Arcane Compliance: Send a Private Transaction on Stellar

npm install @auditable/privacy-pool-zk-sdk

import { PrivacyPoolSDK } from "@auditable/privacy-pool-zk-sdk";

async function initSDK(): Promise<PrivacyPoolSDK> {
  // Fetch your circuit assets — adjust paths to match your build output.
  const [wasmBinary, circuitWasm, zkey] = await Promise.all([
    fetch("/assets/privacy_pool_bg.wasm").then((r) => r.arrayBuffer()),
    fetch("/assets/circuit.wasm").then((r) => r.arrayBuffer()),
    fetch("/assets/circuit_final.zkey").then((r) => r.arrayBuffer()),
  ]);

  const sdk = await PrivacyPoolSDK.init({
    wasmBinary: new Uint8Array(wasmBinary),
    circuitWasm: new Uint8Array(circuitWasm),
    zkey: new Uint8Array(zkey),
  });

  console.log("PrivacyPoolSDK initialized");
  return sdk;
}

import type { StellarWallet } from "./your-wallet-adapter"; // your wallet integration

async function deriveStealthAddress(
  sdk: PrivacyPoolSDK,
  wallet: StellarWallet,
  stellarAddress: string
): Promise<string> {
  // 1. Build the canonical message the user must sign.
  const signMessage =
    PrivacyPoolSDK.buildStealthAddressSignMessage(stellarAddress);

  // 2. Ask the wallet to sign the message (exact API depends on your wallet adapter).
  const signature = await wallet.signMessage(signMessage);

  // 3. Derive the stealth address from the signature.
  const stealthAddress =
    await sdk.generateStealthAddressFromStellarSignature(signature);

  console.log("Stealth address:", stealthAddress);
  return stealthAddress;
}

async function buildDepositProof(sdk: PrivacyPoolSDK) {
  // Build the output coin for the deposit.
  // See the SDK TypeScript types for the full argument shape of generateCoin.
  const coin = await sdk.generateCoin(/* coin parameters */);

  // Generate the proof.
  // Use proveWithdrawal() when spending an existing coin from the pool.
  // See the SDK TypeScript types for the full argument shape of proveTransaction.
  const { proof, publicSignals } = await sdk.proveTransaction(
    /* transaction witness */
  );

  // Serialize proof and public signals for the Soroban call.
  const proofBytes = sdk.proofToHex(proof);
  const pubSignalsBytes = sdk.publicToHex(publicSignals);

  return { coin, proofBytes, pubSignalsBytes };
}

import * as StellarSdk from "@stellar/stellar-sdk";

async function submitTransact(
  wallet: StellarWallet,
  contractAddress: string,
  stellarAddress: string,
  proofBytes: string,
  pubSignalsBytes: string,
  encodedAuditPayload: string // encrypted audit bytes from your SDK/application flow
): Promise<string> {
  const server = new StellarSdk.SorobanRpc.Server(
    "https://soroban-testnet.stellar.org"
  );
  const account = await server.getAccount(stellarAddress);

  // Build the Soroban transaction.
  // transact(from, proof_bytes, pub_signals_bytes, encoded)
  const contract = new StellarSdk.Contract(contractAddress);
  const tx = new StellarSdk.TransactionBuilder(account, {
    fee: "1000000",
    networkPassphrase: StellarSdk.Networks.TESTNET,
  })
    .addOperation(
      contract.call(
        "transact",
        StellarSdk.nativeToScVal(stellarAddress, { type: "address" }),
        StellarSdk.nativeToScVal(Buffer.from(proofBytes, "hex"),      { type: "bytes" }),
        StellarSdk.nativeToScVal(Buffer.from(pubSignalsBytes, "hex"), { type: "bytes" }),
        StellarSdk.nativeToScVal(Buffer.from(encodedAuditPayload, "hex"), { type: "bytes" })
      )
    )
    .setTimeout(30)
    .build();

  // Simulate, sign, and submit.
  const prepared = await server.prepareTransaction(tx);
  const signed = await wallet.signTransaction(prepared.toXDR());
  const result = await server.sendTransaction(
    StellarSdk.TransactionBuilder.fromXDR(signed, StellarSdk.Networks.TESTNET)
  );

  console.log("Transaction submitted:", result.hash);
  return result.hash;
}