@arcanetech/stellar-privacy-pool-zk-sdk 0.9.1-rc.0

package/dist/kyt-onboarding.d.ts

@@ -0,0 +1,36 @@
+import { xdr } from '@stellar/stellar-sdk';
+export interface PlaintextNotePayload {
+    value: bigint;
+    asset_hi: Buffer;
+    asset_lo: Buffer;
+    nullifier: Buffer;
+    secret: Buffer;
+    deposited_ephemeral_scalar?: Buffer;
+}
+export type OptionalPrivateAddressRegistrationPayload = {
+    tag: 'None';
+} | {
+    tag: 'Some';
+    values: readonly [
+        {
+            owner: string;
+            public_key_x: Buffer;
+            public_key_y: Buffer;
+        }
+    ];
+};
+export interface OnboardingPayloadInput {
+    owner: string;
+    temp_public_key_x: Buffer;
+    temp_public_key_y: Buffer;
+    encrypted_private_key: Buffer;
+    notes: PlaintextNotePayload[];
+    private_address_registration: OptionalPrivateAddressRegistrationPayload;
+}
+declare const ONBOARDING_ZERO_DOMAIN = "privacy-pool-onboarding-zero-v1";
+/** Canonical `onboardingHash` matching `libs/kyt-passage/src/lib.rs::hash_onboarding`. */
+export declare function hashOnboardingCanonical(onboarding: OnboardingPayloadInput | null | undefined): string;
+export declare function onboardingToScVal(onboarding: OnboardingPayloadInput): xdr.ScVal;
+export declare function onboardingOptionToScVal(onboarding: OnboardingPayloadInput | null | undefined): xdr.ScVal;
+export declare function addressToScVal(address: string): xdr.ScVal;
+export { ONBOARDING_ZERO_DOMAIN };

package/dist/kyt-passage.d.ts

