@utxopia/sdk 0.1.0-alpha.1

package/packages/sdk/dist/events.js

@@ -0,0 +1,305 @@
+/**
+ * Event parser for UTXOpia sol_log_data events
+ *
+ * Events are emitted by the on-chain program as base64-encoded log data.
+ * Transaction logs contain lines like: "Program data: <base64>"
+ * Each base64 segment decodes to one slice from sol_log_data.
+ *
+ * ## Events
+ *
+ * - 0x02 NullifierSpent: disc(1) + hash(32) + op_type(1) = 34 bytes
+ * - 0x03 StealthAnnouncement: disc(1) + type(1) + ephemeral(32) + amount(8) + commitment(32) + leaf_index(4) = 78 bytes
+ * - 0x0B NullifiersBatch: flat payload in single segment
+ * - 0x0C AnnouncementsBatch: flat payload in single segment
+ */
+/** Event discriminators matching contracts/programs/utxopia/src/utils/events.rs */
+export const EVENT_NULLIFIER_SPENT = 0x02;
+export const EVENT_STEALTH_ANNOUNCEMENT = 0x03;
+export const EVENT_NULLIFIERS_BATCH = 0x0b;
+export const EVENT_ANNOUNCEMENTS_BATCH = 0x0c;
+/** Phase 2: sender memo (XChaCha20-Poly1305 AEAD payload). */
+export const EVENT_SENDER_MEMO = 0x12;
+export const EVENT_BTC_ORIGIN_ATTESTATION = 0x15;
+/** Method-Y: auditor ciphertext emitted alongside every shielded deposit into a permissioned pool. */
+export const EVENT_AUDITOR_CIPHERTEXT = 0x16;
+/**
+ * Parse a nullifier spent event from decoded sol_log_data segments.
+ * Expected: disc(1) + nullifier_hash(32) + op_type(1)
+ */
+export function parseNullifierSpentEvent(segments) {
+    if (segments.length < 3)
+        return null;
+    if (segments[0].length !== 1 || segments[0][0] !== EVENT_NULLIFIER_SPENT)
+        return null;
+    const nullifierHash = segments[1];
+    if (nullifierHash.length !== 32)
+        return null;
+    const opType = segments[2];
+    if (opType.length !== 1)
+        return null;
+    return {
+        type: "nullifier_spent",
+        nullifierHash,
+        operationType: opType[0],
+    };
+}
+/**
+ * Parse a stealth announcement event from decoded sol_log_data segments.
+ * v1: disc(1) + type(1) + ephemeral_pub(32) + encrypted_amount(8) + commitment(32) + leaf_index(4) = 6 segments
+ * v2: + token_id(32) = 7 segments
+ */
+export function parseStealthAnnouncementEvent(segments) {
+    if (segments.length < 6)
+        return null;
+    if (segments[0].length !== 1 || segments[0][0] !== EVENT_STEALTH_ANNOUNCEMENT)
+        return null;
+    const atype = segments[1];
+    if (atype.length !== 1)
+        return null;
+    const ephemeralPub = segments[2];
+    if (ephemeralPub.length !== 32)
+        return null;
+    const encryptedAmount = segments[3];
+    if (encryptedAmount.length !== 8)
+        return null;
+    const commitment = segments[4];
+    if (commitment.length !== 32)
+        return null;
+    const liBytes = segments[5];
+    if (liBytes.length !== 4)
+        return null;
+    const view = new DataView(liBytes.buffer, liBytes.byteOffset, 4);
+    const leafIndex = view.getUint32(0, true);
+    // v2: token_id at segment 6
+    let tokenId;
+    if (segments.length >= 7 && segments[6].length === 32) {
+        tokenId = segments[6];
+    }
+    return {
+        type: "stealth_announcement",
+        announcementType: atype[0],
+        ephemeralPub,
+        encryptedAmount,
+        commitment,
+        leafIndex,
+        tokenId,
+    };
+}
+/**
+ * Parse an association-set update event (Phase 3) from decoded sol_log_data segments.
+ * Layout: disc(1) + new_root(32) + status(1) + version_le(8)
+ */
+/**
+ * Parse a BTC origin attestation event from decoded sol_log_data segments.
+ * Layout: disc(1) + block_height(8 LE) + deposit_txid(32) + sweep_vout(4 LE)
+ *       + commitment(32) + amount_sats(8 LE)
+ */
+export function parseBtcOriginAttestationEvent(segments) {
+    if (segments.length < 6)
+        return null;
+    if (segments[0].length !== 1 || segments[0][0] !== EVENT_BTC_ORIGIN_ATTESTATION)
+        return null;
+    const bhBytes = segments[1];
+    if (bhBytes.length !== 8)
+        return null;
+    let blockHeight = 0n;
+    for (let i = 7; i >= 0; i--)
+        blockHeight = (blockHeight << 8n) | BigInt(bhBytes[i]);
+    const depositTxid = segments[2];
+    if (depositTxid.length !== 32)
+        return null;
+    const voutBytes = segments[3];
+    if (voutBytes.length !== 4)
+        return null;
+    const sweepVout = new DataView(voutBytes.buffer, voutBytes.byteOffset, 4).getUint32(0, true);
+    const commitment = segments[4];
+    if (commitment.length !== 32)
+        return null;
+    const amtBytes = segments[5];
+    if (amtBytes.length !== 8)
+        return null;
+    let amountSats = 0n;
+    for (let i = 7; i >= 0; i--)
+        amountSats = (amountSats << 8n) | BigInt(amtBytes[i]);
+    return {
+        type: "btc_origin_attestation",
+        blockHeight,
+        depositTxid,
+        sweepVout,
+        commitment,
+        amountSats,
+    };
+}
+/**
+ * Parse a sender memo event (Phase 2) from decoded sol_log_data segments.
+ * Layout: disc(1) + nonce(24) + ciphertext_and_tag(56) + commitment(32) + leaf_index(4)
+ */
+export function parseSenderMemoEvent(segments) {
+    if (segments.length < 5)
+        return null;
+    if (segments[0].length !== 1 || segments[0][0] !== EVENT_SENDER_MEMO)
+        return null;
+    const nonce = segments[1];
+    if (nonce.length !== 24)
+        return null;
+    const ciphertextWithTag = segments[2];
+    if (ciphertextWithTag.length !== 56)
+        return null;
+    const commitment = segments[3];
+    if (commitment.length !== 32)
+        return null;
+    const liBytes = segments[4];
+    if (liBytes.length !== 4)
+        return null;
+    const leafIndex = new DataView(liBytes.buffer, liBytes.byteOffset, 4).getUint32(0, true);
+    return { type: "sender_memo", nonce, ciphertextWithTag, commitment, leafIndex };
+}
+/**
+ * Parse batched nullifiers from a single flat segment.
+ * Layout: disc(1) + count(1) + op_type(1) + [hash(32)] x count
+ */
+function parseNullifiersBatch(data) {
+    if (data.length < 3)
+        return [];
+    const count = data[1];
+    const opType = data[2];
+    const expectedLen = 3 + count * 32;
+    if (data.length < expectedLen)
+        return [];
+    const events = [];
+    for (let i = 0; i < count; i++) {
+        const offset = 3 + i * 32;
+        events.push({
+            type: "nullifier_spent",
+            nullifierHash: data.slice(offset, offset + 32),
+            operationType: opType,
+        });
+    }
+    return events;
+}
+/**
+ * Parse batched announcements from a single flat segment.
+ * v1: disc(1) + count(1) + [type(1) + ephemeral(32) + amount(8) + commitment(32) + leaf_index(4)] x count (77 per item)
+ * v2: disc(1) + count(1) + [type(1) + ephemeral(32) + amount(8) + commitment(32) + leaf_index(4) + token_id(32)] x count (109 per item)
+ */
+function parseAnnouncementsBatch(data) {
+    if (data.length < 2)
+        return [];
+    const count = data[1];
+    if (count === 0)
+        return [];
+    // Detect v1 vs v2 by checking total size
+    const remainingBytes = data.length - 2;
+    const v2ItemSize = 109;
+    const v1ItemSize = 77;
+    const isV2 = remainingBytes >= count * v2ItemSize;
+    const itemSize = isV2 ? v2ItemSize : v1ItemSize;
+    const expectedLen = 2 + count * itemSize;
+    if (data.length < expectedLen)
+        return [];
+    const events = [];
+    for (let i = 0; i < count; i++) {
+        const offset = 2 + i * itemSize;
+        const liView = new DataView(data.buffer, data.byteOffset + offset + 73, 4);
+        const event = {
+            type: "stealth_announcement",
+            announcementType: data[offset],
+            ephemeralPub: data.slice(offset + 1, offset + 33),
+            encryptedAmount: data.slice(offset + 33, offset + 41),
+            commitment: data.slice(offset + 41, offset + 73),
+            leafIndex: liView.getUint32(0, true),
+        };
+        if (isV2) {
+            event.tokenId = data.slice(offset + 77, offset + 109);
+        }
+        events.push(event);
+    }
+    return events;
+}
+/**
+ * Parse an auditor ciphertext event (Method-Y) from decoded sol_log_data segments.
+ * Layout: disc(1) + commitment(32) + blob(112)
+ */
+export function parseAuditorCiphertextEvent(segments) {
+    if (segments.length < 3)
+        return null;
+    if (segments[0].length !== 1 || segments[0][0] !== EVENT_AUDITOR_CIPHERTEXT)
+        return null;
+    const commitment = segments[1];
+    if (commitment.length !== 32)
+        return null;
+    const blob = segments[2];
+    if (blob.length !== 112)
+        return null;
+    return { type: "auditor_ciphertext", commitment, blob };
+}
+function decodeBase64(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Parse program events from Solana transaction log messages.
+ *
+ * sol_log_data emits log lines in the format:
+ *   "Program data: <base64_segment1> <base64_segment2> ..."
+ *
+ * @param logs - Array of log message strings from a transaction
+ * @param programId - Optional program ID to filter events (matches "Program <id> invoke" blocks)
+ */
+export function parseProgramEvents(logs, programId) {
+    const events = [];
+    const DATA_PREFIX = "Program data: ";
+    for (const line of logs) {
+        if (!line.startsWith(DATA_PREFIX))
+            continue;
+        const b64Parts = line.slice(DATA_PREFIX.length).split(" ");
+        const segments = b64Parts.map(decodeBase64);
+        if (segments.length === 0)
+            continue;
+        // Handle batch events (single flat segment)
+        if (segments.length === 1 && segments[0].length > 1) {
+            const disc = segments[0][0];
+            if (disc === EVENT_NULLIFIERS_BATCH) {
+                events.push(...parseNullifiersBatch(segments[0]));
+                continue;
+            }
+            if (disc === EVENT_ANNOUNCEMENTS_BATCH) {
+                events.push(...parseAnnouncementsBatch(segments[0]));
+                continue;
+            }
+        }
+        if (segments[0].length !== 1)
+            continue;
+        const disc = segments[0][0];
+        if (disc === EVENT_NULLIFIER_SPENT) {
+            const event = parseNullifierSpentEvent(segments);
+            if (event)
+                events.push(event);
+        }
+        else if (disc === EVENT_STEALTH_ANNOUNCEMENT) {
+            const event = parseStealthAnnouncementEvent(segments);
+            if (event)
+                events.push(event);
+        }
+        else if (disc === EVENT_SENDER_MEMO) {
+            const event = parseSenderMemoEvent(segments);
+            if (event)
+                events.push(event);
+        }
+        else if (disc === EVENT_BTC_ORIGIN_ATTESTATION) {
+            const event = parseBtcOriginAttestationEvent(segments);
+            if (event)
+                events.push(event);
+        }
+        else if (disc === EVENT_AUDITOR_CIPHERTEXT) {
+            const event = parseAuditorCiphertextEvent(segments);
+            if (event)
+                events.push(event);
+        }
+    }
+    return events;
+}

package/packages/sdk/dist/explorer.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Explorer utilities for UTXOPIA
+ *
+ * Types, parsers, and fetchers for browsing on-chain UTXOpia activity:
+ * - Deposits (from event indexer)
+ * - Transfers (from event indexer)
+ * - Redemptions (RedemptionRequest accounts)
+ */
+import type { RpcClient } from "./commitment-tree";
+/** NullifierRecord account size (1 byte — slim layout, just discriminator) */
+export declare const NULLIFIER_RECORD_SIZE = 1;
+/** RedemptionRequest account size (178 bytes):
+ *  disc(1) status(1) btc_script_len(1) signing_approved(1) processing_slot(4) request_id(8)
+ *  requester(32) amount_sats(8) service_fee(8) total_input_sats(8) btc_script(34)
+ *  token_id(32) reserved_count(1) approved_inputs(4) _padding2(3) inputs_commitment(32).
+ *
+ *  This is a `dataSize` filter, so a stale value silently returns nothing rather than failing:
+ *  it sat at 138 — the struct's length before reserved_count/approved_inputs/inputs_commitment
+ *  were added — and matched no account on chain. `RedemptionRequest::LEN` is pinned by a test
+ *  on the program side; update both together. Field offsets below are unaffected. */
+export declare const REDEMPTION_REQUEST_SIZE = 178;
+/** NullifierRecord discriminator byte */
+export declare const NULLIFIER_RECORD_DISCRIMINATOR = 3;
+/** RedemptionRequest discriminator byte */
+export declare const REDEMPTION_REQUEST_DISCRIMINATOR = 4;
+/** Human-readable labels for nullifier operation types */
+export declare const OPERATION_TYPE_LABELS: Record<number, string>;
+/** Parsed deposit from indexer event data */
+export interface ExplorerDeposit {
+    pubkey: string;
+    amountSats: bigint;
+    leafIndex: bigint;
+    /** Commitment hex (from indexer events, not on-chain) */
+    commitment?: string;
+    /** Unix timestamp (from indexer events, not on-chain) */
+    createdAt?: number;
+    /** Ephemeral public key hex (from stealth announcement) */
+    ephemeralPub?: string;
+    /** Solana transaction signature */
+    txSignature?: string;
+}
+/** Transfer event — either a new commitment or a spent nullifier */
+export interface ExplorerTransferEvent {
+    type: "commitment" | "nullifier";
+    pubkey: string;
+    timestamp: number;
+    commitment?: string;
+    leafIndex?: bigint;
+    nullifierHash?: string;
+    operationType?: string;
+    spentBy?: string;
+}
+/** Parsed redemption request */
+export interface ExplorerRedemption {
+    pubkey: string;
+    requestId: bigint;
+    amountSats: bigint;
+    /** Service fee in satoshis, locked at request time */
+    serviceFee: bigint;
+    status: "Pending" | "Processing" | "Failed";
+    requester: string;
+    btcScript: string;
+    /** Slot when processing started (from PDA data[4..8]) — 0 if still Pending */
+    processingSlot: number;
+}
+/** Parse a NullifierRecord account (1 byte — slim layout)
+ * Only confirms existence (discriminator = 0x03). Metadata from indexer events. */
+export declare function parseNullifierRecord(pubkey: string, _data: Uint8Array): ExplorerTransferEvent;
+/** Parse a RedemptionRequest account (138 bytes, raw scriptPubKey) */
+export declare function parseRedemptionRequest(pubkey: string, data: Uint8Array): ExplorerRedemption;
+/** Indexer leaf data for enriching explorer deposits */
+export interface IndexerLeaf {
+    leaf_index: number;
+    commitment: string;
+    created_at: number;
+    announcement_type?: number;
+    amount_sats?: number;
+    ephemeral_pub?: string;
+    tx_signature?: string;
+}
+/** Fetch all deposit announcements from indexer data */
+export declare function fetchExplorerDeposits(_rpc: RpcClient, _programId: string, indexerLeaves?: IndexerLeaf[]): Promise<ExplorerDeposit[]>;
+/** Fetch all transfer events from indexer data */
+export declare function fetchExplorerTransfers(_rpc: RpcClient, _programId: string, indexerLeaves?: IndexerLeaf[]): Promise<ExplorerTransferEvent[]>;
+/** Fetch all redemption requests */
+export declare function fetchExplorerRedemptions(rpc: RpcClient, programId: string): Promise<ExplorerRedemption[]>;

package/packages/sdk/dist/explorer.js

@@ -0,0 +1,197 @@
+/**
+ * Explorer utilities for UTXOPIA
+ *
+ * Types, parsers, and fetchers for browsing on-chain UTXOpia activity:
+ * - Deposits (from event indexer)
+ * - Transfers (from event indexer)
+ * - Redemptions (RedemptionRequest accounts)
+ */
+// =============================================================================
+// Constants
+// =============================================================================
+/** NullifierRecord account size (1 byte — slim layout, just discriminator) */
+export const NULLIFIER_RECORD_SIZE = 1;
+/** RedemptionRequest account size (178 bytes):
+ *  disc(1) status(1) btc_script_len(1) signing_approved(1) processing_slot(4) request_id(8)
+ *  requester(32) amount_sats(8) service_fee(8) total_input_sats(8) btc_script(34)
+ *  token_id(32) reserved_count(1) approved_inputs(4) _padding2(3) inputs_commitment(32).
+ *
+ *  This is a `dataSize` filter, so a stale value silently returns nothing rather than failing:
+ *  it sat at 138 — the struct's length before reserved_count/approved_inputs/inputs_commitment
+ *  were added — and matched no account on chain. `RedemptionRequest::LEN` is pinned by a test
+ *  on the program side; update both together. Field offsets below are unaffected. */
+export const REDEMPTION_REQUEST_SIZE = 178;
+/** NullifierRecord discriminator byte */
+export const NULLIFIER_RECORD_DISCRIMINATOR = 0x03;
+/** RedemptionRequest discriminator byte */
+export const REDEMPTION_REQUEST_DISCRIMINATOR = 0x04;
+/** Max plausible plaintext amount: 21M BTC in sats */
+const MAX_PLAINTEXT_SATS = 21000000n * 100000000n;
+/** Human-readable labels for nullifier operation types */
+export const OPERATION_TYPE_LABELS = {
+    0: "Full Withdrawal",
+    1: "Partial Withdrawal",
+    2: "Private Transfer",
+    3: "Transfer",
+    4: "Split",
+    5: "Join",
+};
+// =============================================================================
+// Helpers
+// =============================================================================
+function toHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+function readU64LE(data, offset) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return view.getBigUint64(offset, true);
+}
+function readI64LE(data, offset) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    return Number(view.getBigInt64(offset, true));
+}
+function bs58Encode(bytes) {
+    const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let num = 0n;
+    for (const byte of bytes) {
+        num = num * 256n + BigInt(byte);
+    }
+    let encoded = "";
+    while (num > 0n) {
+        const remainder = num % 58n;
+        num = num / 58n;
+        encoded = ALPHABET[Number(remainder)] + encoded;
+    }
+    for (const byte of bytes) {
+        if (byte === 0)
+            encoded = "1" + encoded;
+        else
+            break;
+    }
+    return encoded || "1";
+}
+function decodeBase64(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+// =============================================================================
+// Parsers
+// =============================================================================
+/** Parse a NullifierRecord account (1 byte — slim layout)
+ * Only confirms existence (discriminator = 0x03). Metadata from indexer events. */
+export function parseNullifierRecord(pubkey, _data) {
+    return {
+        type: "nullifier",
+        pubkey,
+        timestamp: 0, // metadata available from indexer
+    };
+}
+/** Parse a RedemptionRequest account (138 bytes, raw scriptPubKey) */
+export function parseRedemptionRequest(pubkey, data) {
+    const statusByte = data[1];
+    const status = statusByte === 1 ? "Processing" : statusByte === 2 ? "Failed" : "Pending";
+    const scriptLen = data[2];
+    // data[3] = padding, data[4..8] = processing_slot (u32 LE)
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const processingSlot = view.getUint32(4, true);
+    return {
+        pubkey,
+        requestId: readU64LE(data, 8),
+        amountSats: readU64LE(data, 48),
+        serviceFee: readU64LE(data, 56),
+        status,
+        requester: bs58Encode(data.slice(16, 48)),
+        // btc_script starts at offset 72 (after total_input_sats at 64..72).
+        btcScript: toHex(data.slice(72, 72 + Math.min(scriptLen, 34))),
+        processingSlot,
+    };
+}
+// =============================================================================
+// RPC helpers
+// =============================================================================
+async function fetchAccountsBySize(rpc, programId, dataSize) {
+    const accounts = await rpc.getProgramAccounts(programId, {
+        filters: [{ dataSize }],
+        encoding: "base64",
+    });
+    return accounts.map((acc) => {
+        const raw = typeof acc.account.data === "string"
+            ? acc.account.data
+            : // @solana/kit returns [base64String, "base64"]
+                acc.account.data[0];
+        return {
+            pubkey: String(acc.pubkey),
+            data: decodeBase64(raw),
+        };
+    });
+}
+/** Fetch all deposit announcements from indexer data */
+export async function fetchExplorerDeposits(_rpc, _programId, indexerLeaves) {
+    if (!indexerLeaves || indexerLeaves.length === 0)
+        return [];
+    return indexerLeaves
+        .filter((leaf) => leaf.announcement_type === 0) // deposits only
+        .map((leaf) => ({
+        pubkey: "", // no PDA — data comes from events
+        amountSats: BigInt(leaf.amount_sats ?? 0),
+        leafIndex: BigInt(leaf.leaf_index),
+        commitment: leaf.commitment,
+        createdAt: leaf.created_at,
+        ephemeralPub: leaf.ephemeral_pub,
+        txSignature: leaf.tx_signature,
+    }))
+        .sort((a, b) => {
+        const aHasTime = (a.createdAt ?? 0) > 0;
+        const bHasTime = (b.createdAt ?? 0) > 0;
+        if (aHasTime && bHasTime)
+            return (b.createdAt ?? 0) - (a.createdAt ?? 0);
+        if (aHasTime && !bHasTime)
+            return -1;
+        if (!aHasTime && bHasTime)
+            return 1;
+        return Number(b.leafIndex - a.leafIndex);
+    });
+}
+/** Fetch all transfer events from indexer data */
+export async function fetchExplorerTransfers(_rpc, _programId, indexerLeaves) {
+    if (!indexerLeaves || indexerLeaves.length === 0)
+        return [];
+    const events = [];
+    for (const leaf of indexerLeaves) {
+        if (leaf.announcement_type === 0)
+            continue; // skip deposits
+        events.push({
+            type: "commitment",
+            pubkey: "",
+            timestamp: leaf.created_at ?? 0,
+            commitment: leaf.commitment,
+            leafIndex: BigInt(leaf.leaf_index),
+        });
+    }
+    // Sort by timestamp descending (most recent first); if no timestamp, by leafIndex high→low
+    events.sort((a, b) => {
+        const aHasTime = a.timestamp > 0;
+        const bHasTime = b.timestamp > 0;
+        if (aHasTime && bHasTime)
+            return b.timestamp - a.timestamp;
+        if (aHasTime && !bHasTime)
+            return -1;
+        if (!aHasTime && bHasTime)
+            return 1;
+        return Number((b.leafIndex ?? 0n) - (a.leafIndex ?? 0n));
+    });
+    return events;
+}
+/** Fetch all redemption requests */
+export async function fetchExplorerRedemptions(rpc, programId) {
+    const accounts = await fetchAccountsBySize(rpc, programId, REDEMPTION_REQUEST_SIZE);
+    return accounts
+        .map(({ pubkey, data }) => parseRedemptionRequest(pubkey, data))
+        .sort((a, b) => Number(b.requestId - a.requestId));
+}

package/packages/sdk/dist/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * UTXOpia SDK v3.0 (JoinSplit Architecture)
+ *
+ * Complete client library for interacting with the UTXOpia protocol.
+ * Private Bitcoin using ZK proofs.
+ *
+ * Networks: Solana deployments + Bitcoin testnet4/regtest/mainnet
+ *
+ * ## Quick Start
+ * ```typescript
+ * import { createNonInteractiveDeposit, generateJoinSplitProof, buildTransactInstruction } from '@utxopia/sdk';
+ *
+ * // 1. DEPOSIT: Generate BTC address + compact OP_RETURN payload.
+ * const deposit = await createNonInteractiveDeposit(meta, custodyInternalKey, 'testnet', undefined, opReturnContext);
+ * console.log('Send BTC to:', deposit.btcAddress);
+ *
+ * // 2. TRANSACT: JoinSplit proof for private transfer
+ * const proof = await generateJoinSplitProof(inputs);
+ *
+ * // 3. BUILD: Create Solana instruction
+ * const ix = buildTransactInstruction(options);
+ * ```
+ */
+export { bigintToBytes, bytesToBigint, hexToBytes, bytesToHex, sha256Hash, x25519Ecdh, ed25519GenerateKeyPair, ed25519PubToX25519, ed25519PrivToX25519, x25519PubFromPriv, x25519EcdhRaw, encryptAmountEd25519, decryptAmountEd25519, randomFieldElement, BN254_FIELD_PRIME, babyJubMul, BABYJUB_BASE8, } from "./crypto";
+export { deriveKeysFromWallet, deriveKeysFromSeed, deriveKeysFromSeedCircuit, deriveKeysFromAuthSignature, setupKeysFromAuthSignature, generateRandomAuthSignature, setupKeysFromWallet, setupKeysFromSeed, recreateStealthAddress, eddsaPoseidonSign, eddsaPoseidonSignWithScalar, eddsaGetPrivScalar, eddsaGetPubKey, createStealthMetaAddress, serializeStealthMetaAddress, deserializeStealthMetaAddress, encodeStealthMetaAddress, decodeStealthMetaAddress, clearUTXOpiaKeys, serializeKeysForStorage, deserializeKeysFromStorage, PASSKEY_CHAIN_SCOPE_DOMAIN, deriveChainScopedPasskeySeed, passkeyStorageOwner, type UTXOpiaKeys, type KeySetupResult, type AuthSignatureKeyDerivationOptions, type AuthSignatureKeySetupResult, type ChainScopedPasskeyOptions, type PasskeyChainScope, type SerializedKeysForStorage, type StealthMetaAddress, type WalletSignerAdapter, } from "./keys";
+export { ViewPermissions, hasPermission, isDelegatedKeyValid, isSlotInDelegatedRange, createDelegatedViewKey, serializeDelegatedViewKey, deserializeDelegatedViewKey, makeDelegationRecord, fingerprintDelegatedKey, clearDelegatedViewKey, extractViewOnlyBundle, type DelegatedViewKey, type DelegationRecord, } from "./keys";
+export { auditScan, auditScanCiphertexts, auditRecordsToCsv, type AuditDirection, type AuditRecord, type AuditScanAnnouncement, type AuditScanOptions, type AuditScanSummary, type OnChainSenderMemo, } from "./auditor";
+export { encryptAuditorCiphertext, decryptAuditorCiphertext, buildAuditorCiphertextForNote, resolveAuditorCiphertext, AUDITOR_CIPHERTEXT_BYTES, type AuditorNotePlain, type AuditorCiphertextInput, } from "./auditor-ciphertext";
+export { generateAuditorViewingKeypair, deriveAuditorViewingKeypair, } from "./keys";
+export { encryptSenderMemo, decryptSenderMemo, deriveOutgoingViewingKey, packSenderMemo, unpackSenderMemo, packSenderMemoForInstruction, buildSenderMemosForTransact, generateSenderMemoNonce, SENDER_MEMO_AMOUNT_BYTES, SENDER_MEMO_CIPHERTEXT_BYTES, SENDER_MEMO_COMMITMENT_BYTES, SENDER_MEMO_NONCE_BYTES, SENDER_MEMO_PACKED_BYTES, SENDER_MEMO_TAG_BYTES, SENDER_MEMO_TOKEN_BYTES, type SenderMemoPlain, type SenderMemoCiphertext, type SenderMemoOutput, } from "./sender-memo";
+export { generateOwnershipProof, generateRangeSumProof, computeRangeSumAttestation, pickRangeSumVariant, RANGE_SUM_N, RANGE_SUM_VARIANTS, RANGE_SUM_SIZES, type OwnershipProofInputs, type OwnershipPublicInputs, type RangeSumAttestationStyle, type RangeSumProofInputs, type RangeSumPublicInputs, } from "./selective-disclosure";
+export { initPoseidon, isPoseidonReady, poseidonHashSync, computeUnifiedCommitmentSync, computeNullifierSync, hashNullifierSync, computeMPKSync, computeNPKSync, computeJoinSplitCommitmentSync, computeJoinSplitNullifierSync, computeTokenId, reduceToField, } from "./poseidon";
+export { fetchTokenConfig, getTokenId, fetchSupportedTokens, fetchEnabledTokens, parseTokenConfig, type TokenConfigData, type SupportedToken, } from "./token-registry";
+export { MAGICBLOCK_DELEGATION_PROGRAM_ID, MAGICBLOCK_DEVNET_ROUTER_URL, MAGICBLOCK_DEVNET_ROUTER_WS_URL, MAGICBLOCK_EPHEMERAL_VAULT_ID, MAGICBLOCK_MAGIC_CONTEXT_ID, MAGICBLOCK_MAGIC_PROGRAM_ID, MAGICBLOCK_MAX_PER_MEMBERS, MAGICBLOCK_PERMISSION_PROGRAM_ID, MAGICBLOCK_PER_MEMBER_FLAGS, MAGICBLOCK_VALIDATOR_IDENTITIES, buildDefaultPrivacyDomain, buildMagicBlockPerMemberFlags, deriveMagicBlockCommitRecordPDA, deriveMagicBlockCommitStatePDA, deriveMagicBlockDelegateBufferPDA, deriveMagicBlockDelegationMetadataPDA, deriveMagicBlockDelegationRecordPDA, deriveMagicBlockPermissionPDA, deriveMagicBlockUndelegateBufferPDA, requiresMagicBlockEndpoint, getMagicBlockEndpoint, getMagicBlockValidatorIdentity, createMagicBlockRouterConnection, type BuildPrivacyDomainOptions, type MagicBlockEndpointConfig, type MagicBlockExecutionMode, type MagicBlockPolicyMode, type MagicBlockPerMemberFlagName, type MagicBlockValidatorRegion, type PrivacyDomainConfig, type PrivacyDomainKind, } from "./magicblock";
+export { generateNote, createNoteFromSecrets, serializeNote, deserializeNote, noteHasComputedHashes, getNotePublicKeyX, computeNoteCommitment, computeNoteNullifier, formatBtc, parseBtc, deriveNote, deriveNotes, deriveMasterKey, deriveNoteFromMaster, estimateSeedStrength, createNote, prepareWithdrawal, createStealthNote, serializeStealthNote, deserializeStealthNote, type Note, type SerializedNote, type NoteData, type StealthNote, type SerializedStealthNote, createJoinSplitNote, computeJoinSplitNoteNullifier, serializeJoinSplitNote, deserializeJoinSplitNote, type JoinSplitNote, type SerializedJoinSplitNote, } from "./note";
+export { createMerkleProof, createMerkleProofFromBigints, proofToCircomFormat, proofToOnChainFormat, createEmptyMerkleProof, leafIndexToPathIndices, pathIndicesToLeafIndex, validateMerkleProofStructure, parseMerkleProofResponse, TREE_DEPTH, ROOT_HISTORY_SIZE, MAX_LEAVES, ZERO_VALUE, type MerkleProof, } from "./merkle";
+export { deriveTaprootAddress, deriveTaprootAddressWithRefund, buildRefundScript, computeTapLeafHash, verifyTaprootAddress, createP2TRScriptPubkey, parseP2TRScriptPubkey, isValidBitcoinAddress, getInternalKey, createCustomInternalKey, createOpReturnScriptFromPayload, buildDepositOpReturn, parseDepositOpReturn, encodeDepositOpReturnHeader, decodeDepositOpReturnHeader, validateDepositOpReturnContext, computeDepositPoolTag, DEPOSIT_DESTINATION_CHAIN, DEPOSIT_BITCOIN_NETWORK, DEPOSIT_OP_RETURN_VERSION, DEPOSIT_POOL_TAG_SIZE, DEPOSIT_OP_RETURN_SIZE, type DepositDestinationChain, type DepositBitcoinNetwork, type DepositOpReturnContext, type ParsedDepositOpReturn, } from "./taproot";
+export { encodeClaimLink, decodeClaimLink, parseClaimUrl, } from "./claim-link";
+export type { ProofData, MerkleProofInput, CircuitType, JoinSplitProofInputs, } from "./prover/web";
+export { uploadTransactionToBuffer, uploadProofToBuffer, closeBuffer, readBufferData, fetchRawTransaction, fetchMerkleProof, prepareVerifyDeposit, buildMerkleProof, needsBuffer as bufferNeedsBuffer, getProofSource, calculateUploadTransactions, CHADBUFFER_PROGRAM_ID, AUTHORITY_SIZE, MAX_DATA_PER_WRITE, SOLANA_TX_SIZE_LIMIT, type ProofUploadResult, } from "./chadbuffer";
+export { computeBoundParamsHash, computeSolanaDomainBoundParamsHash, computeSolanaDomainSeparator, computeStealthDataHash, createTransferBoundParams, createUnshieldBoundParams, createRedeemBoundParams, SOLANA_BOUND_CHAIN_ID, SOLANA_DEVNET_BOUND_CHAIN_ID, SOLANA_MAINNET_BOUND_CHAIN_ID, DEFAULT_BOUND_PARAMS, type BoundParams, type BoundParamsMode, type SolanaPrivacyDomainContext, type SolanaPrivacyDomainKind, } from "./bound-params";
+export { getConfig, setConfig, createConfig, initConfig, DEVNET_CONFIG, MAINNET_CONFIG, LOCALNET_CONFIG, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, ATA_PROGRAM_ID, UTXOPIA_POLICY_PROGRAM_ID, SDK_VERSION, DEPLOYMENT_INFO, JOINSPLIT_TREE_DEPTH, type NetworkConfig, type NetworkType, } from "./config";
+export { POOL_STATE_DISCRIMINATOR, POOL_STATE_LEN, POOL_STATE_OFFSETS, POOL_FLAG, parsePoolState, parsePoolFees, BPS_DENOMINATOR, computeBpsFee, feeShareBps, } from "./pool-state";
+export type { PoolState, PoolFees } from "./pool-state";
+export { PDA_SEEDS, poolStateSeeds, commitmentTreeSeeds, tokenConfigSeeds, poolConfigSeeds, nullifierRecordSeeds, redemptionRequestSeeds, vkRegistrySeeds, depositReceiptSeeds, policyApprovalSeeds, exitDestinationSeeds, lightClientSeeds, blockHeaderSeeds, heightIndexSeeds, verifiedTransactionSeeds, derivePoolStatePDA, deriveCommitmentTreePDA, deriveNullifierRecordPDA, derivePolicyApprovalPDA, deriveExitDestinationPDA, EXIT_KIND_SOLANA_OWNER, EXIT_KIND_BTC_SCRIPT, deriveLightClientPDA, deriveBlockHeaderPDA, deriveHeightIndexPDA, deriveVkRegistryPDA, deriveRedemptionRequestPDA, deriveTokenConfigPDA, derivePoolConfigPDA, deriveDepositReceiptPDA, commitmentToBytes, } from "./pda";
+export { createStealthDeposit, createStealthDepositWithKeys, createStealthOutput, createStealthOutputWithKeys, createStealthOutputForCommitment, packStealthOutputForCircuit, scanAnnouncements, scanAnnouncementsViewOnly, scanAnnouncementsViewOnlyMulti, exportViewOnlyKeys, encodeViewOnlyKeys, decodeViewOnlyKeys, prepareClaimInputs, scanUnifiedNotes, scanUnifiedNotesMulti, encryptAmount, decryptAmount, computeNullifierHashForNote, computeNullifierBytes, parseAnnouncementsFromHex, createDepositFromConfig, createDirectVaultDeposit, isDepositForViewer, isDepositForViewerHex, ANNOUNCEMENT_TYPE_DEPOSIT, ANNOUNCEMENT_TYPE_TRANSFER, type StealthDeposit, type StealthOutputData, type StealthOutputWithKeys, type CircuitStealthOutput, type ScannedNote, type ClaimInputs as StealthClaimInputs, type OnChainStealthAnnouncement, type ConnectionAdapter, type ViewOnlyKeys, type ViewOnlyScannedNote, createNonInteractiveDeposit, pickIkaCustodyKey, type NonInteractiveDepositResult, type NonInteractiveDepositWithRefundResult, } from "./stealth";
+export { buildDepositPsbt, estimateDepositFee, fetchUtxos, selectUtxos, type BuildDepositPsbtParams, type BuildDepositPsbtResult, type UtxoDescriptor, } from "./psbt";
+export { EsploraClient, esploraTestnet, esploraMainnet, type EsploraTransaction, type EsploraVin, type EsploraVout, type EsploraStatus, type EsploraAddressInfo, type EsploraUtxo, type EsploraMerkleProof, type EsploraNetwork, } from "./core/esplora";
+export { MempoolClient, mempoolTestnet, mempoolMainnet, reverseBytes, type BlockHeader, type TransactionInfo, type SPVProofData, } from "./core/mempool";
+export { estimatePriorityFee, buildPriorityFeeInstructionData, encodeSetComputeUnitLimit, encodeSetComputeUnitPrice, getHeliusRpcUrl, DEFAULT_COMPUTE_UNITS, DEFAULT_PRIORITY_FEE, COMPUTE_BUDGET_DISCRIMINATORS, type PriorityFeeConfig, type PriorityFeeEstimate, type PriorityFeeInstructions, } from "./solana/priority-fee";
+export { setDebug } from "./logger";
+export { createFetchConnectionAdapter, createConnectionAdapterFromWeb3, createConnectionAdapterFromKit, getConnectionAdapter, clearConnectionAdapterCache, type RpcConfig, type Web3Connection, type KitRpc, } from "./solana/connection";
+export { resolveSnsName, resolveStealthName, parseSnsStealthData, isSnsStealthAddress, isAuditorDisclosable, SnsComplianceFlags, SNS_COMPLIANCE_AUDITOR_OFFSET, SNS_COMPLIANCE_AUDITOR_BYTES, deriveParentDomainKey, SNS_STEALTH_DATA_SIZE, type SnsStealthAddress, } from "./sns-resolver";
+export { COMMITMENT_TREE_DISCRIMINATOR, parseCommitmentTreeData, isValidRoot, fetchCommitmentTree, getCommitmentIndex, saveCommitmentIndex, CommitmentTreeIndex, buildCommitmentTreeFromChain, fetchLeafIndexForCommitment, fetchMerkleProofForCommitment, getMerkleProofFromTree, type CommitmentTreeState, type RpcClient, type OnChainMerkleProof, } from "./commitment-tree";
+export { INSTRUCTION_DISCRIMINATORS, buildShieldInstructionData, buildShieldInstruction, type ShieldInstructionOptions, buildApproveRedemptionSigningInstructionData, buildApproveRedemptionSigningInstruction, buildCancelRedemptionInstructionData, buildCancelRedemptionInstruction, type CancelRedemptionInstructionOptions, bigintTo32Bytes, bytes32ToBigint, buildTransactInstructionData, buildTransactInstruction, buildRedeemInstructionData, buildUnshieldInstructionData, buildUnshieldInstruction, buildProposePoolUpdateInstructionData, buildProposePoolUpdateInstruction, buildExecutePoolUpdateInstructionData, buildExecutePoolUpdateInstruction, buildCancelPoolUpdateInstructionData, buildCancelPoolUpdateInstruction, buildRotateTreeInstructionData, buildRotateTreeInstruction, type RotateTreeOptions, buildMagicBlockDelegateInstructionData, buildMagicBlockDelegateInstruction, buildMagicBlockCommitInstructionData, buildMagicBlockCommitInstruction, buildMagicBlockPerPermissionInstructionData, buildMagicBlockPerPermissionInstruction, buildPolicyRequestHash, buildPolicyIntentParts, buildRegisterExitDestinationInstruction, buildRegisterExitDestinationInstructionData, MAX_POLICY_INTENT_PARTS, buildInitializePolicyApprovalInstructionData, buildInitializePolicyApprovalInstruction, buildPolicyApprovalDecisionInstruction, buildPolicyApprovalCommitInstruction, buildCompleteDepositPermissionedInstructionData, buildCompleteDepositPermissionedInstruction, buildShieldPermissionedInstructionData, buildShieldPermissionedInstruction, buildRotateAuditorInstructionData, buildRotateAuditorInstruction, type MagicBlockDelegateTarget, type MagicBlockDelegateInstructionOptions, type MagicBlockCommitInstructionOptions, type MagicBlockPerPermissionOperation, type MagicBlockPerPermissionMember, type MagicBlockPerPermissionInstructionOptions, type PolicyApprovalDecision, type InitializePolicyApprovalOptions, type CompleteDepositPermissionedOptions, type ShieldPermissionedInstructionOptions, type RotateAuditorOptions, buildVerifyTransactionInstructionData, buildCompleteDepositInstructionData, buildSetPoolConfigInstructionData, parsePoolConfig, type ParsedPoolConfig, POOL_CONFIG_DISCRIMINATOR, POOL_CONFIG_LEN, POOL_SCRIPT_MAX_LEN, type Instruction, type ApproveRedemptionSigningInstructionOptions, type TransactInstructionOptions, type UnshieldInstructionOptions, type ProposePoolUpdateOptions, type ExecutePoolUpdateOptions, type CancelPoolUpdateOptions, } from "./instructions";
+export { VK_REGISTRY_DISCRIMINATOR, VK_REGISTRY_LEN, MAX_IC_POINTS, MAX_SAFE_JOINSPLIT_SIZE, INIT_VK_REGISTRY_DISCRIMINATOR, UPDATE_VK_REGISTRY_DISCRIMINATOR, joinSplitNumPublicInputs, computeVkHash, vkeyJsonToVkMaterial, buildVkRegistryData, parseVkRegistry, assertVkRegistryForShape, isVkRegistryReady, type JoinSplitVkMaterial, type SnarkjsVkeyJson, type ParsedVkRegistry, } from "./vk-registry";
+export { fetchExplorerDeposits, fetchExplorerTransfers, fetchExplorerRedemptions, parseNullifierRecord, parseRedemptionRequest, NULLIFIER_RECORD_SIZE, REDEMPTION_REQUEST_SIZE, NULLIFIER_RECORD_DISCRIMINATOR, REDEMPTION_REQUEST_DISCRIMINATOR, OPERATION_TYPE_LABELS, type ExplorerDeposit, type ExplorerTransferEvent, type ExplorerRedemption, type IndexerLeaf, } from "./explorer";
+export { parseProgramEvents, parseNullifierSpentEvent, parseStealthAnnouncementEvent, parseSenderMemoEvent, parseBtcOriginAttestationEvent, parseAuditorCiphertextEvent, EVENT_NULLIFIER_SPENT, EVENT_STEALTH_ANNOUNCEMENT, EVENT_NULLIFIERS_BATCH, EVENT_ANNOUNCEMENTS_BATCH, EVENT_SENDER_MEMO, EVENT_BTC_ORIGIN_ATTESTATION, EVENT_AUDITOR_CIPHERTEXT, type NullifierSpentEvent, type StealthAnnouncementEvent, type SenderMemoEvent, type BtcOriginAttestationEvent, type AuditorCiphertextEvent, type ProgramEvent, } from "./events";
+export { AnnouncementClient, type AnnouncementClientConfig, type AnnouncementListener, } from "./announcement-client";
+export { EventClient, type LeafInsertedEvent as EventLeafInserted, type NullifierSpentEvent as EventNullifierSpent, type AnnouncementEvent as EventAnnouncement, type ServerEvent as EventServerEvent, type EventListener, type TreeStatusResponse, type NullifierPdasResponse, } from "./event-client";
+export { UTXOpiaClient, type UTXOpiaClientConfig, type TokenDefinition, type InboxNote as ClientInboxNote, } from "./client";