Send Transactions

This guide will walk you through the process of sending transactions from your wallet using the Crossmint transactions API with custodial signers. Custodial signers enable secure transaction signing without managing private keys directly.

Note: This guide currently only works for wallets set up with a custodial admin signer. We will soon update it to cover all types of signers.

Prerequisites

Ensure you have created a wallet with a custodial signer by following the Server Wallets Quickstart. You will need:

API Key: Ensure you have an API key with the scope: wallets:transactions.create
Wallet Address: The address of your wallet created via the quickstart.

Sending a Transaction

You can send various types of transactions using the Create Transaction API. Here’s how to do it for different chains:

For EVM-based chains like Ethereum, Polygon, Base, etc., you can send transactions as follows:

const walletLocator = '0x...'; // Address of your wallet from the quickstart guide
const apiKey = 'sk_staging...';
const contractAddress = '0x...';

async function sendTransaction() {
    const response = await fetch(
         `https://staging.crossmint.com/api/2022-06-09/wallets/${walletLocator}/transactions`,
        {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-API-KEY': apiKey,
            },
            body: JSON.stringify({
                params: {
                    calls: [{
                        to: contractAddress,
                        value: '0', // Value in wei (0 for contract calls with no ETH transfer)
                        data: '0x1234abcd...', // The encoded function call data
                    }],
                    chain: 'base-sepolia', // Specify your target chain
                },
            }),
        }
    );

    const data = await response.json();
    console.log(data);
    return data;
}

Encoding Contract Function Calls

When interacting with smart contracts, you need to encode your function calls as data. Here’s how to do it:

import { encodeFunctionData } from 'viem';

// Example: Encoding a "transfer" function call for an ERC-20 token
const recipientAddress = '0x...'; // Address of the recipient
const tokenAmount = 1000000n; // 1 token with 6 decimals

// Encode the function call
const data = encodeFunctionData({
    abi: [{
        name: 'transfer',
        type: 'function',
        inputs: [
            { name: 'to', type: 'address' },
            { name: 'amount', type: 'uint256' }
        ],
        outputs: [{ name: '', type: 'bool' }],
        stateMutability: 'nonpayable'
    }],
    args: [recipientAddress, tokenAmount]
});

console.log(data);
// Example output: 0xa9059cbb000000000000000000000000recipientAddressWithout0x00000000000000000000000000000000000000000000000000000000000003e8

For EVM-based chains like Ethereum, Polygon, Base, etc., you can send transactions as follows:

const walletLocator = '0x...'; // Address of your wallet from the quickstart guide
const apiKey = 'sk_staging...';
const contractAddress = '0x...';

async function sendTransaction() {
    const response = await fetch(
         `https://staging.crossmint.com/api/2022-06-09/wallets/${walletLocator}/transactions`,
        {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-API-KEY': apiKey,
            },
            body: JSON.stringify({
                params: {
                    calls: [{
                        to: contractAddress,
                        value: '0', // Value in wei (0 for contract calls with no ETH transfer)
                        data: '0x1234abcd...', // The encoded function call data
                    }],
                    chain: 'base-sepolia', // Specify your target chain
                },
            }),
        }
    );

    const data = await response.json();
    console.log(data);
    return data;
}

Encoding Contract Function Calls

When interacting with smart contracts, you need to encode your function calls as data. Here’s how to do it:

import { encodeFunctionData } from 'viem';

// Example: Encoding a "transfer" function call for an ERC-20 token
const recipientAddress = '0x...'; // Address of the recipient
const tokenAmount = 1000000n; // 1 token with 6 decimals

// Encode the function call
const data = encodeFunctionData({
    abi: [{
        name: 'transfer',
        type: 'function',
        inputs: [
            { name: 'to', type: 'address' },
            { name: 'amount', type: 'uint256' }
        ],
        outputs: [{ name: '', type: 'bool' }],
        stateMutability: 'nonpayable'
    }],
    args: [recipientAddress, tokenAmount]
});

console.log(data);
// Example output: 0xa9059cbb000000000000000000000000recipientAddressWithout0x00000000000000000000000000000000000000000000000000000000000003e8

