Cross-chain USDC

import { useState } from "react";
import { useCrossChainDeposit, useCctpDepositStatus } from "@chipi-stack/nextjs";
import {
  CCTP_EVM_CHAINS,
  discoverEvmWallets,
  formatCctpEta,
  type CctpFinality,
  type CctpQuote,
} from "@chipi-stack/backend";

const BASE = CCTP_EVM_CHAINS.find((c) => c.key === "base")!;

export function FundFromBase() {
  const { quote, depositAsync, isLoading, error } = useCrossChainDeposit();
  const [quotes, setQuotes] = useState<Record<CctpFinality, CctpQuote> | null>(null);
  const [status, setStatus] = useState("");
  const [burnTxHash, setBurnTxHash] = useState<string | null>(null);
  // Resumes on any device after the page closed: keep the burn hash.
  const followed = useCctpDepositStatus({ burnTxHash, getBearerToken: getToken });

  const showQuotes = async () => setQuotes(await quote({ chain: BASE, amount: "25" }));

  const fund = async (finality: CctpFinality) => {
    const [evmWallet] = await discoverEvmWallets();
    if (!evmWallet) throw new Error("No EVM wallet is installed");
    const result = await depositAsync({
      provider: evmWallet.provider,
      chain: BASE,
      amount: "25",
      walletAddress: wallet.address, // the Chipi wallet: the only possible recipient
      finality,
      getBearerToken: getToken, // asked fresh at every step; tokens expire during the wait
      onStatus: ({ step, eta, burnTxHash }) => {
        if (burnTxHash) setBurnTxHash(burnTxHash);
        setStatus(`${step}: ${formatCctpEta(eta)}`);
      },
    });
    console.log("minted on Starknet:", result.mintTxHash);
  };

  return (
    <div>
      <button onClick={showQuotes}>Quote 25 USDC from Base</button>
      {quotes && (
        <>
          <button onClick={() => fund("standard")} disabled={isLoading}>
            Free, {formatCctpEta(quotes.standard.eta)}: receive {quotes.standard.receivesUsdc} USDC
          </button>
          <button onClick={() => fund("fast")} disabled={isLoading}>
            {formatCctpEta(quotes.fast.eta)} for {quotes.fast.feeUsdc} USDC: receive {quotes.fast.receivesUsdc}
          </button>
        </>
      )}
      <p>{status}</p>
      {followed.data?.status === "MINTED" && <p>Arrived: {followed.data.mintTx}</p>}
      {error && <p>{error.message}</p>}
    </div>
  );
}

import { useCrossChainWithdraw } from "@chipi-stack/nextjs";
import { CCTP_EVM_CHAINS, formatCctpEta } from "@chipi-stack/backend";
import type { WalletData } from "@chipi-stack/types";

const BASE = CCTP_EVM_CHAINS.find((c) => c.key === "base")!;

export function WithdrawToBase({ chipiWallet, recipient }: { chipiWallet: WalletData; recipient: string }) {
  const { withdrawAsync, isLoading, error } = useCrossChainWithdraw();

  const withdraw = async () => {
    const result = await withdrawAsync({
      wallet: chipiWallet,
      usePasskey: true,
      externalUserId,
      chain: BASE,
      recipient, // checked: hex, not zero, EIP-55 when it carries mixed case
      amount: "7.81",
      getBearerToken: getToken,
      onStatus: ({ step, eta }) => console.log(step, formatCctpEta(eta)),
    });
    console.log("delivered on Base:", result.destTxHash, "sponsored:", result.quote.sponsored);
  };

  return (
    <button onClick={withdraw} disabled={isLoading}>
      {error ? error.message : "Withdraw 7.81 USDC to Base"}
    </button>
  );
}

import { ChipiServerSDK, CCTP_EVM_CHAINS, cctpQuote } from "@chipi-stack/backend";

export async function resumeDeposit(burnTxHash: string, chipiWallet: string) {
  const sdk = new ChipiServerSDK({ apiPublicKey: "pk_prod_...", apiSecretKey: "sk_prod_..." });
  const base = CCTP_EVM_CHAINS.find((c) => c.key === "base")!;

  // Both speeds for 25 USDC from Base: fee in bps and base units, net amount, ETA.
  const quotes = await cctpQuote({ sourceDomain: base.domain, destinationDomain: 25, amount: "25" });

  // Register a burn the browser made but never registered (idempotent).
  await sdk.registerCctpDeposit({
    burnTxHash,
    sourceDomain: base.domain,
    mintRecipient: chipiWallet,
    amountUsdc: quotes.standard.amountUsdc,
  });
  // PENDING | MINTED (with mintTx) | FAILED | UNREGISTERED
  return sdk.getCctpDepositStatus(burnTxHash);
}

import { Connection } from "@solana/web3.js";
import { ChipiBrowserSDK } from "@chipi-stack/backend";
import { depositFromSolana, solanaUsdcBalance, type SolanaWalletSigner } from "@chipi-stack/backend/solana";

const connection = new Connection("https://api.mainnet-beta.solana.com", "confirmed");
const phantom = (window as unknown as { solana: SolanaWalletSigner }).solana;
const sdk = new ChipiBrowserSDK({ apiPublicKey: "pk_prod_..." });

export async function fundFromSolana(owner: string) {
  const { usdc, hasRentForBurn } = await solanaUsdcBalance(connection, owner);
  if (!hasRentForBurn) throw new Error("add about 0.005 SOL for the fee and the message rent");
  if (usdc < 1_000_000n) throw new Error("not enough USDC");

  const burn = await depositFromSolana({
    connection,
    wallet: phantom,
    owner,
    amount: 1_000_000n, // 1 USDC, base units
    starknetRecipient: wallet.address, // the Chipi wallet: the only possible recipient
  });
  // Chipi mints on Starknet from here on, even if the page closes.
  await sdk.registerCctpDeposit(
    { burnTxHash: burn.burnTxHash, sourceDomain: burn.sourceDomain, mintRecipient: wallet.address, amountUsdc: "1" },
    bearerToken
  );
  return burn.burnTxHash;
}

import { Connection } from "@solana/web3.js";
import { cctpFees, cctpMaxFee, CCTP_STARKNET_DOMAIN, parseUsdc } from "@chipi-stack/backend";
import {
  SOLANA_CCTP,
  buildCctpWithdrawToSolanaCalls,
  isSolanaWalletAddress,
  solanaUsdcAtaExists,
} from "@chipi-stack/backend/solana";

export async function withdrawCalls(owner: string, humanAmount: string) {
  if (!isSolanaWalletAddress(owner)) throw new Error("that is not a Solana wallet address");
  const connection = new Connection(SOLANA_CCTP.defaultRpc, "confirmed");
  if (!(await solanaUsdcAtaExists(connection, owner))) {
    throw new Error("this wallet has no USDC account yet; receive any USDC on Solana once first");
  }
  const amount = parseUsdc(humanAmount);
  const fees = await cctpFees(CCTP_STARKNET_DOMAIN, SOLANA_CCTP.domain);
  return buildCctpWithdrawToSolanaCalls({ amount, owner, maxFee: cctpMaxFee(amount, fees.fast) });
}