@@ -0,0 +1,83 @@
+export declare const KYT_PASSAGE_AUTH_DOMAIN = "privacy-pool-kyt-passage-v1";
+export declare const PUBLIC_LEG_CONTEXT_DOMAIN = "privacy-pool-public-leg-context-v1";
+export declare const PASSAGE_ID_DOMAIN = "privacy-pool-passage-id-v3";
+export declare const PASSAGE_ID_DOMAIN_V2 = "privacy-pool-passage-id-v2";
+export declare const PASSAGE_ID_DOMAIN_V1 = "privacy-pool-passage-id-v1";
+export declare const NOTE_AUDIT_LEN = 12;
+export declare const TOTAL_PUBLIC_SIGNALS = 93;
+export declare const NOTE_AUDIT_PLAINTEXT_LEN = 12;
+export interface PublicLegLayout {
+    publicNInputs: number;
+    publicNOutputs: number;
+}
+export interface PublicLegContextInput {
+    owner: string;
+    withdrawAddress: string;
+    publicDeposits: string[];
+    publicWithdrawals: string[];
+    publicDepositedAssets: [string, string][];
+    publicWithdrawnAssets: [string, string][];
+}
+export interface KytPassageDerivation {
+    publicSignalHash: string;
+    publicLegContextHash: string;
+    passageId: string;
+}
+export interface KytPassageAuthorization {
+    authorizationHash: string;
+    poolContract: string;
+    kytRegistry: string;
+    passageId: string;
+    expiresAtLedger: number;
+}
+/** Canonical zero-address sentinel for absent public-leg slots: `u32_be(0)` with no XDR bytes. */
+export declare function zeroAddressSentinelBuffer(): Buffer;
+export declare function addressToCanonicalXdr(address: string): Buffer;
+export declare function hashPublicSignalBytes(publicSignalsBytes: Buffer | string, zkConfigNonce?: bigint): string;
+export declare function hashPublicLegContext(layout: PublicLegLayout, input: PublicLegContextInput): string;
+export declare function derivePassageId(owner: string, nonce: bigint | number, publicSignalHash: string, publicLegContextHash: string, ciphertextHash: string): string;
+export declare function derivePassageIdV2(owner: string, nonce: bigint | number, publicSignalHash: string, publicLegContextHash: string): string;
+export declare function derivePassageIdV1(owner: string, nonce: bigint | number, publicSignalHash: string, publicLegContextHash: string, onboardingHash: string): string;
+export declare function buildKytPassageAuthorization(input: {
+    poolContract: string;
+    kytRegistry: string;
+    passageId: string;
+    expiresAtLedger: number;
+}): KytPassageAuthorization;
+export declare function derivePassageFromTransactContext(input: {
+    owner: string;
+    nonce?: bigint | number;
+    publicSignalsBytes: Buffer | string;
+    ciphertextBytes?: Buffer | string;
+    publicLegContext: PublicLegContextInput;
+    layout?: PublicLegLayout;
+}): KytPassageDerivation;
+export declare function hashCiphertextBytes(ciphertextBytes: Buffer | string): string;
+export declare function zeroBindingTagsInPublicSignals(publicSignalsBytes: Buffer | string, zkConfigNonce?: bigint): Buffer;
+export declare function spliceBindingTagsIntoPublicSignals(parameters: {
+    publicSignalsBytes: Buffer | string;
+    zkConfigNonce: bigint;
+    auditTags: readonly string[];
+    outputNoteTags: readonly string[];
+}): Buffer;
+export declare function accountIdFromAddress(address: string): Buffer;
+export interface InspectKytPassageRequest {
+    owner: string;
+    poolContract: string;
+    kytRegistry: string;
+    proofBytes: string;
+    publicSignalsBytes: string;
+    applicationIdsPlaintext: string[];
+    ciphertextBytes?: string;
+    outputNoteEphemeralScalars?: string[];
+    nonce?: string;
+    zkConfigNonce?: string;
+}
+export interface InspectKytPassageApproved {
+    status: 'approved';
+    passageId: string;
+    signature: string;
+    expiresAtLedger: number;
+}
+export declare function inspectKytPassage(backendUrl: string, request: InspectKytPassageRequest): Promise<InspectKytPassageApproved>;
+export declare function signatureBase64ToBytes(signature: string): Buffer;

package/dist/output-note-encryption.d.ts

@@ -0,0 +1,72 @@
+import { buildPoseidon } from 'circomlibjs';
+import type { DepositObject, TransactionWitnessInput } from './withdrawal-transaction-input.js';
+import type { EcdhSharedKeyFn } from './shared-secret.js';
+import type { ZkLayoutParams } from './zk-layout.js';
+export declare const NOTE_OUTPUT_LEN = 6;
+export declare const NOTE_AUDIT_LEN = 12;
+export declare const STREAM_DOMAIN = 1n;
+export declare const FR_SIZE = 32;
+type Poseidon = Awaited<ReturnType<typeof buildPoseidon>>;
+export type OutputNotePlaintext = {
+    value: string;
+    assetHi: string;
+    assetLo: string;
+    nullifier: string;
+    secret: string;
+    applicationId: string;
+};
+export type OutputNoteEncryption = {
+    ciphertext: [string, string, string, string, string, string];
+    tag: string;
+};
+export type DecryptedOutputNote = OutputNotePlaintext & {
+    commitmentHex: string;
+    commitmentMatches: boolean;
+};
+export type OutputNoteEventInput = {
+    recipientScalarHex: string;
+    commitmentHashHex: string;
+    createdEphemeralKey: readonly [string, string];
+    ciphertext: readonly string[];
+    tag: string;
+    ownerMode?: bigint;
+};
+export declare function poseidonMacTag(parameters: {
+    poseidon: Poseidon;
+    domain: bigint;
+    key: bigint;
+    nonce: bigint;
+    message: readonly bigint[];
+}): bigint;
+export declare function secretFromDepositEphemeralScalarDecimal(ephemeralKeyScalarDecimal: string): Promise<string>;
+export declare function encryptOutputNoteForDeposit(parameters: {
+    deposit: DepositObject;
+    ecdhShared: EcdhSharedKeyFn;
+}): Promise<OutputNoteEncryption>;
+export declare function buildOutputNoteEncryptionPublicInputs(parameters: {
+    deposits: [DepositObject, DepositObject];
+    ecdhShared: EcdhSharedKeyFn;
+}): Promise<{
+    outputNoteCiphertexts: [OutputNoteEncryption['ciphertext'], OutputNoteEncryption['ciphertext']];
+    outputNoteTags: [string, string];
+}>;
+export declare function decryptOutputNoteEvent(input: OutputNoteEventInput): Promise<DecryptedOutputNote>;
+export declare function encryptNoteAuditSlot(parameters: {
+    auditPublicKey: readonly [string, string];
+    auditEphemeralScalar: string;
+    plaintext: readonly string[];
+    ecdhShared: EcdhSharedKeyFn;
+}): Promise<{
+    ciphertext: string[];
+    tag: string;
+}>;
+export declare function encryptTransactionCiphertextBlob(parameters: {
+    witness: TransactionWitnessInput;
+    layout: ZkLayoutParams;
+    ecdhShared: EcdhSharedKeyFn;
+}): Promise<{
+    ciphertextHex: string;
+    auditCiphertexts: string[][];
+    outputNoteCiphertexts: string[][];
+}>;
+export {};

