@auditable/privacy-pool-zk-sdk 0.1.0 → 0.4.0

package/dist/sdk.d.ts

@@ -2,7 +2,7 @@ import { type DecodedDepositorSharedSecretPreimage, type DecodedEphemeralKey, ty
 import { type SharedSecret } from './shared-secret';
 import type { DecodedRecipientSharedSecretPreimage } from './stealth-address';
 import type { CoinData, GeneratedCoin, SDKOptions, StateFile, WithdrawMerkleWitness, WithdrawResult } from './types';
-import { type DepositSlot, type WithdrawalProofPublicParams, type WithdrawSlot } from './withdrawal-transaction-input';
+import { type DepositSlot, type TransactionPublicLegParams, type WithdrawalProofPublicParams, type WithdrawSlot } from './withdrawal-transaction-input';
 export declare class PrivacyPoolSDK {
     private wasm;
     private options;
@@ -32,29 +32,33 @@ export declare class PrivacyPoolSDK {
     /**
      * Generate a new coin with random nullifier, secret, and random shared-secret field elements (dev / self-contained tests).
      * @param amount Stroops encoded as `bigint` or integer `number` (WASM `u64`).
+     * @param assetHiDecimal / assetLoDecimal Decimal Fr strings for Stellar asset contract id (two limbs).
      */
-    generateCoin(amount: bigint | number): GeneratedCoin;
+    generateCoin(amount: bigint | number, assetHiDecimal: string, assetLoDecimal: string): GeneratedCoin;
     /**
      * Generate a coin with the same commitment shape as on-chain deposit: pass `ecdhSharedKey` output (hex x, y).
      * @param amount Stroops (`bigint` | `number`).
      */
-    generateCoinWithSharedSecret(shared: SharedSecret, amount: bigint | number): GeneratedCoin;
+    generateCoinWithSharedSecret(shared: SharedSecret, amount: bigint | number, assetHiDecimal: string, assetLoDecimal: string): GeneratedCoin;
     /**
      * Coin for a depositor `ephemeralKeyScalar` (32-byte hex): `coin.secret = Poseidon255(1)(scalar)` as in `deposit.circom`.
      * @param amount Stroops (`bigint` | `number`).
      */
-    generateCoinFromDepositEphemeralScalarHex(scalarHex: string, amount: bigint | number): GeneratedCoin;
+    generateCoinFromDepositEphemeralScalarHex(scalarHex: string, amount: bigint | number, assetHiDecimal: string, assetLoDecimal: string): GeneratedCoin;
     /**
      * Aligned deposit coin: `secret = Poseidon₁(scalar)` and ECDH shared key from hex coords (e.g. `ecdhSharedKey(scalar, recipient_x, recipient_y)`).
      * @param amount Stroops (`bigint` | `number`).
      */
-    generateCoinForDepositWithSharedHex(scalarHex: string, sharedXHex: string, sharedYHex: string, amount: bigint | number): GeneratedCoin;
+    generateCoinForDepositWithSharedHex(scalarHex: string, sharedXHex: string, sharedYHex: string, amount: bigint | number, assetHiDecimal: string, assetLoDecimal: string): GeneratedCoin;
     /**
      * Merkle root, path, and coin fields for the first withdraw leg (Rust LeanIMT + Poseidon).
      */
     buildWithdrawMerkleWitness(coin: CoinData, state: StateFile): WithdrawMerkleWitness;
     /**
      * Full `Transaction(20,2,2)` withdrawal proof: one real withdraw + dummies, using coin/state and depositor ECDH point (hex).
+     *
+     * Optional **partial public withdraw**: spend the full coin commitment `coin.value` (V), send `publicWithdrawStroops` (W) to the
+     * Stellar receiver, and re-deposit the remainder (V−W) as a new private note to `changeRecipientStealthAddress` (same circuit balance).
      */
     proveWithdrawal(coin: CoinData, state: StateFile, params: {
         withdrawAddressHi: string;
@@ -62,6 +66,10 @@ export declare class PrivacyPoolSDK {
         privKeyScalar: string;
         ephemeralXHex: string;
         ephemeralYHex: string;
+        /** If set, public leg amount W (stroops). Must satisfy 0 < W < V. Remainder (V−W) stays in the pool as a new commitment. */
+        publicWithdrawStroops?: bigint;
+        /** Required when `publicWithdrawStroops` is set: stealth recipient for the change note (typically same as deposit). */
+        changeRecipientStealthAddress?: string;
     }): Promise<WithdrawResult>;
     /**
      * Convert a snarkjs proof JSON to hex bytes for Soroban.
@@ -84,10 +92,11 @@ export declare class PrivacyPoolSDK {
      * `Transaction(20,2,2)` proof from high-level legs: maps to witness input (incl. `"dummy"` ECDH via WASM), then Groth16 → Soroban hex.
      *
      * @param publicParams Public inputs: `stateRoot`, `withdrawAddressHi` / `withdrawAddressLo`, `privKeyScalar` (decimal field strings).
+     * @param publicLegs Public token legs (`publicWithdrawnAssets`, `publicDepositedAssets`, `publicDeposits`, `publicWithdrawals`).
      * @param withdraws Exactly two withdraw slots (`WithdrawObject` or `"dummy"`).
      * @param deposits Exactly two deposit slots (`DepositObject` or `"dummy"`).
      */
-    proveTransaction(publicParams: WithdrawalProofPublicParams, withdraws: [WithdrawSlot, WithdrawSlot], deposits: [DepositSlot, DepositSlot]): Promise<WithdrawResult>;
+    proveTransaction(publicParams: WithdrawalProofPublicParams, publicLegs: TransactionPublicLegParams, withdraws: [WithdrawSlot, WithdrawSlot], deposits: [DepositSlot, DepositSlot]): Promise<WithdrawResult>;
     /**
      * Calculate nullifier hash: Poseidon(nullifier)
      * @param nullifier Nullifier decimal string from coin data

package/dist/types.d.ts

@@ -3,10 +3,15 @@ export interface CoinData {
     nullifier: string;
     secret: string;
     commitment: string;
+    /** Decimal Fr strings for Stellar asset contract id (`asset[0]`, `asset[1]` in `commitment.circom`). */
+    asset_hi: string;
+    asset_lo: string;
 }
 export interface GeneratedCoin {
     coin: CoinData;
     commitment_hex: string;
+    /** 64-char lowercase hex (no `0x`), Fr big-endian for audit `precommitement`. */
+    precommitement_hex: string;
 }
 /** Pool Merkle tree depth (matches `coin::TREE_DEPTH` / `Transaction` circuit). */
 export declare const POOL_MERKLE_TREE_DEPTH = 20;
@@ -23,6 +28,8 @@ export interface WithdrawMerkleWitness {
     value: string;
     nullifier: string;
     secret: string;
+    /** `[asset_hi, asset_lo]` decimal Fr strings (Stellar asset contract id). */
+    withdrawnAsset: [string, string];
     stateRoot: string;
     stateIndex: string;
     /** Length is always {@link POOL_MERKLE_TREE_DEPTH}; each entry is a decimal field element. */

package/dist/withdrawal-transaction-input.d.ts

@@ -3,6 +3,9 @@ import type { WithdrawMerkleWitness } from './types';
 export declare const TRANSACTION_TREE_DEPTH = 20;
 export declare const TRANSACTION_N_INS = 2;
 export declare const TRANSACTION_N_OUTS = 2;
+/** Must match `Transaction(..., publicNInputs, publicNOutputs)` and contract `get_public_slot_config`. */
+export declare const TRANSACTION_PUBLIC_N_INPUTS = 1;
+export declare const TRANSACTION_PUBLIC_N_OUTPUTS = 1;
 /** BN254 scalar field modulus (ark `Fr`, circom signals). */
 export declare const BN254_SCALAR_MOD = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
 /**
@@ -20,11 +23,22 @@ export interface WithdrawalProofPublicParams {
     /** Decimal string, circom `privKeyScalar`. */
     privKeyScalar: string;
 }
+/** Public accounting legs (`publicWithdrawnAssets`, `publicDepositedAssets`, `publicDeposits`, `publicWithdrawals`). */
+export interface TransactionPublicLegParams {
+    publicWithdrawnAssets: Array<[string, string]>;
+    publicDepositedAssets: Array<[string, string]>;
+    publicDeposits: string[];
+    publicWithdrawals: string[];
+}
+/** All-zero public legs (private-only pool moves). */
+export declare function zeroPublicLegs(): TransactionPublicLegParams;
 /** Real withdraw leg; coordinates are decimal field strings (same as `CoinData`). */
 export interface WithdrawObject {
     value: string;
     nullifier: string;
     secret: string;
+    /** Asset contract id as two decimal Fr strings (`asset[0]`, `asset[1]`). */
+    asset: [string, string];
     /** Depositor ECDH point `[x, y]` as decimal strings. */
     ephemeralKeys: [string, string];
     stateSiblings: string[];
@@ -34,12 +48,14 @@ export interface DepositObject {
     value: string;
     nullifier: string;
     ephemeralKeyScalar: string;
+    /** Asset contract id as two decimal Fr strings. */
+    asset: [string, string];
     /** Recipient public key `[x, y]` as decimal strings. */
     recipientPublicKeys: [string, string];
 }
 export type WithdrawSlot = WithdrawObject | 'dummy';
 export type DepositSlot = DepositObject | 'dummy';
-/** Witness calculator input for `circuits/main.circom` `Transaction(20,2,2)`. */
+/** Witness calculator input for `circuits/main.circom` `Transaction(20,2,2,publicNInputs,publicNOutputs)`. */
 export interface TransactionWitnessInput {
     stateRoot: string;
     withdrawAddressHi: string;
@@ -48,13 +64,19 @@ export interface TransactionWitnessInput {
     withdrawnValues: [string, string];
     withdrawnNullifiers: [string, string];
     withdrawnSecrets: [string, string];
+    withdrawnAssets: [[string, string], [string, string]];
     ephemeralKeys: [[string, string], [string, string]];
     stateSiblings: [string[], string[]];
     stateIndex: [string, string];
     depositedValues: [string, string];
     depositedNullifiers: [string, string];
+    depositedAssets: [[string, string], [string, string]];
     depositedEphemeralKeyScalars: [string, string];
     depositedRecipientPublicKeys: [[string, string], [string, string]];
+    publicWithdrawnAssets: Array<[string, string]>;
+    publicDepositedAssets: Array<[string, string]>;
+    publicDeposits: string[];
+    publicWithdrawals: string[];
 }
 export interface WasmEcdhPointFns {
     ecdhEphemeralPublicKeyFromScalarHex(scalarHex: string): {
@@ -77,11 +99,15 @@ export declare function ed25519PubkeyPayloadHexToWithdrawFrDecimals(hex: string)
     hi: string;
     lo: string;
 };
+/**
+ * Stellar contract id (`C…`) → two circom field decimals for `asset[0]`, `asset[1]` (same 32-byte split as accounts).
+ */
+export declare function stellarContractAddressToAssetFrDecimals(address: string): [string, string];
 /** Uniform random `Fr` as decimal (32 random bytes, mod r). For Poseidon-only inputs (e.g. nullifiers). */
 export declare function randomFrDecimal(): string;
 /** Random scalar < 2^253 for BabyJub ECDH / `Num2Bits(253)` (uses {@link generateRandomScalarHex32}). */
 export declare function randomFrDecimal253(): string;
-export declare function buildTransactionWitnessInput(publicParams: WithdrawalProofPublicParams, withdrawSlots: [WithdrawSlot, WithdrawSlot], depositSlots: [DepositSlot, DepositSlot], wasm: WasmEcdhPointFns): TransactionWitnessInput;
+export declare function buildTransactionWitnessInput(publicParams: WithdrawalProofPublicParams, publicLegs: TransactionPublicLegParams, withdrawSlots: [WithdrawSlot, WithdrawSlot], depositSlots: [DepositSlot, DepositSlot], wasm: WasmEcdhPointFns): TransactionWitnessInput;
 /** `stpl1…` stealth address → `[x, y]` as decimal field strings for `depositedRecipientPublicKeys`. */
 export declare function recipientPublicKeysDecimalFromStealthAddress(stealthAddress: string): [string, string];
 /** First withdraw leg: Merkle witness + depositor ECDH point coordinates (hex). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auditable/privacy-pool-zk-sdk",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "Client SDK for Soroban Privacy Pools - coin generation, withdrawal proofs, and proof serialization",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",
@@ -38,6 +38,7 @@
     "cli": "node dist/cli.js"
   },
   "dependencies": {
+    "@stellar/stellar-base": "^13.0.0",
     "bech32": "^2.0.0",
     "snarkjs": "^0.7.0"
   },

package/pkg/client_sdk_wasm.d.ts

@@ -31,24 +31,25 @@ export function ecdhSharedKey(priv_hex: string, pub_x_hex: string, pub_y_hex: st
 /**
  * Generate a new coin with random nullifier, secret, and shared-secret field elements.
  * `amount` is stroops (u64); JS passes `bigint`.
- * Returns JSON: { coin: { value, nullifier, secret, commitment }, commitment_hex }
+ * `asset_hi_decimal` / `asset_lo_decimal` are decimal Fr strings for the Stellar asset contract id (two limbs).
+ * Returns JSON: { coin: { value, nullifier, secret, commitment, asset_hi, asset_lo }, commitment_hex, precommitement_hex }
  */
-export function generateCoin(amount: bigint): any;
+export function generateCoin(amount: bigint, asset_hi_decimal: string, asset_lo_decimal: string): any;
 
 /**
  * `Poseidon₁(scalar)` secret + fixed ECDH shared coords (hex), matching an aligned deposit witness.
  */
-export function generateCoinForDepositWithSharedHex(scalar_hex: string, shared_x_hex: string, shared_y_hex: string, amount: bigint): any;
+export function generateCoinForDepositWithSharedHex(scalar_hex: string, shared_x_hex: string, shared_y_hex: string, amount: bigint, asset_hi_decimal: string, asset_lo_decimal: string): any;
 
 /**
  * `secret` in coin = `Poseidon255(1)(scalar)` per `deposit.circom`; scalar is 32-byte hex (64 chars, optional `0x`).
  */
-export function generateCoinFromDepositEphemeralScalarHex(scalar_hex: string, amount: bigint): any;
+export function generateCoinFromDepositEphemeralScalarHex(scalar_hex: string, amount: bigint, asset_hi_decimal: string, asset_lo_decimal: string): any;
 
 /**
  * Same as `generateCoin`, but commitment uses the given ECDH shared key (64-char hex coords from `ecdhSharedKey`); shared coords are not stored in `coin` JSON.
  */
-export function generateCoinWithSharedSecretHex(shared_x_hex: string, shared_y_hex: string, amount: bigint): any;
+export function generateCoinWithSharedSecretHex(shared_x_hex: string, shared_y_hex: string, amount: bigint, asset_hi_decimal: string, asset_lo_decimal: string): any;
 
 /**
  * Convert snarkjs proof JSON to hex bytes for Soroban contract.
@@ -69,10 +70,10 @@ export interface InitOutput {
     readonly ecdhEphemeralPublicKey: (a: number, b: number, c: number) => void;
     readonly ecdhEphemeralPublicKeyFromScalarHex: (a: number, b: number, c: number) => void;
     readonly ecdhSharedKey: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-    readonly generateCoin: (a: bigint) => number;
-    readonly generateCoinForDepositWithSharedHex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: bigint) => void;
-    readonly generateCoinFromDepositEphemeralScalarHex: (a: number, b: number, c: number, d: bigint) => void;
-    readonly generateCoinWithSharedSecretHex: (a: number, b: number, c: number, d: number, e: number, f: bigint) => void;
+    readonly generateCoin: (a: number, b: bigint, c: number, d: number, e: number, f: number) => void;
+    readonly generateCoinForDepositWithSharedHex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: bigint, i: number, j: number, k: number, l: number) => void;
+    readonly generateCoinFromDepositEphemeralScalarHex: (a: number, b: number, c: number, d: bigint, e: number, f: number, g: number, h: number) => void;
+    readonly generateCoinWithSharedSecretHex: (a: number, b: number, c: number, d: number, e: number, f: bigint, g: number, h: number, i: number, j: number) => void;
     readonly proofToHex: (a: number, b: number, c: number) => void;
     readonly publicToHex: (a: number, b: number, c: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;

package/pkg/client_sdk_wasm.js

@@ -147,13 +147,31 @@ export function ecdhSharedKey(priv_hex, pub_x_hex, pub_y_hex) {
 /**
  * Generate a new coin with random nullifier, secret, and shared-secret field elements.
  * `amount` is stroops (u64); JS passes `bigint`.
- * Returns JSON: { coin: { value, nullifier, secret, commitment }, commitment_hex }
+ * `asset_hi_decimal` / `asset_lo_decimal` are decimal Fr strings for the Stellar asset contract id (two limbs).
+ * Returns JSON: { coin: { value, nullifier, secret, commitment, asset_hi, asset_lo }, commitment_hex, precommitement_hex }
  * @param {bigint} amount
+ * @param {string} asset_hi_decimal
+ * @param {string} asset_lo_decimal
  * @returns {any}
  */
-export function generateCoin(amount) {
-    const ret = wasm.generateCoin(amount);
-    return takeObject(ret);
+export function generateCoin(amount, asset_hi_decimal, asset_lo_decimal) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(asset_hi_decimal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(asset_lo_decimal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.generateCoin(retptr, amount, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
 /**
@@ -162,9 +180,11 @@ export function generateCoin(amount) {
  * @param {string} shared_x_hex
  * @param {string} shared_y_hex
  * @param {bigint} amount
+ * @param {string} asset_hi_decimal
+ * @param {string} asset_lo_decimal
  * @returns {any}
  */
-export function generateCoinForDepositWithSharedHex(scalar_hex, shared_x_hex, shared_y_hex, amount) {
+export function generateCoinForDepositWithSharedHex(scalar_hex, shared_x_hex, shared_y_hex, amount, asset_hi_decimal, asset_lo_decimal) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(scalar_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -173,7 +193,11 @@ export function generateCoinForDepositWithSharedHex(scalar_hex, shared_x_hex, sh
         const len1 = WASM_VECTOR_LEN;
         const ptr2 = passStringToWasm0(shared_y_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len2 = WASM_VECTOR_LEN;
-        wasm.generateCoinForDepositWithSharedHex(retptr, ptr0, len0, ptr1, len1, ptr2, len2, amount);
+        const ptr3 = passStringToWasm0(asset_hi_decimal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(asset_lo_decimal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.generateCoinForDepositWithSharedHex(retptr, ptr0, len0, ptr1, len1, ptr2, len2, amount, ptr3, len3, ptr4, len4);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -190,14 +214,20 @@ export function generateCoinForDepositWithSharedHex(scalar_hex, shared_x_hex, sh
  * `secret` in coin = `Poseidon255(1)(scalar)` per `deposit.circom`; scalar is 32-byte hex (64 chars, optional `0x`).
  * @param {string} scalar_hex
  * @param {bigint} amount
+ * @param {string} asset_hi_decimal
+ * @param {string} asset_lo_decimal
  * @returns {any}
  */
-export function generateCoinFromDepositEphemeralScalarHex(scalar_hex, amount) {
+export function generateCoinFromDepositEphemeralScalarHex(scalar_hex, amount, asset_hi_decimal, asset_lo_decimal) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(scalar_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
-        wasm.generateCoinFromDepositEphemeralScalarHex(retptr, ptr0, len0, amount);
+        const ptr1 = passStringToWasm0(asset_hi_decimal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(asset_lo_decimal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.generateCoinFromDepositEphemeralScalarHex(retptr, ptr0, len0, amount, ptr1, len1, ptr2, len2);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -215,16 +245,22 @@ export function generateCoinFromDepositEphemeralScalarHex(scalar_hex, amount) {
  * @param {string} shared_x_hex
  * @param {string} shared_y_hex
  * @param {bigint} amount
+ * @param {string} asset_hi_decimal
+ * @param {string} asset_lo_decimal
  * @returns {any}
  */
-export function generateCoinWithSharedSecretHex(shared_x_hex, shared_y_hex, amount) {
+export function generateCoinWithSharedSecretHex(shared_x_hex, shared_y_hex, amount, asset_hi_decimal, asset_lo_decimal) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(shared_x_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(shared_y_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
-        wasm.generateCoinWithSharedSecretHex(retptr, ptr0, len0, ptr1, len1, amount);
+        const ptr2 = passStringToWasm0(asset_hi_decimal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(asset_lo_decimal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.generateCoinWithSharedSecretHex(retptr, ptr0, len0, ptr1, len1, amount, ptr2, len2, ptr3, len3);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -295,13 +331,6 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
-            const ret = debugString(getObject(arg1));
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
         __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
             const ret = typeof(getObject(arg0)) === 'function';
             return ret;
@@ -427,71 +456,6 @@ function addHeapObject(obj) {
     return idx;
 }
 
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
-}
-
 function dropObject(idx) {
     if (idx < 1028) return;
     heap[idx] = heap_next;

package/pkg/client_sdk_wasm_bg.wasm.d.ts

@@ -6,10 +6,10 @@ export const calculateNullifierHash: (a: number, b: number, c: number) => void;
 export const ecdhEphemeralPublicKey: (a: number, b: number, c: number) => void;
 export const ecdhEphemeralPublicKeyFromScalarHex: (a: number, b: number, c: number) => void;
 export const ecdhSharedKey: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-export const generateCoin: (a: bigint) => number;
-export const generateCoinForDepositWithSharedHex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: bigint) => void;
-export const generateCoinFromDepositEphemeralScalarHex: (a: number, b: number, c: number, d: bigint) => void;
-export const generateCoinWithSharedSecretHex: (a: number, b: number, c: number, d: number, e: number, f: bigint) => void;
+export const generateCoin: (a: number, b: bigint, c: number, d: number, e: number, f: number) => void;
+export const generateCoinForDepositWithSharedHex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: bigint, i: number, j: number, k: number, l: number) => void;
+export const generateCoinFromDepositEphemeralScalarHex: (a: number, b: number, c: number, d: bigint, e: number, f: number, g: number, h: number) => void;
+export const generateCoinWithSharedSecretHex: (a: number, b: number, c: number, d: number, e: number, f: bigint, g: number, h: number, i: number, j: number) => void;
 export const proofToHex: (a: number, b: number, c: number) => void;
 export const publicToHex: (a: number, b: number, c: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;