SDK Options

npm install @cashmerelabs/cashmere-agent-sdk

import { CashmereCCTP } from '@cashmerelabs/cashmere-agent-sdk';

const cctp = new CashmereCCTP({
  evm: { privateKey: process.env.EVM_PRIVATE_KEY! },
});

// Quote first: route, CCTP version, fee and duration; nothing is sent
const sim = await cctp.simulate({ from: 'ethereum', to: 'arbitrum', amount: '100' });

// Then send: the SDK fetches the signed quote, approves USDC and waits for confirmation
const { txHash, explorerUrl } = await cctp.transfer({
  from: 'ethereum',
  to: 'arbitrum',
  amount: '100',
  recipient: '0xDestinationAddress',
});

/**
 * Fetches a signed fee quote for CashmereCCTP.transferV2.
 */
export async function getTransferV2Quote({
  localDomain,
  destinationDomain,
  isNative,
}: {
  localDomain: number;
  destinationDomain: number;
  isNative: boolean;
}) {
  const res = await fetch(
    'https://gas.cashmere.exchange/getEcdsaSig_native?' +
      new URLSearchParams({
        localDomain: String(localDomain),
        destinationDomain: String(destinationDomain),
        isV2: 'true',
        isNative: String(isNative),
      }),
    { signal: AbortSignal.timeout(15_000) },
  );
  if (!res.ok) throw new Error(`Gas API error ${res.status}`);
  return (await res.json()) as {
    fee: string;         // wei when isNative, otherwise USDC base units (6 decimals)
    deadline: string;    // unix seconds
    signature: string;   // 65-byte ECDSA signature, 0x-prefixed
    isNative: boolean;
    cctpVersion: number;
  };
}

package cashmere

import (
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type EcdsaQuote struct {
    Fee         string `json:"fee"`       // wei when IsNative, otherwise USDC base units
    Deadline    string `json:"deadline"`  // unix seconds
    Signature   string `json:"signature"` // 65 bytes, 0x-prefixed
    IsNative    bool   `json:"isNative"`
    CctpVersion int    `json:"cctpVersion"`
}

var client = &http.Client{Timeout: 15 * time.Second}

func GetECDSAQuote(local, dest uint32, isNative bool) (*EcdsaQuote, error) {
    url := fmt.Sprintf(
        "https://gas.cashmere.exchange/getEcdsaSig_native?localDomain=%d&destinationDomain=%d&isV2=true&isNative=%t",
        local, dest, isNative,
    )
    resp, err := client.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("gas API returned status %s", resp.Status)
    }

    var quote EcdsaQuote
    if err := json.NewDecoder(resp.Body).Decode(&quote); err != nil {
        return nil, err
    }
    return &quote, nil
}

// Cargo.toml: anyhow = "1", serde = { version = "1", features = ["derive"] },
// reqwest = { version = "0.12", features = ["json"] }
use anyhow::{bail, Result};
use serde::Deserialize;

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Ed25519Quote {
    pub signature: String,          // 64 bytes, 0x-prefixed
    pub message: String,            // the signed bytes, 0x-prefixed
    pub public_key: String,         // 32 bytes, 0x-prefixed
    pub destination_domain: String,
    pub fee: String,                // the native unit when is_native, otherwise USDC base units
    pub deadline: String,           // unix seconds
    pub is_native: bool,
    pub version: u8,
}

pub async fn get_ed25519_quote(local: u32, dest: u32, is_native: bool) -> Result<Ed25519Quote> {
    let url = format!(
        "https://gas.cashmere.exchange/getEd25519Sig_native?localDomain={local}&destinationDomain={dest}&isNative={is_native}&version=2"
    );
    let resp = reqwest::get(&url).await?;
    if !resp.status().is_success() {
        bail!("gas api error: {}", resp.status());
    }
    Ok(resp.json::<Ed25519Quote>().await?)
}