Crossmint Smart Wallets

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-guest-agent:evm:smart"
});

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

import { CrossmintEmbeddedWallet } from "@crossmint/client-sdk-react-ui";

const { login } = useCrossmintWallet();

// Trigger email OTP
await login({ email: "[email protected]" });

// User enters code, wallet is created
const wallet = await crossmintWallets.getWallet();

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

console.log("Address:", wallet.address);
// 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb

// Check deployment status
const isDeployed = await checkWalletDeployment(
  wallet.address,
  "base-sepolia"
);
console.log("Deployed:", isDeployed);  // false

// Guest signs payment (pre-deployed wallet)
const signature = await wallet.signTypedData({
  domain: { chainId: 84532, ... },
  types: { Payment: [...] },
  message: {
    amount: "50000",
    to: "0xHostWallet",
    currency: "0xUSDC"
  }
});

// Facilitator deploys wallet + settles payment
const tx = await facilitator.settle(signature);

console.log("Deployment TX:", tx.hash);
// 0xabc...def

const isDeployed = await checkWalletDeployment(
  wallet.address,
  "base-sepolia"
);
console.log("Deployed:", isDeployed);  // true

// Can now receive tokens
await usdcContract.transfer(wallet.address, "1000000");

// Signatures validated via EIP-1271
const signature = await wallet.signMessage("Hello");
const valid = await wallet.isValidSignature("Hello", signature);

// 1. Wallet signs message (pre-deployed)
const baseSignature = await wallet.signTypedData(paymentMessage);

// 2. Crossmint wraps with deployment data
const erc6492Signature = [
  factoryAddress,    // Contract factory
  factoryCalldata,   // Deployment parameters
  baseSignature      // Actual signature
].encode();

// 3. Add ERC-6492 magic suffix
const finalSignature = erc6492Signature + "6492649264926492...";

// Verifier receives ERC-6492 signature
function verifyERC6492(signature, message, expectedSigner) {
  // 1. Check for magic suffix
  if (signature.endsWith("6492649264926492...")) {
    // 2. Extract deployment data
    const { factory, calldata, innerSig } = decode(signature);
    
    // 3. Simulate deployment
    const simulatedAddress = computeAddress(factory, calldata);
    
    // 4. Check address matches
    if (simulatedAddress !== expectedSigner) {
      throw new Error("Address mismatch");
    }
    
    // 5. Verify signature against simulated contract
    return verifySmartContractSignature(
      simulatedAddress,
      innerSig,
      message
    );
  }
  
  // Standard ECDSA verification
  return verifyECDSA(signature, message, expectedSigner);
}

interface IERC1271 {
  /**
   * @dev Should return whether the signature provided is valid for the provided data
   * @param hash      Hash of the data to be signed
   * @param signature Signature byte array associated with _data
   */
  function isValidSignature(
    bytes32 hash,
    bytes memory signature
  ) external view returns (bytes4 magicValue);
}

import { verifyTypedData } from "viem";

// For deployed smart wallets
const valid = await publicClient.call({
  address: wallet.address,
  abi: ERC1271_ABI,
  functionName: "isValidSignature",
  args: [messageHash, signature]
});

if (valid === "0x1626ba7e") {
  console.log("✅ Signature valid");
} else {
  console.log("❌ Signature invalid");
}

contract CrossmintSmartWallet {
  mapping(address => bool) public owners;
  
  function isValidSignature(
    bytes32 hash,
    bytes memory signature
  ) external view returns (bytes4) {
    // Recover signer from signature
    address signer = recoverSigner(hash, signature);
    
    // Check if signer is an owner
    if (owners[signer]) {
      return 0x1626ba7e;  // Valid
    }
    
    return 0xffffffff;  // Invalid
  }
}

const crossmintWallet = await crossmintWallets.createWallet({...});
const x402Signer = createX402Signer(crossmintWallet);

const server = new McpServer({ name: "Event Host" })
  .withX402({
    wallet: x402Signer,  // Works with x402!
    network: "base-sepolia",
    recipient: hostAddress
  });

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

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

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

  // If bytecode exists, wallet is deployed
  return code !== undefined && code !== '0x' && code.length > 2;
}

const deployed = await checkWalletDeployment(
  wallet.address,
  "base-sepolia"
);

if (deployed) {
  console.log("✅ Wallet deployed, can receive tokens");
} else {
  console.log("⚠️ Wallet not deployed yet");
  console.log("💡 First payment will deploy it automatically");
}

export async function deployWallet(wallet: Wallet<any>): Promise<string> {
  console.log("🚀 Deploying wallet on-chain...");

  const evmWallet = EVMWallet.from(wallet);

  // Deploy with minimal self-transfer (1 wei)
  const tx = await evmWallet.sendTransaction({
    to: wallet.address,
    value: 1n,  // 1 wei
    data: "0x"
  });

  console.log(`✅ Wallet deployed! TX: ${tx.hash}`);
  return tx.hash;
}