package/dist/prover.d.ts

@@ -0,0 +1,5 @@
+/** @deprecated Groth16 proving is in the main SDK WASM (`proveGroth16`). */
+export declare function generateProof(_wtns: Uint8Array, _zkey?: BufferSource, _zkeyFileName?: string): Promise<{
+    proof: object;
+    publicSignals: string[];
+}>;

package/dist/sdk.d.ts

@@ -0,0 +1,130 @@
+import type { CoinData, GeneratedCoin, SDKOptions, StateFile, WithdrawMerkleWitness, WithdrawResult } from "./types";
+import { type DecodedDepositorSharedSecretPreimage, type DecodedEphemeralKey, type EncodedDepositorSharedSecretPreimage, type EncodedEphemeralKey } from "./ephemeral-key";
+import { type SharedSecret } from "./shared-secret";
+import { type SpendScalarDomain } from "./stealth-sign-message";
+import type { DecodedRecipientSharedSecretPreimage } from "./stealth-address";
+import { type DepositSlot, type TransactionPublicLegParams, type WithdrawalProofPublicParams, type WithdrawSlot } from "./withdrawal-transaction-input";
+import { type TransactionAuditParams } from "./transaction-audit";
+import { type ZkLayoutParams } from "./zk-layout";
+export declare class PrivacyPoolSDK {
+    private wasm;
+    private options;
+    private zkConfigNonce;
+    private circuitConfig;
+    private layout;
+    private circuitArtifacts;
+    private constructor();
+    getZkConfigNonce(): bigint;
+    getLayout(): ZkLayoutParams;
+    /**
+     * Initialize the SDK by loading WASM modules.
+     *
+     * In Node.js, proving artifacts load from `zkArtifactBaseUrl` or
+     * `ZK_ARTIFACT_BASE_URL`, defaulting to this package's GitHub release.
+     * In browser, pass pre-loaded WASM via options:
+     * ```ts
+     * const sdk = await PrivacyPoolSDK.init({
+     *   wasmBinary: await fetch('/pkg/client_sdk_wasm_bg.wasm').then(r => r.arrayBuffer()),
+     *   zkArtifactBaseUrl: 'https://github.com/Polynom-Labs/stellar-privacy-layer-contracts/releases/download/v0.8.0',
+     * });
+     * ```
+     */
+    static init(options?: SDKOptions): Promise<PrivacyPoolSDK>;
+    /**
+     * Uniform 32-byte scalar as lowercase hex (Web Crypto). Same in browser and Node 19+.
+     */
+    static generateRandomScalarHex32(): string;
+    /**
+     * Text to sign with a Stellar wallet for spend-key derivation (UTF-8). No WASM required.
+     * The message binds network, pool, registry, and schema version (H6).
+     */
+    static buildStealthAddressSignMessage(address: string, domain: SpendScalarDomain, nonce?: string): string;
+    /**
+     * Generate a new coin with random nullifier, secret, and random owner-pub field elements (dev / self-contained tests).
+     * @param amount Decimal field element as `bigint` or decimal `string` (never JS `number`).
+     * @param assetHiDecimal / assetLoDecimal Decimal Fr strings for Stellar asset contract id (two limbs).
+     */
+    generateCoin(amount: bigint | string, assetHiDecimal: string, assetLoDecimal: string, applicationIdDecimal?: string): GeneratedCoin;
+    /**
+     * Generate a coin with the same commitment shape as on-chain deposit: pass owner public key (hex x, y).
+     * @param amount Decimal field element (`bigint` | `string`).
+     */
+    generateCoinWithOwnerPub(ownerPub: {
+        x: string;
+        y: string;
+    }, amount: bigint | string, assetHiDecimal: string, assetLoDecimal: string, applicationIdDecimal?: string): GeneratedCoin;
+    /**
+     * Coin for a depositor `ephemeralKeyScalar` (32-byte hex): `coin.secret = Poseidon255(1)(scalar)` as in `deposit.circom`.
+     * @param amount Decimal field element (`bigint` | `string`).
+     */
+    generateCoinFromDepositEphemeralScalarHex(scalarHex: string, amount: bigint | string, assetHiDecimal: string, assetLoDecimal: string, applicationIdDecimal?: string): GeneratedCoin;
+    /**
+     * Aligned deposit coin: `secret = Poseidon₁(scalar)` and owner pub from recipient hex coords.
+     * @param amount Decimal field element (`bigint` | `string`).
+     */
+    generateCoinForDepositWithOwnerPubHex(scalarHex: string, ownerXHex: string, ownerYHex: string, amount: bigint | string, assetHiDecimal: string, assetLoDecimal: string, applicationIdDecimal?: 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;
+        withdrawAddressLo: string;
+        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;
+        applicationId?: string;
+        audit?: TransactionAuditParams;
+    }): Promise<WithdrawResult>;
+    /**
+     * Convert a snarkjs proof JSON to hex bytes for Soroban.
+     */
+    proofToHex(proof: object): string;
+    /**
+     * Convert snarkjs public signals to hex bytes for Soroban.
+     */
+    publicToHex(publicSignals: string[]): string;
+    /**
+     * BabyJubJub ephemeral point from a 32-byte scalar (hex). For custom {@link WithdrawObject} / tests.
+     */
+    ecdhEphemeralPublicKeyFromScalarHex(scalarHex: string): {
+        x: string;
+        y: string;
+    };
+    /** Circuit `ECDH`: scalar (32-byte hex) × recipient BabyJub point → shared key hex coords. */
+    ecdhSharedKey(scalarHex: string, recipientPubXHex: string, recipientPubYHex: string): SharedSecret;
+    /**
+     * `Transaction(20,nIns,nOuts)` proof from high-level legs: maps to witness input (incl. `"dummy"` ECDH via WASM), then Groth16 → Soroban hex.
+     * Slots are padded to the selected ZK config layout (bundled 2×2 or 6×6).
+     */
+    proveTransaction(publicParams: WithdrawalProofPublicParams, publicLegs: TransactionPublicLegParams, withdraws: WithdrawSlot[], deposits: DepositSlot[], audit: TransactionAuditParams): Promise<WithdrawResult>;
+    proveTransactionSlots(publicParams: WithdrawalProofPublicParams, publicLegs: TransactionPublicLegParams, withdraws: WithdrawSlot[], deposits: DepositSlot[], audit: TransactionAuditParams): Promise<WithdrawResult>;
+    /**
+     * Calculate owner-bound nullifier hash: Poseidon(DOM_NULLIFIER, nullifier, privKeyScalar)
+     * @param nullifier Nullifier decimal string from coin data
+     * @param privKeyScalar Spend scalar decimal string
+     * @returns Hex string (0x...) of the hash bytes
+     */
+    calculateNullifierHash(nullifier: string, privKeyScalar: string): string;
+    /**
+     * Ed25519 signature from signing {@link buildStealthAddressSignMessage}: **128 hex chars** (optional `0x`)
+     * or **base64** (64 raw bytes after decode). Domain-separated SHA-256 → scalar → ECDH → `stpl1` Bech32.
+     */
+    generateStealthAddressFromStellarSignature(signature: string, domain: SpendScalarDomain): Promise<string>;
+    encodeDecodedEphemeralKey(decoded: DecodedEphemeralKey): EncodedEphemeralKey;
+    decodeDecodedEphemeralKey(encoded: EncodedEphemeralKey): DecodedEphemeralKey;
+    encodeDepositorSharedSecretPreimage(decoded: DecodedDepositorSharedSecretPreimage): EncodedDepositorSharedSecretPreimage;
+    decodeDepositorSharedSecretPreimage(encoded: EncodedDepositorSharedSecretPreimage): DecodedDepositorSharedSecretPreimage;
+    sharedSecretFromDepositorPreimage(preimage: DecodedDepositorSharedSecretPreimage): SharedSecret;
+    sharedSecretFromRecipientPreimage(preimage: DecodedRecipientSharedSecretPreimage): SharedSecret;
+}

