Transfer Tokens

import { CrossmintWallets, WalletsApiClient, createCrossmint } from "@crossmint/wallets-sdk";
import { privateKeyToAccount } from "viem/accounts";

const crossmint = createCrossmint({
    apiKey: "<your-server-api-key>",
});

const crossmintWallets = CrossmintWallets.from(crossmint);
const apiClient = new WalletsApiClient(crossmint);

const account = privateKeyToAccount(
    process.env.EXTERNAL_WALLET_PRIVATE_KEY as `0x${string}`
);

const wallet = await crossmintWallets.getWallet(
    "<wallet-address>",
    { chain: "base-sepolia", signer: { type: "external-wallet" } }
);

// 1. Create the transaction in prepare-only mode
const { transactionId } = await wallet.send(
    "0x0D282906CDD8F6934d60E4dCAa79fa5B1c7a1925",
    "usdxm",
    "3.14",
    {
        experimental_prepareOnly: true,
        experimental_signer: `external-wallet:${account.address}`,
    }
);

// 2. Fetch the pending transaction to get the message that needs signing
const txResponse = await apiClient.getTransaction(
    wallet.address,
    transactionId
);
if ("error" in txResponse) {
    throw new Error(`Failed to get transaction: ${JSON.stringify(txResponse)}`);
}

const pendingApproval = txResponse.approvals?.pending[0];
if (!pendingApproval) {
    throw new Error("No pending approval found");
}

// 3. Sign the pending approval message with your viem private key
const signature = await account.signMessage({
    message: { raw: pendingApproval.message as `0x${string}` },
});

// 4. Submit the approval
const result = await wallet.approve({
    transactionId,
    options: {
        experimental_approval: {
            signature,
            signer: `external-wallet:${account.address}`,
        },
    },
});

console.log("Transaction approved:", result);

import { useWallet } from '@crossmint/client-sdk-react-native-ui';

const { wallet } = useWallet();

const { hash, explorerLink } = await wallet.send("0x0D282906CDD8F6934d60E4dCAa79fa5B1c7a1925", "usdxm", "3.14");

import CrossmintClient
import Wallet

let sdk = CrossmintSDK.shared

let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
    chain: .baseSepolia,
    signer: .email("user@example.com")
)

let result = try await wallet.send("0x0D282906CDD8F6934d60E4dCAa79fa5B1c7a1925", "usdxm", 3.14)

import { privateKeyToAccount } from "viem/accounts";

// ============================
// Config (replace placeholders)
// ============================
const API_BASE_URL = "https://staging.crossmint.com";
const API_VERSION = "2025-06-09";

const API_KEY = "<x-api-key>";
const WALLET_ADDRESS = "<walletAddress>";
const CHAIN = "base-sepolia";
const TOKEN = "usdc";

// The externally-owned address that will sign the approval message:
const EXTERNAL_WALLET_ADDRESS = "<externalWalletAddress>";

const RECIPIENT_ADDRESS = "<recipientAddress>";

const AMOUNT = "0.69";

const headers = {
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json",
};

// ============================
// STEP 1: Create the transaction
// ============================
const createTransferUrl = `${API_BASE_URL}/api/${API_VERSION}/wallets/${WALLET_ADDRESS}/tokens/${CHAIN}:${TOKEN}/transfers`;

const createTransferPayload = {
    recipient: RECIPIENT_ADDRESS,
    amount: AMOUNT,
    signer: `external-wallet:${EXTERNAL_WALLET_ADDRESS}`,
};

const createTransferRes = await fetch(createTransferUrl, {
    method: "POST",
    headers,
    body: JSON.stringify(createTransferPayload),
});

if (!createTransferRes.ok) {
    throw new Error(
        `Failed to create transfer: ${createTransferRes.status} ${await createTransferRes.text()}`
    );
}

const tx = await createTransferRes.json();
const txId = tx.id;
const messageToSign = tx?.approvals?.pending?.[0]?.message;

if (!messageToSign) {
    throw new Error(
        "No approval message found. Ensure signer is external-wallet and that an approval is pending."
    );
}

console.log("txId:", txId);
console.log("messageToSign:", messageToSign);

// ============================
// STEP 2: Sign the approval message (Viem)
// ============================
// IMPORTANT: sign the message EXACTLY as returned (a raw hex string).
const account = privateKeyToAccount(`0x${"<privateKey>"}`);

const signature = await account.signMessage({
    message: { raw: messageToSign },
});

console.log("signature:", signature);

// ============================
// STEP 3: Submit the signature
// ============================
const submitApprovalUrl = `${API_BASE_URL}/api/${API_VERSION}/wallets/${WALLET_ADDRESS}/transactions/${txId}/approvals`;

const submitApprovalPayload = {
    approvals: [
        {
            signer: `external-wallet:${EXTERNAL_WALLET_ADDRESS}`,
            signature,
        },
    ],
};

const submitApprovalRes = await fetch(submitApprovalUrl, {
    method: "POST",
    headers,
    body: JSON.stringify(submitApprovalPayload),
});

if (!submitApprovalRes.ok) {
    throw new Error(
        `Failed to submit approval: ${submitApprovalRes.status} ${await submitApprovalRes.text()}`
    );
}

const approvalResult = await submitApprovalRes.json();
console.log("approvalResult:", approvalResult);

// ============================
// STEP 4 (optional): Check transaction status
// ============================
const getTxUrl = `${API_BASE_URL}/api/${API_VERSION}/wallets/${WALLET_ADDRESS}/transactions/${txId}`;

const getTxRes = await fetch(getTxUrl, { method: "GET", headers });

if (!getTxRes.ok) {
    throw new Error(
        `Failed to fetch transaction: ${getTxRes.status} ${await getTxRes.text()}`
    );
}

const txStatus = await getTxRes.json();
console.log("txStatus:", txStatus);