@crossmint/wallets-sdk

npm install @crossmint/wallets-sdk

import { createCrossmint, CrossmintWallets } from '@crossmint/wallets-sdk';

const crossmint = createCrossmint({
  apiKey: process.env.CROSSMINT_API_KEY
});

const crossmintWallets = CrossmintWallets.from(crossmint);

const wallet = await crossmintWallets.createWallet({
  chain: "base-sepolia",
  signer: { type: "api-key" },
  owner: "userId:my-app:user-123"
});

console.log("Wallet address:", wallet.address);

// Guest agent - consistent wallet per user
const GUEST_WALLET_LOCATOR = "userId:crossmint-merchant-guest:demo-user";

const guestWallet = await crossmintWallets.createWallet({
  chain: "base-sepolia",
  signer: { type: "api-key" },
  owner: GUEST_WALLET_LOCATOR
});

// Host agent - wallet per host user
const hostWallet = await crossmintWallets.createWallet({
  chain: "base-sepolia",
  signer: { type: "api-key" },
  owner: `userId:crossmint-merchant-host:${userScopeId}`
});

import { EVMWallet } from '@crossmint/wallets-sdk';

const evmWallet = EVMWallet.from(wallet);

console.log("EVM address:", evmWallet.address);
console.log("Chain:", evmWallet.chain);

const signature = await evmWallet.signTypedData({
  domain: {
    name: "X402",
    version: "1",
    chainId: 84532,
    verifyingContract: "0x..."
  },
  message: {
    from: evmWallet.address,
    to: "0x...",
    maxAmount: "1000000", // 1 USDC
    nonce: 1
  },
  primaryType: "Payment",
  types: {
    Payment: [
      { name: "from", type: "address" },
      { name: "to", type: "address" },
      { name: "maxAmount", type: "uint256" },
      { name: "nonce", type: "uint256" }
    ]
  },
  chain: evmWallet.chain as any
});

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

// Send a transaction
const tx = await evmWallet.sendTransaction({
  to: "0xRecipientAddress",
  value: 1000000n, // 0.001 ETH in wei
  data: "0x"
});

console.log("Transaction hash:", tx.hash);

const deploymentTx = await evmWallet.sendTransaction({
  to: wallet.address,
  value: 1n, // 1 wei
  data: "0x"
});

console.log("Wallet deployed:", deploymentTx.hash);

import { CrossmintWallets, createCrossmint, type Wallet } from '@crossmint/wallets-sdk';

class Guest {
  wallet!: Wallet<any>;
  
  async onStart() {
    // Initialize Crossmint SDK and create wallet with API key signer
    const crossmint = createCrossmint({
      apiKey: this.env.CROSSMINT_API_KEY
    });
    const crossmintWallets = CrossmintWallets.from(crossmint);

    // Create or get wallet using consistent locator
    const locator = "userId:crossmint-merchant-guest:demo-user";
    this.wallet = await crossmintWallets.createWallet({
      chain: "base-sepolia",
      signer: { type: "api-key" },
      owner: locator
    });

    console.log(`Guest wallet ready: ${this.wallet.address}`);
  }
}

import { CrossmintWallets, createCrossmint, type Wallet } from '@crossmint/wallets-sdk';

class Host {
  wallet!: Wallet<any>;
  
  async init() {
    // Create host wallet for receiving payments
    const crossmint = createCrossmint({
      apiKey: this.env.CROSSMINT_API_KEY
    });
    const crossmintWallets = CrossmintWallets.from(crossmint);

    this.wallet = await crossmintWallets.createWallet({
      chain: "base-sepolia",
      signer: { type: "api-key" },
      owner: `userId:crossmint-merchant-host:${this.userScopeId}`
    });

    const recipient = this.wallet.address as `0x${string}`;

    // Store wallet address in KV
    await this.env.SECRETS.put(
      `usersByHash:${this.userScopeId}`,
      JSON.stringify({ walletAddress: recipient, userId: this.userScopeId })
    );

    console.log(`Host wallet created: ${recipient}`);
  }
}

interface Wallet<T> {
  address: string;
  chain: string;
  // Additional properties specific to wallet type
}

class EVMWallet {
  address: string;
  chain: string;
  
  static from(wallet: Wallet<any>): EVMWallet;
  
  signTypedData(params: {
    domain: any;
    message: any;
    primaryType: string;
    types: any;
    chain: any;
  }): Promise<{ signature: string }>;
  
  sendTransaction(params: {
    to: string;
    value: bigint;
    data: string;
  }): Promise<{ hash: string }>;
}

// Good: Deterministic locator
const locator = `userId:my-app:${userId}`;

// Bad: Random locator
const locator = `userId:my-app:${Math.random()}`;

import { createPublicClient, http } from 'viem';
import { baseSepolia } from 'viem/chains';

async function checkWalletDeployment(walletAddress: string): Promise<boolean> {
  const publicClient = createPublicClient({
    chain: baseSepolia,
    transport: http("https://sepolia.base.org")
  });

  const code = await publicClient.getCode({
    address: walletAddress as `0x${string}`
  });

  return code !== undefined && code !== '0x' && code.length > 2;
}

const isDeployed = await checkWalletDeployment(wallet.address);

if (!isDeployed) {
  console.log("Deploying wallet...");
  const evmWallet = EVMWallet.from(wallet);
  
  await evmWallet.sendTransaction({
    to: wallet.address,
    value: 1n,
    data: "0x"
  });
  
  console.log("Wallet deployed!");
}

try {
  await evmWallet.sendTransaction({ to, value, data });
} catch (error) {
  const errorMsg = error instanceof Error ? error.message : String(error);
  
  if (errorMsg.includes('insufficient') || errorMsg.includes('balance')) {
    throw new Error("Insufficient ETH balance for gas fees");
  }
  
  throw error;
}