Withdrawals

npm install @daimo/sdk

import "@daimo/sdk/web/theme.css";
import { DaimoSDKProvider } from "@daimo/sdk/web";

export function App({ children }) {
  return <DaimoSDKProvider>{children}</DaimoSDKProvider>;
}

import type { DaimoWithdrawalDestination } from "@daimo/sdk/web";

async function createSession(input: {
  destination: DaimoWithdrawalDestination;
  fundingMode: "injected-wallet" | "manual";
}) {
  const response = await fetch("/api/withdrawals/session", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(input),
  });
  if (!response.ok) throw new Error("failed to create withdrawal");
  return response.json() as Promise<{
    sessionId: string;
    clientSecret: string;
  }>;
}

<DaimoWithdrawal
  {...withdrawalProps}
  resolveEns={(name) =>
    fetch(`/api/custom-ens?name=${encodeURIComponent(name)}`).then(
      async (response) => {
        if (!response.ok) throw new Error("failed to resolve ENS name");
        return response.json() as Promise<{ address: `0x${string}` }>;
      },
    )
  }
/>

return (
  <>
    {withdrawalOpen && (
      <DaimoWithdrawal
        {...withdrawalProps}
        embedded={false}
        onClose={() => setWithdrawalOpen(false)}
      />
    )}
  </>
);

import { DaimoWithdrawal } from "@daimo/sdk/web";

export function Withdrawal({ user, wallet }) {
  return (
    <DaimoWithdrawal
      fundingMode="injected-wallet"
      walletSource="evm"
      connectToAddress={wallet.address}
      evmProvider={wallet.provider}
      contactStorageScope={user.id}
      createSession={createSession}
      onPaymentStarted={() => console.log("withdrawal submitted")}
      onPaymentCompleted={() => console.log("withdrawal completed")}
    />
  );
}

<DaimoWithdrawal
  fundingMode="manual"
  amountUnits="25.00"
  contactStorageScope={user.id}
  createSession={createSession}
  sendManualTransaction={async ({ receiverAddress, amountUnits }) => {
    const txHash = await treasury.sendUsdc({
      to: receiverAddress,
      amountUnits,
    });
    return { txHash };
  }}
/>

<DaimoWithdrawal
  fundingMode="manual"
  contactStorageScope={user.id}
  createSession={createSession}
  sendManualTransaction={async ({
    receiverAddress,
    amountUnits,
    expiresAt,
  }) => {
    const txHash = await embeddedWallet.sendUsdc({
      to: receiverAddress,
      amountUnits,
      expiresAt,
    });
    return { txHash };
  }}
/>

import { isNativeToken } from "@daimo/sdk/common";
import { DaimoWithdrawal } from "@daimo/sdk/web";
import { encodeFunctionData, erc20Abi, getAddress } from "viem";

<DaimoWithdrawal
  fundingMode="manual"
  connectToAddress={embeddedWallet.address}
  sourceTokenFilter={(token) => embeddedWallet.canSend(token)}
  contactStorageScope={user.id}
  createSession={createSession}
  sendManualTransaction={async ({ receiverAddress, source }) => {
    if (!source) throw new Error("source token is required");
    const tokenAddress = getAddress(source.token.token);
    const transaction = isNativeToken(source.token.chainId, tokenAddress)
      ? {
          chainId: source.token.chainId,
          to: receiverAddress,
          value: source.amount,
        }
      : {
          chainId: source.token.chainId,
          to: tokenAddress,
          data: encodeFunctionData({
            abi: erc20Abi,
            functionName: "transfer",
            args: [receiverAddress, source.amount],
          }),
        };
    const txHash = await embeddedWallet.sendTransaction(transaction);
    return { txHash };
  }}
/>;

type DaimoWithdrawalManualTransferRequest = {
  sessionId: string;
  receiverAddress: Address;
  destination: DaimoWithdrawalDestination;
  expiresAt: number;
  amountUnits: string;
  source?: {
    address: Address;
    token: DaimoPayToken;
    amount: bigint;
  };
};

type DaimoWithdrawalManualTransferResult = void | { txHash?: `0x${string}` };