STRK20 privacy pool

@starkware-libs:registry=https://npm.pkg.github.com

//npm.pkg.github.com/:_authToken=YOUR_TOKEN

npm install @starkware-libs/starknet-privacy-sdk

import { deriveAccountLeafViewingKey, type ViewingKeyContext } from "starkzap";

class MySigner implements SignerInterface {
  async deriveViewingKey(context: ViewingKeyContext): Promise<string> {
    return deriveAccountLeafViewingKey(this.privateKey, context);
  }
}

import { StarkZap } from "starkzap";
import { connectPrivacy } from "starkzap/privacy";

const sdk = new StarkZap({ network: "mainnet" });
const wallet = await sdk.connectWallet({ account: { signer } });

const privacy = await connectPrivacy(wallet, {
  poolContractAddress: POOL,
  prover: PROVER,
  discovery: DISCOVERY,
  paymaster: {
    url: "https://my-app.example.com/api/paymaster/mainnet",
    fee: { mode: "sponsored" },
    // Ceiling on what one quote may withdraw for its fee, in base units of the
    // fee token, and the forwarder addresses allowed to receive it. Both come
    // from your paymaster operator.
    maxFee: 10n ** 19n,
    allowedFeeRecipients: [FORWARDER],
  },
});

ohttp: { relayUrl: OHTTP_RELAY }

import type { ViewingKeyDerivation } from "starkzap/privacy";

const fromWalletKdf: ViewingKeyDerivation = async (context, signer) => {
  // context: { chainId, accountAddress, poolAddress, keyIndex? }
  // signer:  the account's own signer, for schemes that reach key material
  //          through it or delegate to a device
  return myWallet.deriveViewingKey(context); // 0x-prefixed hex
};

const requirement = await privacy.discoverRequirement(wallet.address, token.address);
const registered = requirement !== 0; // SetupRequirement.Register === 0

export async function recipientReady(recipient: string): Promise<boolean> {
  const address = recipient.trim();
  try {
    const { channels } = await privacy.discoverChannels([address]);
    return Boolean(channels?.get(address)?.publicKey);
  } catch {
    return false;
  }
}

import { Amount, fromAddress } from "starkzap";
import { waitForFundedBalance } from "starkzap/privacy";

const amount = Amount.parse("100", token);

const hash = await privacy.send(
  (b) =>
    b
      .with(token.address, (t) => t.deposit({ amount: amount.toBase() }))
      .surplusTo(wallet.address),
  {
    // Relayed alongside the pool action. `calls()` resolves the builder without
    // sending, so every ERC20 and protocol helper is available here.
    invoke: await wallet.tx().approve(token, fromAddress(POOL), amount).calls(),
    autoRegister: true,
    autoSetup: true,
    autoDiscover: { notes: "refresh", channels: "refresh" },
    provingBlockId: await waitForFundedBalance(
      wallet.getProvider(),
      token,
      fromAddress(wallet.address),
      amount.toBase()
    ),
  }
);

// 1. Public approve so the pool can pull the funds.
const approve = await wallet
  .tx()
  .approve(token, fromAddress(POOL), amount)
  .send();
await approve.wait();

// 2. The private deposit — the same call as above, without `invoke`.
const hash = await privacy.send(
  (b) =>
    b
      .with(token.address, (t) => t.deposit({ amount: amount.toBase() }))
      .surplusTo(wallet.address),
  {
    autoRegister: true,
    autoSetup: true,
    autoDiscover: { notes: "refresh", channels: "refresh" },
    provingBlockId: await waitForFundedBalance(
      wallet.getProvider(),
      token,
      fromAddress(wallet.address),
      amount.toBase()
    ),
  }
);

const hash = await privacy.send(
  (b) =>
    b
      .with(token.address, (t) =>
        t.transfer({ recipient: recipient.trim(), amount: amount.toBase() })
      )
      .surplusTo(wallet.address),
  {
    autoSetup: true,
    autoSelectNotes: "naive",
    autoDiscover: { notes: "refresh", channels: "refresh" },
  }
);

const hash = await privacy.send(
  (b) =>
    b
      .with(token.address, (t) =>
        t.withdraw({ recipient: recipient.trim(), amount: amount.toBase() })
      )
      .surplusTo(wallet.address),
  {
    autoSelectNotes: "naive",
    autoDiscover: { notes: "refresh", channels: "refresh" },
  }
);

const { notes } = await privacy.discoverNotes();

const balances = tokens.map((token) => {
  const owned = notes.get(BigInt(token.address)) ?? [];
  const total = owned.reduce((sum, note) => sum + note.amount, 0n);
  return {
    token,
    private: Amount.fromRaw(total, token),
    notes: owned.length,
  };
});

const { warnings, feeAction } = await privacy.simulate((b) =>
  b
    .with(token, (t) => t.withdraw({ recipient, amount }))
    .surplusTo(wallet.address)
);

if (warnings.length > 0) {
  // Ask the user. `USER_LINKAGE` is the one to expect on a withdrawal.
}

const fee = await privacy.quote();
console.log(fee.feeAction.amount); // bigint, base units of fee.feeAction.token

// What the paymaster reckons the gas costs, when it reports it.
if (fee.gas) {
  console.log(fee.gas.estimatedInGasToken, fee.gas.suggestedMaxInGasToken);
}

import type { ProvableAttempt } from "starkzap/privacy";

const hash = await privacy.send(compose, {
  wait: {
    onAttempt: ({ attempt, head, provingBlock, ready }: ProvableAttempt) => {
      if (ready) return;
      console.log(`#${attempt}: head ${head}, proving block ${provingBlock} — polling`);
    },
  },
});

import { screeningVerdict } from "starkzap/privacy";

switch (screeningVerdict(err)) {
  case "rejected":
    // The source address is blocked. Retrying will not help.
    break;
  case "unavailable":
    // Screening is down and deposits fail closed. Retry later.
    break;
  default:
    // Not a screening failure — surface the underlying error.
}