Transfer Tokens

Transfer tokens from your wallet

This guide will walk you through the process of sending a token transfer from your wallet using the Crossmint transactions API. You can transfer various ERC20 tokens using this method. One of the benefits of non-custodial Smart Wallets is that you can hold and send different cryptocurrencies.

Prerequisites

Ensure you have a wallet created. You can follow the Quickstart for server wallets to prepare one. You will need:

• API Key: Ensure you have your Crossmint API key with the scope wallets:transactions.create.
• Wallet Locator: The locator of the wallet you want to transfer the tokens from.

Sending the Transaction

We will use the Create Transaction API.

Ethereum

1. First, we need to prepare the transaction that will send 4 USDC to the recipient. This will encode the function call for the transfer function for sending 4 USDC to a recipient.

   prepareTransaction.ts

   import { encodeFunctionData, parseUnits } from 'viem';
   
   // USDC contract address on Base
   const usdcAddress = '0x036CbD53842c5426634e7929541eC2318f3dCF7e';
   
   // Recipient address and amount to send (4 USDC)
   const recipient = '0xRecipientAddress'; // Replace with the recipient's address
   const amount = parseUnits('4', 6);      // 4 USDC (6 decimals)
   
   // Encode the data for the transfer function
   const data = encodeFunctionData({
       abi: [
           {
               "constant": false,
               "inputs": [
                   { "name": "recipient", "type": "address" },
                   { "name": "amount", "type": "uint256" }
               ],
               "name": "transfer",
               "outputs": [{ "name": "", "type": "bool" }],
               "type": "function"
           }
       ],
       functionName: 'transfer',
       args: [recipient, amount]
   });
   
   console.log('Transaction Data:', data);

2. With our encoded transaction data, we need to set the following parameters for the /transactions endpoint:

   • calls: An array of objects with the following properties:
     • to: The token contract address.
     • value: Set to "0" for token transfers.
     • data: The encoded data generated in the previous step.
   • chain: The chain where the transaction will be sent.
   • signer: One of the wallet’s signers, typically the admin signer.

   sendTransaction.ts

   const walletLocator = '0x...';
   const apiKey = 'sk_staging...';
   const tokenContractAddress = '0x036CbD53842c5426634e7929541eC2318f3dCF7e';
   const recipientAddress = '0x...';
   const signerAddress = '0x...';
   const encodedData = '0x...'; // Encoded transfer function data
   
   async function sendTransaction() {
       const response = await fetch(`https://api.crossmint.com/2022-06-09/wallets/${walletLocator}/transactions`, {
           method: 'POST',
           headers: {
               'Content-Type': 'application/json',
               'X-API-KEY': apiKey,
           },
           body: JSON.stringify({
               params: {
                   calls: [
                       {
                           to: tokenContractAddress,
                           value: '0',
                           data: encodedData,
                       },
                   ],
                   chain: 'base-sepolia',
                   signer: `evm-keypair:${signerAddress}`,
               },
           }),
       });
   
       const data = await response.json();
       console.log(data);
   }
   
   sendTransaction().catch(console.error);

1. First, we need to prepare the transaction that will send 4 USDC to the recipient. This will encode the function call for the transfer function for sending 4 USDC to a recipient.

   prepareTransaction.ts

   import { encodeFunctionData, parseUnits } from 'viem';
   
   // USDC contract address on Base
   const usdcAddress = '0x036CbD53842c5426634e7929541eC2318f3dCF7e';
   
   // Recipient address and amount to send (4 USDC)
   const recipient = '0xRecipientAddress'; // Replace with the recipient's address
   const amount = parseUnits('4', 6);      // 4 USDC (6 decimals)
   
   // Encode the data for the transfer function
   const data = encodeFunctionData({
       abi: [
           {
               "constant": false,
               "inputs": [
                   { "name": "recipient", "type": "address" },
                   { "name": "amount", "type": "uint256" }
               ],
               "name": "transfer",
               "outputs": [{ "name": "", "type": "bool" }],
               "type": "function"
           }
       ],
       functionName: 'transfer',
       args: [recipient, amount]
   });
   
   console.log('Transaction Data:', data);

2. With our encoded transaction data, we need to set the following parameters for the /transactions endpoint:

   • calls: An array of objects with the following properties:
     • to: The token contract address.
     • value: Set to "0" for token transfers.
     • data: The encoded data generated in the previous step.
   • chain: The chain where the transaction will be sent.
   • signer: One of the wallet’s signers, typically the admin signer.

   sendTransaction.ts

   const walletLocator = '0x...';
   const apiKey = 'sk_staging...';
   const tokenContractAddress = '0x036CbD53842c5426634e7929541eC2318f3dCF7e';
   const recipientAddress = '0x...';
   const signerAddress = '0x...';
   const encodedData = '0x...'; // Encoded transfer function data
   
   async function sendTransaction() {
       const response = await fetch(`https://api.crossmint.com/2022-06-09/wallets/${walletLocator}/transactions`, {
           method: 'POST',
           headers: {
               'Content-Type': 'application/json',
               'X-API-KEY': apiKey,
           },
           body: JSON.stringify({
               params: {
                   calls: [
                       {
                           to: tokenContractAddress,
                           value: '0',
                           data: encodedData,
                       },
                   ],
                   chain: 'base-sepolia',
                   signer: `evm-keypair:${signerAddress}`,
               },
           }),
       });
   
       const data = await response.json();
       console.log(data);
   }
   
   sendTransaction().catch(console.error);

