Privacy (STRK20 shield/unshield)

import {
  ChipiProofProvider,
  derivePoolKeypair,
  deriveCompanionKeypair,
  deriveCompanionAddress,
  requestGasFunding,
  waitForFunding,
  execShield,
  GAS_FUND_STRK,
} from "@chipi-stack/core";
import { RpcProvider } from "starknet";

const pool = await derivePoolKeypair({ anchorSecret, seedDomainTag: wallet.address });
const companion = await deriveCompanionKeypair(anchorSecret);
const companionAddress = deriveCompanionAddress({
  publicKey: companion.publicKey,
  classHash: COMPANION_CLASS_HASH,
});

const provider = new RpcProvider({ nodeUrl: "https://api.cartridge.gg/x/starknet/mainnet" });
await requestGasFunding(companionAddress, {
  baseUrl: "https://api.chipipay.com/v1",
  apiKey: apiPublicKey,
  getBearerToken: () => getToken(),
});
await waitForFunding(provider, companionAddress, { strk: GAS_FUND_STRK });
const result = await execShield(
  {
    provider,
    chainId: "0x534e5f4d41494e",
    companionAddress,
    companionKey: companion.privateKey,
    classHash: COMPANION_CLASS_HASH,
    poolKey: BigInt(pool.privateKey),
    provingProvider: new ChipiProofProvider({
      baseUrl: "https://api.chipipay.com/v1",
      apiKey: apiPublicKey,
      getBearerToken: () => getToken(),
      chainId: "0x534e5f4d41494e",
    }),
  },
  USDC_ADDRESS,
  1_000_000n,
);

import {
  ChipiProofProvider,
  derivePoolKeypair,
  deriveCompanionKeypair,
  deriveCompanionAddress,
  execShieldMany,
  STRK_ADDRESS,
} from "@chipi-stack/core";
import { RpcProvider } from "starknet";

const pool = await derivePoolKeypair({ anchorSecret, seedDomainTag: wallet.address });
const companion = await deriveCompanionKeypair(anchorSecret);
const ctx = {
  provider: new RpcProvider({ nodeUrl: "https://api.cartridge.gg/x/starknet/mainnet" }),
  chainId: "0x534e5f4d41494e",
  companionAddress: deriveCompanionAddress({
    publicKey: companion.publicKey,
    classHash: COMPANION_CLASS_HASH,
  }),
  companionKey: companion.privateKey,
  classHash: COMPANION_CLASS_HASH,
  poolKey: BigInt(pool.privateKey),
  provingProvider: new ChipiProofProvider({
    baseUrl: "https://api.chipipay.com/v1",
    apiKey: apiPublicKey,
    getBearerToken: () => getToken(),
    chainId: "0x534e5f4d41494e",
  }),
};

// One tx, one proof, ONE 4-STRK fee for the whole batch.
const shielded = await execShieldMany(ctx, [
  { token: USDC_ADDRESS, amount: 1_000_000n }, // 1 USDC
  { token: STRK_ADDRESS, amount: 10n ** 18n }, // 1 STRK
]);
console.log(shielded.transactionHash, shielded.via);

import {
  execUnshield,
  getPrivateBalance,
  requestGasFunding,
  waitForFunding,
  sweepCompanion,
  GAS_FUND_STRK,
  type CompanionCtx,
} from "@chipi-stack/core";
import { Account } from "starknet";

declare const ctx: CompanionCtx; // the same ctx used to shield
declare const gasTankAddress: string; // leftover fronted STRK returns here

// Exact private amounts per token (viewing-key note scan, read-only).
const account = new Account({
  provider: ctx.provider,
  address: ctx.companionAddress,
  signer: ctx.companionKey,
  cairoVersion: "1",
});
const { byToken } = await getPrivateBalance({
  provider: ctx.provider,
  account,
  viewingKey: ctx.poolKey,
  provingProvider: ctx.provingProvider,
});

// The prover proves against head − 12: wait until it can SEE the state the
// previous operation wrote before compiling the next one.
async function waitProverView(fromBlock: number) {
  for (;;) {
    const b = await ctx.provider.getBlockNumber();
    if (b >= fromBlock + 13) return;
    await new Promise((r) => setTimeout(r, 30_000));
  }
}

const gasOpts = {
  baseUrl: "https://api.chipipay.com/v1",
  apiKey: apiPublicKey,
  getBearerToken: () => getToken(),
};

// `lastOpBlock` starts at the SHIELD's block — the freshly created notes are
// just as invisible to the prover as a fresh withdrawal.
let lastOpBlock = await ctx.provider.getBlockNumber();
for (const [token, amountRaw] of Object.entries(byToken)) {
  if (amountRaw === 0n) continue;
  await waitProverView(lastOpBlock);
  await requestGasFunding(ctx.companionAddress, gasOpts); // refuel EVERY op
  await waitForFunding(ctx.provider, ctx.companionAddress, { strk: GAS_FUND_STRK });

  const result = await execUnshield(ctx, token, amountRaw);
  lastOpBlock = await ctx.provider.getBlockNumber();

  // The sweep IS the delivery of the user's money here — strict, not
  // best-effort, so a failed delivery throws instead of claiming success.
  await sweepCompanion({
    provider: ctx.provider,
    companionAddress: ctx.companionAddress,
    companionKey: ctx.companionKey,
    gasTank: gasTankAddress,
    deliverToken: { address: token, to: wallet.address },
    strict: true,
  });
  console.log(`unshielded ${token}: ${result.transactionHash}`);
}