Quickstart: ECDSA and Merkle campaigns.

import { createPublicClient, createWalletClient, http, zeroAddress, type Address } from "viem";
import { sepolia } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";
import { createSepoliaEncryptor } from "@tokenops/sdk/fhe";
import {
  createConfidentialAirdropFactoryClient,
  createEcdsaAirdropClient,
  encryptUint64,
  setOperator,
  signClaimAuthorization,
} from "@tokenops/sdk/fhe-airdrop";

const account = privateKeyToAccount(process.env.SEPOLIA_PRIVATE_KEY as `0x${string}`);
const publicClient = createPublicClient({ chain: sepolia, transport: http(process.env.RPC_URL) });
const walletClient = createWalletClient({ account, chain: sepolia, transport: http(process.env.RPC_URL) });
const token = "0x..." as Address; // your ERC-7984 token

// Node encryptor over the Zama Sepolia relayer. In a browser, use
// createSepoliaEncryptorWeb from "@tokenops/sdk/fhe/web", or pass a ZamaSDK.
const encryptor = await createSepoliaEncryptor({ rpcUrl: process.env.RPC_URL });

try {
  // The factory address resolves from DEPLOYED_ADDRESSES on mainnet and Sepolia.
  const factory = createConfidentialAirdropFactoryClient({ publicClient, walletClient, encryptor });
  const now = Math.floor(Date.now() / 1000);

  // The per-claim fee is the factory's to set and is frozen into the instance,
  // so you declare the most you accept. Reading it first bounds you at today's
  // fee; UINT96_MAX accepts whatever resolves. See the gas-fees concept page.
  const resolvedGasFee = await factory.resolveGasFee(account.address);

  // common has no admin field, the factory makes the sender admin
  const { airdrop } = await factory.createEcdsaAirdrop({
    params: {
      common: {
        token,
        startTime: now - 60, // already open, so the claim below cannot hit ClaimNotStarted
        endTime: now + 30 * 86400, // at least 60s past the latest block
        canExtendClaimWindow: false,
        unwrappable: false,
        complianceAdmin: zeroAddress, // zero = you; also seeded as a client delegate with decrypt rights
        maxAcceptedGasFee: resolvedGasFee,
      },
      signer: account.address,
      dedupMode: "perAddress", // frozen at create; read it back with readDedupMode()
    },
    mode: "clone",
    userSalt: "0x0000000000000000000000000000000000000000000000000000000000000001",
  });

  // Funding routes through the factory, which needs operator approval on the token.
  await setOperator({ publicClient, walletClient, token, spender: factory.address });
  // Writes return the hash without waiting, and the next write's gas estimate
  // runs against the latest state, so wait for each one the next depends on.
  const fundHash = await factory.fundAirdrop({ airdrop, amount: 1_000_000n });
  await publicClient.waitForTransactionReceipt({ hash: fundHash });

  // Bind the ciphertext to the recipient: a non-empty proof is (instance, claimant).
  const recipient = account.address;
  const encryptedInput = await encryptUint64({
    encryptor,
    contractAddress: airdrop,
    userAddress: recipient,
    value: 1_000_000n,
  });
  const dedupId = "0x0000000000000000000000000000000000000000000000000000000000000001" as const;
  const deadline = BigInt(now + 3600);
  const signature = await signClaimAuthorization({
    walletClient,
    airdrop,
    chainId: sepolia.id,
    recipient,
    encryptedAmountHandle: encryptedInput.handle,
    dedupId,
    deadline,
  });

  const claimant = createEcdsaAirdropClient({ publicClient, walletClient, address: airdrop });
  await claimant.claim({ encryptedInput, dedupId, deadline, signer: account.address, signature });
} finally {
  encryptor.terminate();
}