package/dist/shared-secret.d.ts

@@ -0,0 +1,24 @@
+import type { DecodedDepositorSharedSecretPreimage, DecodedEphemeralKey } from './ephemeral-key';
+import type { DecodedRecipientSharedSecretPreimage, Hex } from './stealth-address';
+/** ECDH shared key coordinates (`ecdh_shared_key` / circuit `ECDH` output). */
+export interface SharedSecret {
+    x: Hex;
+    y: Hex;
+}
+/** Withdrawer-side material: recipient private scalar ‖ depositor’s ephemeral point. */
+export interface DecodedWithdrawerSharedSecret {
+    recipientScalar: Hex;
+    ephemeralKey: DecodedEphemeralKey;
+}
+export type EcdhSharedKeyFn = (privHex64: string, pubXHex64: string, pubYHex64: string) => {
+    x: string;
+    y: string;
+};
+/**
+ * Depositor: `randomNonceScalar * recipientStealthPoint` (same as circom `ECDH` with depositor scalar).
+ */
+export declare function sharedSecretFromDepositorPreimage(ecdhShared: EcdhSharedKeyFn, preimage: DecodedDepositorSharedSecretPreimage): SharedSecret;
+/**
+ * Recipient: `recipientScalar * ephemeralKey` (same shared point as depositor path when keys match).
+ */
+export declare function sharedSecretFromRecipientPreimage(ecdhShared: EcdhSharedKeyFn, preimage: DecodedRecipientSharedSecretPreimage): SharedSecret;

