Quickstart

import {
  createInMemorySigner,
  createSignerFromPrivateKeyBytes,
} from "@umbra-privacy/sdk";

// Ephemeral — disappears when the process exits. Test/dev only.
const signer = await createInMemorySigner();

// Reusable — pass your own secret bytes (e.g. from a Solana CLI keypair file).
// const secret = Uint8Array.from(JSON.parse(readFileSync("keypair.json", "utf8")));
// const signer = await createSignerFromPrivateKeyBytes(secret);

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

import { getUmbraClient } from "@umbra-privacy/sdk";

const client = await getUmbraClient({
  signer,
  network: "mainnet",
  rpcUrl: "https://api.mainnet-beta.solana.com",
  rpcSubscriptionsUrl: "wss://api.mainnet-beta.solana.com",
  indexerApiEndpoint: "https://utxo-indexer.api.umbraprivacy.com",
  // NOTE: there is NO relayerApiEndpoint here — see step 9.
});

import { getUserRegistrationFunction } from "@umbra-privacy/sdk/registration";
import { getUserRegistrationProver } from "@umbra-privacy/sdk/zk-prover";

const register = getUserRegistrationFunction(
  { client },
  { zkProver: getUserRegistrationProver() },
);

const signatures = await register({
  confidential: true, // register the X25519 key (Shared-mode balances + receiver-burnable notes)
  anonymous: true,    // register the user commitment (anonymous mixer transfers) — needs the zkProver above
});

console.log(`Registered in ${signatures.length} transaction(s)`);

import { getATAIntoETADirectDepositorFunction } from "@umbra-privacy/sdk/deposit";
import { createU64 } from "@umbra-privacy/sdk/types";
import { address } from "@solana/kit";

const deposit = getATAIntoETADirectDepositorFunction({ client });

const MINT = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); // USDC (mainnet)
const amount = createU64({ value: 1_000_000n }); // 1 USDC (6 decimals)

const result = await deposit(
  signer.address, // credit your own ETA
  MINT,
  amount,
);

console.log("Deposit queued:", result.queueSignature);
if (result.callback?.status === "finalized") {
  console.log("Callback confirmed:", result.callback.signature);
}

import { getETAIntoATAWithdrawerFunction } from "@umbra-privacy/sdk/withdrawal";

const withdraw = getETAIntoATAWithdrawerFunction({ client });

const result = await withdraw(
  signer.address, // destination ATA owner
  MINT,
  amount,
);

console.log("Withdraw queued:", result.queueSignature);
if (result.callback?.status === "finalized") {
  console.log("Callback confirmed:", result.callback.signature);
}

import { getATAIntoReceiverBurnableStealthPoolNoteCreatorFunction } from "@umbra-privacy/sdk/deposit";
import { getATAIntoStealthPoolNoteCreatorProver } from "@umbra-privacy/sdk/zk-prover";
import { address } from "@solana/kit";

const zkProver = getATAIntoStealthPoolNoteCreatorProver();

const createNote = getATAIntoReceiverBurnableStealthPoolNoteCreatorFunction(
  { client },
  { zkProver },
);

const RECIPIENT = address("RecipientWalletAddressHere");

const signatures = await createNote({
  destinationAddress: RECIPIENT,
  mint: MINT,
  amount,
});
console.log("Stealth Pool Note created:", signatures[0]);

import { getBurnableStealthPoolNoteScannerFunction } from "@umbra-privacy/sdk/burn";

const scan = getBurnableStealthPoolNoteScannerFunction({ client });

// Zero-arg. No (treeIndex, start, end) — the cursor is managed by the SDK.
const result = await scan();

console.log("Self-burnable from ETA: ", result.etaToStealthPoolSelfBurnable.length);
console.log("Receiver-burnable from ETA: ", result.etaToStealthPoolReceiverBurnable.length);
console.log("Self-burnable from ATA: ", result.ataToStealthPoolSelfBurnable.length);
console.log("Receiver-burnable from ATA: ", result.ataToStealthPoolReceiverBurnable.length);
console.log("Scanned trees:", result.scannedTrees.length);

import {
  getReceiverBurnableStealthPoolNoteIntoETABurnerFunction,
} from "@umbra-privacy/sdk/burn";
import { getUmbraRelayer } from "@umbra-privacy/sdk";
import { getClaimReceiverClaimableUtxoIntoEncryptedBalanceProver } from "@umbra-privacy/sdk/zk-prover";

const zkProver = getClaimReceiverClaimableUtxoIntoEncryptedBalanceProver();
const r        = getUmbraRelayer({ apiEndpoint: "https://relayer.api.umbraprivacy.com" });

