Send tokens across wallets

# Add a script for the transfer quickstart
npm pkg set scripts.send-tokens="tsx --env-file=.env send-tokens.ts"

# Create or reactivate the virtual environment
python3 -m venv .venv
source .venv/bin/activate

# Install runtime dependencies
pip install circle-developer-controlled-wallets python-dotenv

import { initiateDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";

// Replace the source and destination constants with your own wallet values
const SOURCE_WALLET_ADDRESS: string = "0x..."; // Used with blockchain to identify the source wallet
const SOURCE_WALLET_BLOCKCHAIN = "0x..."; // Used with blockchain to identify the source wallet
const DESTINATION_WALLET_ADDRESS: string = "0x..."; // Recipient wallet address
const DESTINATION_WALLET_ID: string = "..."; // Used for post-transfer balance check only
const ARC_TESTNET_USDC: string = "0x3600000000000000000000000000000000000000";
const TRANSFER_AMOUNT_USDC: string = "5"; // Token quantity as a string

// Initialize the wallets client
const client = initiateDeveloperControlledWalletsClient({
  apiKey: process.env.CIRCLE_API_KEY!,
  entitySecret: process.env.CIRCLE_ENTITY_SECRET!,
});

async function main() {
  // Validate the wallet inputs
  if (
    SOURCE_WALLET_ADDRESS === "YOUR_SOURCE_WALLET_ADDRESS" ||
    DESTINATION_WALLET_ID === "YOUR_DESTINATION_WALLET_ID" ||
    DESTINATION_WALLET_ADDRESS === "YOUR_DESTINATION_WALLET_ADDRESS"
  ) {
    throw new Error(
      "Replace the wallet constants at the top of send-tokens.ts before running the script.",
    );
  }

  // Create the transfer transaction
  const transferResponse = await client.createTransaction({
    blockchain: SOURCE_WALLET_BLOCKCHAIN,
    walletAddress: SOURCE_WALLET_ADDRESS,
    tokenAddress: ARC_TESTNET_USDC, // USDC contract address on Arc Testnet; replace for other chains
    destinationAddress: DESTINATION_WALLET_ADDRESS,
    amount: [TRANSFER_AMOUNT_USDC],
    fee: {
      type: "level",
      config: { feeLevel: "MEDIUM" }, // Gas fee strategy: LOW, MEDIUM, or HIGH
    },
  });

  const transactionId = transferResponse.data?.id;
  let currentState = transferResponse.data?.state ?? "";

  if (!transactionId) {
    throw new Error("Transaction creation failed: no ID returned");
  }

  console.log("Transfer response:", transferResponse.data);

  // Wait for the transfer to finish
  const terminalStates = new Set(["COMPLETE", "FAILED", "CANCELLED", "DENIED"]);

  while (!terminalStates.has(currentState)) {
    await new Promise((resolve) => setTimeout(resolve, 3000));
    const pollResponse = await client.getTransaction({ id: transactionId });
    const tx = pollResponse.data?.transaction;
    currentState = tx?.state ?? "";
    console.log("Transaction response:", pollResponse.data);

    if (currentState === "COMPLETE") break;
  }

  if (currentState !== "COMPLETE") {
    throw new Error(`Transaction ended in state: ${currentState}`);
  }

  // Check the recipient balance
  const destinationBalanceResponse = await client.getWalletTokenBalance({
    id: DESTINATION_WALLET_ID,
  });

  console.log("Wallet balance response:", destinationBalanceResponse.data);
}

main().catch((err) => {
  console.error("Error:", err.message || err);
  process.exit(1);
});

from circle.web3 import utils, developer_controlled_wallets
from dotenv import load_dotenv
import os
import time
import json

load_dotenv()

# Set transfer inputs
SOURCE_WALLET_ADDRESS = "YOUR_SOURCE_WALLET_ADDRESS"
SOURCE_WALLET_BLOCKCHAIN = "ARC-TESTNET"
DESTINATION_WALLET_ID = "YOUR_DESTINATION_WALLET_ID"
DESTINATION_WALLET_ADDRESS = "YOUR_DESTINATION_WALLET_ADDRESS"
ARC_TESTNET_USDC = "0x3600000000000000000000000000000000000000"
TRANSFER_AMOUNT_USDC = "5"

# Initialize the wallets client
client = utils.init_developer_controlled_wallets_client(
    api_key=os.getenv("CIRCLE_API_KEY"),
    entity_secret=os.getenv("CIRCLE_ENTITY_SECRET")
)

transactions_api = developer_controlled_wallets.TransactionsApi(client)
wallets_api = developer_controlled_wallets.WalletsApi(client)

# Validate the wallet inputs
if (
    SOURCE_WALLET_ADDRESS == "YOUR_SOURCE_WALLET_ADDRESS"
    or DESTINATION_WALLET_ID == "YOUR_DESTINATION_WALLET_ID"
    or DESTINATION_WALLET_ADDRESS == "YOUR_DESTINATION_WALLET_ADDRESS"
):
    raise ValueError(
        "Replace the wallet constants at the top of send_tokens.py before running the script."
    )

try:
    # Create the transfer transaction
    request = developer_controlled_wallets.CreateTransferTransactionForDeveloperRequest.from_dict({
        "walletAddress": SOURCE_WALLET_ADDRESS,
        "blockchain": SOURCE_WALLET_BLOCKCHAIN,
        "destinationAddress": DESTINATION_WALLET_ADDRESS,
        "tokenAddress": ARC_TESTNET_USDC,
        "amounts": [TRANSFER_AMOUNT_USDC],
        "feeLevel": "MEDIUM"
    })

    transfer_response = transactions_api.create_developer_transaction_transfer(request)
    transfer_data = transfer_response.data.to_dict()
    transaction_id = transfer_data["id"]
    current_state = transfer_data["state"]

    print(json.dumps(json.loads(transfer_response.model_dump_json()), indent=2))

    # Wait for the transfer to finish
    terminal_states = {"COMPLETE", "FAILED", "CANCELLED", "DENIED"}

    while current_state not in terminal_states:
        time.sleep(3)
        poll_response = transactions_api.get_transaction(id=transaction_id)
        transaction = poll_response.data.to_dict()["transaction"]
        current_state = transaction["state"]
        print(json.dumps(json.loads(poll_response.model_dump_json()), indent=2))

    if current_state != "COMPLETE":
        raise RuntimeError(f"Transaction ended in state: {current_state}")

    # Check the recipient balance
    destination_balance_response = wallets_api.list_wallet_balance(id=DESTINATION_WALLET_ID)
    print(json.dumps(json.loads(destination_balance_response.model_dump_json()), indent=2))
except developer_controlled_wallets.ApiException as e:
    print("Exception when calling the Circle Wallets API: %s\n" % e)

npm run send-tokens

python send_tokens.py

Transfer response: {
  id: "6f10...",
  state: "INITIATED"
}
Transaction response: {
  transaction: {
    id: "6f10...",
    state: "COMPLETE",
    blockchain: "ARC-TESTNET",
    txHash: "0x..."
  }
}
Wallet balance response: {
  tokenBalances: [
    {
      token: [Object],
      amount: "5"
    }
  ]
}

{
  "data": {
    "id": "6f10...",
    "state": "INITIATED"
  }
}
{
  "data": {
    "transaction": {
      "id": "6f10...",
      "state": "COMPLETE",
      "blockchain": "ARC-TESTNET",
      "tx_hash": "0x..."
    }
  }
}
{
  "data": {
    "token_balances": [
      {
        "amount": "5",
        "token": {
          "symbol": "USDC"
        }
      }
    ]
  }
}