For Solana, you’ll need to prepare the transaction first, then send it to the API:

Prepare Transaction

Create a transaction with placeholders that Crossmint will replace:

import {
    PublicKey,
    TransactionMessage,
    VersionedTransaction,
    SystemProgram,
    LAMPORTS_PER_SOL
} from "@solana/web3.js";
import base58 from "bs58";

// Your wallet address from the quickstart guide
const fromPublicKey = new PublicKey("your_wallet_address");

// Recipient address
const toPublicKey = new PublicKey("recipient_address");

// Create a transaction (example: sending 0.01 SOL)
const message = new TransactionMessage({
    instructions: [
        SystemProgram.transfer({
            fromPubkey: fromPublicKey,
            toPubkey: toPublicKey,
            lamports: 0.01 * LAMPORTS_PER_SOL,
        }),
        // Add more instructions as needed
    ],
    // Use placeholder values - Crossmint will replace these
    recentBlockhash: "11111111111111111111111111111111",
    payerKey: new PublicKey("11111111111111111111111111111112"),
}).compileToV0Message();

const transaction = new VersionedTransaction(message);

// Serialize and encode the transaction
const serializedTransaction = transaction.serialize();
const serializedTransactionBase58 = base58.encode(serializedTransaction);

console.log("Base58 Encoded Transaction:", serializedTransactionBase58);

The transaction will be properly configured on Crossmint’s servers with the correct blockhash and payer before execution. Crossmint will also handle signing the transaction with your wallet’s custodial signer.

Send Transaction

Now send the transaction to the Crossmint API:

const walletLocator = 'your_wallet_address'; // Your Solana wallet address from the quickstart guide
const apiKey = 'sk_staging...';

async function sendTransaction(serializedTransactionBase58: string) {
    const response = await fetch(
        `https://staging.crossmint.com/api/2022-06-09/wallets/${walletLocator}/transactions`,
        {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-API-KEY': apiKey,
            },
            body: JSON.stringify({
                params: {
                    transaction: serializedTransactionBase58
                }
            }),
        }
    );

    const data = await response.json();
    console.log(data);
    return data;
}

// Call the function with your base58-encoded transaction
sendTransaction("your_base58_encoded_transaction").catch(console.error);

For more complex Solana transactions, such as token transfers or interactions with programs, you’d add the appropriate instructions to the transaction message before serializing it.

Transaction Status

After sending a transaction, you can check its status by querying the transaction endpoint:

const apiKey = 'sk_staging...';
const walletLocator = '0x...';
const transactionId = 'transaction-id-from-previous-response';

async function checkTransactionStatus() {
    const response = await fetch(
        `https://api.crossmint.com/2022-06-09/wallets/${walletLocator}/transactions/${transactionId}`, {
            method: 'GET',
            headers: {
                'X-API-KEY': apiKey,
                'Content-Type': 'application/json',
            },
        }
    );

    const data = await response.json();
    console.log(data);
    return data;
}

checkTransactionStatus().catch(console.error);

Learn More

For specific transaction types, check out these detailed guides:

Transfer Native Tokens

Send ETH, SOL, and other native tokens.

Transfer Tokens

Send ERC-20, SPL, and other fungible tokens.

Transfer NFTs

Send NFTs to other wallets.

Create Wallet

Learn how to create wallets.

Introduction

Wallets

Authentication

Tokenization (Minting)

Verifiable Credentials

Checkout

Prerequisites

Sending a Transaction

Encoding Contract Function Calls

Encoding Contract Function Calls

Transaction Status

Learn More

Transfer Native Tokens

Transfer Tokens

Transfer NFTs

Create Wallet

Introduction

Wallets

Authentication

Tokenization (Minting)

Verifiable Credentials

Checkout

​Prerequisites

​Sending a Transaction

​Encoding Contract Function Calls

​Encoding Contract Function Calls

​Transaction Status

​Learn More

Transfer Native Tokens

Transfer Tokens

Transfer NFTs

Create Wallet

Prerequisites

Sending a Transaction

Encoding Contract Function Calls

Encoding Contract Function Calls

Transaction Status

Learn More