1. First, we need to prepare the transaction that will send 1 USDC to the recipient. This will encode the function call for the transfer function.

   For the transaction parameters:

   • Use "11111111111111111111111111111111" as the blockhash (Crossmint will replace this)
   • Use "11111111111111111111111111111112" as the payerKey (Crossmint will replace this)
   • Do not include the sending wallet in the signers array
   • Do not sign the transaction (Crossmint will handle signing)

   The transaction will be properly configured on Crossmint’s servers with the correct values before execution. Crossmint will also pay for the transaction fee.

   prepareTransaction.ts

   import { TransactionMessage, PublicKey, VersionedTransaction, Connection } from "@solana/web3.js";
   import {
       createTransferInstruction,
       getAssociatedTokenAddress,
       TOKEN_PROGRAM_ID,
       createAssociatedTokenAccountInstruction,
       ASSOCIATED_TOKEN_PROGRAM_ID,
   } from "@solana/spl-token";
   import bs58 from "bs58";
   
   const connection = new Connection("https://api.devnet.solana.com", "confirmed");
   
   const USDC_MINT = new PublicKey("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"); // USDC Mint Address on Solana Devnet
   const senderAddress = "your_address";
   const recipientAddress = "recipient_address";
   const amount = 1; // 1 USDC
   
   async function createUSDCTransferTransaction(senderAddress, recipientAddress, amount) {
       // Convert addresses to PublicKeys
       const senderPublicKey = new PublicKey(senderAddress);
       const recipientPublicKey = new PublicKey(recipientAddress);
   
       // Get associated token accounts for both addresses
       const senderTokenAccount = await getAssociatedTokenAddress(USDC_MINT, senderPublicKey);
       const recipientTokenAccount = await getAssociatedTokenAddress(USDC_MINT, recipientPublicKey);
       console.log("Sender token account:", senderTokenAccount);
       console.log("Recipient token account:", recipientTokenAccount);
   
       // Amount needs to be converted to base units (multiply by 10^6 for USDC)
       const amountInBaseUnits = amount * 1_000_000;
   
       // Create new transaction
       const instructions = [];
       const recipientAccountInfo = await connection.getAccountInfo(recipientTokenAccount);
       console.log("Recipient account info:", recipientAccountInfo);
       if (!recipientAccountInfo) {
           instructions.push(
               createAssociatedTokenAccountInstruction(
                   senderPublicKey,
                   recipientTokenAccount,
                   recipientPublicKey
                   USDC_MINT,
                   TOKEN_PROGRAM_ID,
                   ASSOCIATED_TOKEN_PROGRAM_ID
               )
           );
       }
   
       // Add the transfer instruction
       instructions.push(
           createTransferInstruction(
               senderTokenAccount,
               recipientTokenAccount,
               senderPublicKey,
               amountInBaseUnits,
               [],
               TOKEN_PROGRAM_ID
           )
       );
   
       const message = new TransactionMessage({
           instructions,
           recentBlockhash: "11111111111111111111111111111111",
           payerKey: new PublicKey("11111111111111111111111111111112"),
       }).compileToV0Message();
   
       const transaction = new VersionedTransaction(message);
   
       // Serialize and encode transaction
       return bs58.encode(transaction.serialize());
   }
   
   const base58Transaction = await createUSDCTransferTransaction(senderAddress, recipientAddress, amount);
   console.log("Base58 encoded transaction:", base58Transaction);

2. Send the transaction to the /transactions endpoint. We only need to send the transaction field with the base58 encoded transaction generated in the previous step.

   sendTransaction.ts

   const apiKey = "sk_staging...";
   const walletLocator = "0x...";
   
   async function sendTransaction(serializedTransactionStr) {
       const response = await fetch(`https://staging.crossmint.com/api/2022-06-09/wallets/${walletLocator}/transactions`, {
           method: "POST",
           headers: {
               "X-API-KEY": apiKey,
               "Content-Type": "application/json",
           },
           body: JSON.stringify({
               params: {
                   transaction: serializedTransactionStr,
               },
           }),
       });
   
       const data = await response.json();
       console.log(data);
   }
   
   sendTransaction("your_base58_encoded_transaction_string").catch(console.error);