package/dist/stealth-address.d.ts

@@ -0,0 +1,23 @@
+import type { DecodedEphemeralKey } from './ephemeral-key';
+/** Lowercase hex string (optional `0x` prefix when parsing). */
+export type Hex = string;
+export type StealthAddress = string;
+export interface DecodedStealthAddress {
+    x: Hex;
+    y: Hex;
+}
+/** Withdrawer preimage: recipient scalar ‖ depositor-revealed ephemeral point. */
+export interface DecodedRecipientSharedSecretPreimage {
+    ephemeralKey: DecodedEphemeralKey;
+    recipientScalar: Hex;
+}
+export declare const STEALTH_ADDRESS_HRP: "stpl1";
+/**
+ * Encodes `x || y` as Bech32 (BIP-173) with human-readable part {@link STEALTH_ADDRESS_HRP} (`stpl1`).
+ * `x` and `y` must have the same byte length so decoding can split the payload in half.
+ */
+export declare function encodeStealthAddress(decoded: DecodedStealthAddress): StealthAddress;
+/**
+ * Decodes a `stpl1` Bech32 stealth address into `x` and `y` (each half of the payload, as lowercase hex).
+ */
+export declare function decodeStealthAddress(address: StealthAddress): DecodedStealthAddress;

package/dist/stealth-sign-message.d.ts