const burn = getReceiverBurnableStealthPoolNoteIntoETABurnerFunction(
  { client },
  {
    fetchBatchMerkleProof: client.fetchBatchMerkleProof!,
    zkProver,
    relayer: {
      submitBurn:        r.submitClaim,        // alias: BurnSubmitter ≡ ClaimSubmitter
      pollBurnStatus:    r.pollClaimStatus,    // alias: BurnStatusPoller ≡ ClaimStatusPoller
      getRelayerAddress: r.getRelayerAddress,
    },
  },
);

// Tag the scanned notes with their burn kind (the scanner does not).
const notes = result.etaToStealthPoolReceiverBurnable.map(
  (n) => ({ ...n, kind: "receiver-burnable" as const }),
);
if (notes.length > 0) {
  const out = await burn([notes[0]]);
  for (const [batchIndex, batch] of out.batches) {
    console.log(
      "Batch",   batchIndex,
      "status:", batch.status,
      "id:",     batch.requestId,
      "sig:",    batch.callbackSignature ?? batch.txSignature,
    );
  }
}

import {
  createInMemorySigner,
  getUmbraClient,
  getUmbraRelayer,
} from "@umbra-privacy/sdk";
import { createU64 } from "@umbra-privacy/sdk/types";
import { address } from "@solana/kit";
import { getUserRegistrationFunction } from "@umbra-privacy/sdk/registration";
import {
  getATAIntoETADirectDepositorFunction,
  getATAIntoReceiverBurnableStealthPoolNoteCreatorFunction,
} from "@umbra-privacy/sdk/deposit";
import { getETAIntoATAWithdrawerFunction } from "@umbra-privacy/sdk/withdrawal";
import {
  getBurnableStealthPoolNoteScannerFunction,
  getReceiverBurnableStealthPoolNoteIntoETABurnerFunction,
} from "@umbra-privacy/sdk/burn";
import {
  getUserRegistrationProver,
  getATAIntoStealthPoolNoteCreatorProver,
  getClaimReceiverClaimableUtxoIntoEncryptedBalanceProver,
} from "@umbra-privacy/sdk/zk-prover";

async function main() {
  // 1. Signer (use your wallet adapter / a persisted keypair in production).
  const signer = await createInMemorySigner();

  // 2. Client (relayer is built separately, below).
  const client = await getUmbraClient({
    signer,
    network: "mainnet",
    rpcUrl: "https://api.mainnet-beta.solana.com",
    rpcSubscriptionsUrl: "wss://api.mainnet-beta.solana.com",
    indexerApiEndpoint: "https://utxo-indexer.api.umbraprivacy.com",
  });

  const MINT = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); // USDC

  // 3. Register (idempotent; anonymous mode needs the registration prover).
  const register = getUserRegistrationFunction(
    { client },
    { zkProver: getUserRegistrationProver() },
  );
  await register({ confidential: true, anonymous: true });

  // 4. Deposit (ATA → ETA).
  const deposit = getATAIntoETADirectDepositorFunction({ client });
  await deposit(signer.address, MINT, createU64({ value: 1_000_000n }));

  // 5. Withdraw (ETA → ATA).
  const withdraw = getETAIntoATAWithdrawerFunction({ client });
  await withdraw(signer.address, MINT, createU64({ value: 1_000_000n }));

  // 6. ZK provers (Groth16).
  const createProver = getATAIntoStealthPoolNoteCreatorProver();
  const burnProver   = getClaimReceiverClaimableUtxoIntoEncryptedBalanceProver();

  // 7. Create a receiver-burnable Stealth Pool Note.
  const createNote = getATAIntoReceiverBurnableStealthPoolNoteCreatorFunction(
    { client },
    { zkProver: createProver },
  );
  const RECIPIENT = address("RecipientWalletAddressHere");
  await createNote({ destinationAddress: RECIPIENT, mint: MINT, amount: createU64({ value: 500_000n }) });

  // 8. Scan (zero-arg, cursor in client.utxoDataStore).
  const scan = getBurnableStealthPoolNoteScannerFunction({ client });
  const result = await scan();

  // 9. Burn the first receiver-burnable note into the recipient's ETA.
  const r = getUmbraRelayer({ apiEndpoint: "https://relayer.api.umbraprivacy.com" });
  const burn = getReceiverBurnableStealthPoolNoteIntoETABurnerFunction(
    { client },
    {
      fetchBatchMerkleProof: client.fetchBatchMerkleProof!,
      zkProver: burnProver,
      relayer: {
        submitBurn:        r.submitClaim,
        pollBurnStatus:    r.pollClaimStatus,
        getRelayerAddress: r.getRelayerAddress,
      },
    },
  );

  // Tag scanned notes with their burn kind before passing to the burner.
  const candidates = result.etaToStealthPoolReceiverBurnable.map(
    (n) => ({ ...n, kind: "receiver-burnable" as const }),
  );
  if (candidates.length > 0) {
    const out = await burn([candidates[0]]);
    for (const [, b] of out.batches) {
      console.log("Burn status:", b.status, "sig:", b.callbackSignature ?? b.txSignature);
    }
  }
}

main().catch(console.error);