@@ -0,0 +1,20 @@
+/** Default nonce when deriving the wallet sign-in message. */
+export declare const DEFAULT_STEALTH_SIGN_NONCE = "main address";
+/** Domain tag mixed into the spend-scalar digest (H6). */
+export declare const SPEND_SCALAR_DOMAIN_TAG = "privacy-pool-spend-scalar-v1";
+/** Schema version bound into the spend-scalar message and digest. */
+export declare const OWNER_BOUND_NOTE_SCHEMA_VERSION = 1;
+export type SpendScalarDomain = {
+    networkPassphrase: string;
+    poolContract: string;
+    registryContract: string;
+    schemaVersion?: number;
+};
+export declare function resolveSpendScalarSchemaVersion(domain: SpendScalarDomain): number;
+/**
+ * Plaintext for Stellar wallet message signing (spend-key derivation).
+ * Sign the exact bytes of this string (UTF-8) with the stellar account key.
+ *
+ * The derived scalar is the owner-bound spend key for notes in this environment.
+ */
+export declare function buildStealthAddressSignMessage(address: string, domain: SpendScalarDomain, nonce?: string): string;

package/dist/stealth-signature.d.ts

@@ -0,0 +1,29 @@
+import { type SpendScalarDomain } from './stealth-sign-message';
+/**
+ * Ed25519 signature as **128 hex chars** (optional `0x`) or **base64** (typically 88 chars for 64 bytes, whitespace ignored).
+ */
+export declare function parseStellarEd25519SignatureRaw(input: string): Uint8Array;
+/** SHA-256 via Web Crypto only (`crypto.subtle`) — works in browsers and Node 19+ (global `crypto`). */
+export declare function sha256(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Domain-separated spend-scalar digest: SHA-256(
+ *   SPEND_SCALAR_DOMAIN_TAG || network || pool || registry || schemaVersion || signature
+ * ).
+ */
+export declare function spendScalarDigestFromStellarSignature(signature: string, domain: SpendScalarDomain): Promise<Uint8Array>;
+export declare function spendScalarHexFromStellarSignature(signature: string, domain: SpendScalarDomain): Promise<string>;
+/**
+ * Stellar Ed25519 signature (hex or base64) → domain-separated SHA-256 → scalar → WASM ECDH.
+ */
+export declare function stealthAddressFromStellarSignature(ecdhFromScalarHex: (scalarHex64: string) => {
+    x: string;
+    y: string;
+}, encodeStealth: (decoded: {
+    x: string;
+    y: string;
+}) => string, signature: string, domain: SpendScalarDomain): Promise<string>;
+/**
+ * Domain-separated SHA-256(signature, network, pool, registry, schema) reduced into
+ * `(0, BabyJub subgroup order)` so `privKeyScalar` matches `BabyPbk` and circom `LessThan(l)`.
+ */
+export declare function privKeyScalarDecimalFromStellarSignature(signature: string, domain: SpendScalarDomain): Promise<string>;

package/dist/transaction-audit.d.ts

@@ -0,0 +1,26 @@
+import { type DepositObject, type DepositSlot, type WithdrawObject, type WithdrawSlot } from './withdrawal-transaction-input';
+export declare const TRANSACTION_N_AUDIT_SLOTS = 4;
+export declare const SIX_BY_SIX_N_AUDIT_SLOTS = 12;
+export declare const DEFAULT_APPLICATION_ID = "101";
+/** BabyJub audit public key (decimal Fr) used in BDD / local demo when env is unset. */
+export declare const DEMO_AUDIT_PUBLIC_KEY: AuditPublicKey;
+export type AuditPublicKey = [string, string];
+export interface TransactionAuditParams {
+    applicationId: string;
+    noteAuditPublicKey: AuditPublicKey;
+    auditEphemeralScalar: string;
+}
+export interface TransactionSlotApplicationIds {
+    inputApplicationIds: string[];
+    outputApplicationIds: string[];
+}
+export declare function buildUniformAuditParams(applicationId: string | undefined, auditPublicKey: AuditPublicKey, _nAuditSlots?: number): TransactionAuditParams;
+export declare function resolveSlotApplicationIds(audit: TransactionAuditParams, withdrawSlots: WithdrawSlot[], depositSlots: DepositSlot[]): TransactionSlotApplicationIds;
+export declare function withApplicationIdOnDeposit(deposit: DepositObject, applicationId: string): DepositObject;
+export declare function withApplicationIdOnWithdraw(withdraw: WithdrawObject, applicationId: string): WithdrawObject;
+/**
+ * Prefer an explicit key, then `NOTE_AUDIT_PUBLIC_KEY_X`/`_Y` env (decimal Fr),
+ * then the built-in demo key. Used by CLI/`demo.sh` for per-app audit pubkeys.
+ */
+export declare function resolveAuditPublicKeyFromEnv(auditPublicKey?: AuditPublicKey): AuditPublicKey;
+export declare function resolveTransactionAuditParams(applicationId: string, auditPublicKey?: AuditPublicKey, nAuditSlots?: number): TransactionAuditParams;

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+export interface CoinData {
+    value: string;
+    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;
+    /** Decimal Fr application id (per-note KYT slot); optional on legacy coins. */
+    application_id?: string;
+}
+export interface GeneratedCoin {
+    coin: CoinData;
+    commitment_hex: string;
+    /** 64-char lowercase hex (no `0x`), Fr big-endian for audit `precommitement`. */
+    precommitement_hex: string;
+    /** JS alias of {@link GeneratedCoin.precommitement_hex}. */
+    precommitementHex: string;
+}
+/** Pool Merkle tree depth (matches `coin::TREE_DEPTH` / `Transaction` circuit). */
+export declare const POOL_MERKLE_TREE_DEPTH = 20;
+/** Default coin value in stroops (1 XLM); matches Rust `coin::COIN_VALUE`. */
+export declare const COIN_VALUE_STROOPS = 1000000000;
+/**
+ * Merkle path + coin fields for the first withdraw leg (WASM `buildWithdrawMerkleWitness`).
+ * Serde: `withdrawnValue`, `stateRoot`, `stateIndex`, `stateSiblings`.
+ */
+export interface WithdrawMerkleWitness {
+    /** Withdrawn amount in stroops as decimal Fr string; matches `coin.value`. */
+    withdrawnValue: string;
+    /** Coin value as decimal field string. */
+    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. */
+    stateSiblings: string[];
+}
+export interface StateFile {
+    commitments: string[];
+}
+export interface WithdrawResult {
+    proof_hex: string;
+    public_hex: string;
+    ciphertext_hex: string;
+    output_note_ephemeral_scalars: string[];
+}
+export interface SDKOptions {
+    /** Pre-loaded Rust WASM binary (ArrayBuffer). Required in browser. */
+    wasmBinary?: BufferSource;
+    /** Nonce-keyed circuit map. Defaults to {@link DEFAULT_ZK_CIRCUITS}. */
+    zkCircuits?: Record<string, import('./zk-layout').ZkCircuitConfig>;
+    /** Selected pool `ZkConfig` nonce. Defaults to {@link DEFAULT_ZK_CONFIG_NONCE}. */
+    zkConfigNonce?: bigint;
+    /**
+     * Directory or URL prefix for graph/r1cs/proving-key files.
+     * Defaults to the GitHub release for this SDK version. Node also reads
+     * `ZK_ARTIFACT_BASE_URL`.
+     */
+    zkArtifactBaseUrl?: string;
+}

package/dist/wasm.d.ts

@@ -0,0 +1 @@
+export declare function loadWasm(wasmBinary?: BufferSource): Promise<any>;