@utxopia/sdk 0.1.0-alpha.1

package/packages/sdk/dist/bitcoin/ika.js

@@ -0,0 +1,74 @@
+/**
+ * Ika dWallet → Bitcoin P2TR address derivation.
+ *
+ * UTXOpia v2 custody is held by an Ika dWallet on Solana. The dWallet's
+ * compressed secp256k1 public key (or its x-only form) identifies the Bitcoin
+ * key that Ika can sign for. Ika pre-alpha signs for the raw x-only key; it
+ * does not currently produce signatures for UTXOpia's per-deposit tweaked keys.
+ */
+import { taggedHash, hexToBytes, bytesToHex } from "../crypto";
+import { bech32m } from "bech32";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+/**
+ * Derive the BIP-341 P2TR (key-path-only) address controlled by an Ika dWallet.
+ *
+ * BIP-341 (no script tree):
+ *   t = h_tapTweak(P)
+ *   Q = P + t*G
+ *   output_key = x(Q)
+ *   address = bech32m(hrp, [witness_version=1, ...words(output_key)])
+ *
+ * @param ref       The Ika dWallet reference (literal pubkey, or future async id).
+ * @param network   "mainnet" | "testnet" | "regtest"
+ * @returns         The P2TR address (`bc1p…` / `tb1p…` / `bcrt1p…`)
+ */
+export function deriveCustodyAddressFromIkaDWallet(ref, network) {
+    const xonly = extractXOnly(ref);
+    const tweak = taggedHash("TapTweak", xonly);
+    const tweakScalar = bytesToBigIntBe(tweak);
+    // Lift x-only to a full point with even y (BIP-340 convention).
+    const internalPoint = secp256k1.Point.fromHex("02" + bytesToHex(xonly));
+    const tweakPoint = secp256k1.Point.BASE.multiply(tweakScalar);
+    const outputPoint = internalPoint.add(tweakPoint);
+    // Drop the 1-byte parity prefix to get the x-only output key.
+    const outputKey = hexToBytes(outputPoint.toHex(true).slice(2));
+    const hrp = network === "mainnet" ? "bc" : network === "regtest" ? "bcrt" : "tb";
+    const words = bech32m.toWords(outputKey);
+    return bech32m.encode(hrp, [1, ...words]);
+}
+/**
+ * Encode a raw x-only public key as a P2TR witness program.
+ *
+ * This intentionally does not apply BIP-341's no-script TapTweak. It is the
+ * direct-vault address used by the current Ika pre-alpha mock signer, because
+ * the signer returns Schnorr signatures for the dWallet's raw x-only key.
+ */
+export function deriveRawXOnlyP2TRAddress(xonlyPubkey, network) {
+    if (xonlyPubkey.length !== 32) {
+        throw new Error("xonlyPubkey must be 32 bytes");
+    }
+    const hrp = network === "mainnet" ? "bc" : network === "regtest" ? "bcrt" : "tb";
+    return bech32m.encode(hrp, [1, ...bech32m.toWords(xonlyPubkey)]);
+}
+function extractXOnly(ref) {
+    if (ref.type === "literal-xonly") {
+        if (ref.xonlyPubkey.length !== 32) {
+            throw new Error("xonlyPubkey must be 32 bytes");
+        }
+        return ref.xonlyPubkey;
+    }
+    if (ref.type === "literal-compressed") {
+        if (ref.compressedPubkey.length !== 33) {
+            throw new Error("compressedPubkey must be 33 bytes");
+        }
+        return ref.compressedPubkey.subarray(1);
+    }
+    throw new Error("deriveCustodyAddressFromIkaDWallet: 'id' resolution requires the Ika SDK; " +
+        "resolve dwalletId → pubkey first and pass via literal-xonly or literal-compressed");
+}
+function bytesToBigIntBe(bytes) {
+    let n = 0n;
+    for (const b of bytes)
+        n = (n << 8n) | BigInt(b);
+    return n;
+}

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

@@ -0,0 +1,2 @@
+export { deriveCustodyAddressFromIkaDWallet, deriveRawXOnlyP2TRAddress, } from "./ika";
+export type { IkaDWalletRef } from "./ika";

package/packages/sdk/dist/bitcoin/index.js

@@ -0,0 +1 @@
+export { deriveCustodyAddressFromIkaDWallet, deriveRawXOnlyP2TRAddress, } from "./ika";

package/packages/sdk/dist/bound-params.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Bound Parameters Hash for JoinSplit transactions
+ *
+ * The operation hash binds transaction metadata to the proof:
+ * - treeNumber: Which commitment tree (for multi-tree support)
+ * - unshieldAddress: Recipient for public unshield (null = private transfer)
+ * - chainId: Prevents cross-chain replay
+ * - stealthDataHash: SHA256 of concatenated stealth data (prevents relayer tampering)
+ *
+ * Hash: SHA256(serialize(params)) mod BN254_SCALAR_FIELD
+ *
+ * Solana callers must wrap this operation hash with
+ * `computeSolanaDomainBoundParamsHash()` before generating a proof.
+ */
+/** Bound params mode: transfer(0), unshield(1), redeem(2) */
+export type BoundParamsMode = 'transfer' | 'unshield' | 'redeem';
+export interface BoundParams {
+    /** Tree number (0 for default) */
+    treeNumber: number;
+    /** Unshield recipient address (null = private transfer, 32 bytes = public unshield/redeem) */
+    unshieldAddress: Uint8Array | null;
+    /** Chain ID (prevents cross-chain replay) */
+    chainId: bigint;
+    /** Mode flag: 'transfer'(0), 'unshield'(1), 'redeem'(2). Defaults to inferred from unshieldAddress. */
+    mode?: BoundParamsMode;
+    /** SHA256 of concatenated stealth data (prevents relayer from corrupting change outputs) */
+    stealthDataHash: Uint8Array;
+    /**
+     * Requester pubkey (32 bytes) — REQUIRED for redeem. Binds the proof to the signing account
+     * that becomes RedemptionRequest.requester so a privileged orderflow actor cannot replay the
+     * proof under their own key. Ignored for transfer/unshield.
+     */
+    requester?: Uint8Array;
+}
+export type SolanaPrivacyDomainKind = "public" | "institution";
+export interface SolanaPrivacyDomainContext {
+    programId: Uint8Array;
+    poolState: Uint8Array;
+    kind: SolanaPrivacyDomainKind;
+}
+/**
+ * Compute the canonical public/institution domain field for Solana.
+ *
+ * SHA256("UTXOPIA_DOMAIN_V1" || chainIdLE || programId || poolState || kind)
+ * reduced modulo BN254 Fr. The on-chain verifier recomputes this from the
+ * actual program, pool account, and PoolState.permissioned flag.
+ */
+export declare function computeSolanaDomainSeparator(context: SolanaPrivacyDomainContext, chainId?: bigint): bigint;
+/**
+ * Bind an operation-specific hash to its exact Solana privacy domain.
+ *
+ * This occupies the existing boundParamsHash public input, so circuit/VK
+ * dimensions remain unchanged while proofs become non-replayable across pools.
+ */
+export declare function computeSolanaDomainBoundParamsHash(params: BoundParams, context: SolanaPrivacyDomainContext): bigint;
+/**
+ * Compute SHA256 hash of concatenated stealth data arrays.
+ * Returns 32-byte hash, or all zeros if no stealth data.
+ */
+export declare function computeStealthDataHash(stealthData: Uint8Array[]): Uint8Array;
+/**
+ * Compute the operation-specific bound parameters hash.
+ *
+ * Solana callers must wrap this with
+ * `computeSolanaDomainBoundParamsHash()` to bind the program and pool.
+ *
+ * Deterministic serialization:
+ * - treeNumber: 4 bytes LE
+ * - flag: 1 byte (0=transfer, 1=unshield, 2=redeem)
+ * - unshieldAddress: 32 bytes (zeros if null)
+ * - chainId: 8 bytes LE
+ * - stealthDataHash: 32 bytes (SHA256 of concatenated stealth data)
+ * - requester: 32 bytes (redeem only — appended, extending the buffer to 109 bytes)
+ *
+ * Total: 77 bytes (transfer/unshield) or 109 bytes (redeem) → SHA256 → mod BN254
+ */
+export declare function computeBoundParamsHash(params: BoundParams): bigint;
+/** Canonical chain ids folded into bound-params hashes (must match on-chain). */
+export declare const SOLANA_MAINNET_BOUND_CHAIN_ID = 101n;
+export declare const SOLANA_DEVNET_BOUND_CHAIN_ID = 103n;
+/** Backward-compatible devnet alias. Prefer the network-specific constants. */
+export declare const SOLANA_BOUND_CHAIN_ID = 103n;
+/**
+ * Default bound params for Solana devnet (private transfer)
+ */
+export declare function createTransferBoundParams(stealthDataHash: Uint8Array, chainId?: bigint, treeNumber?: number): BoundParams;
+/** @deprecated Use createTransferBoundParams instead */
+export declare const DEFAULT_BOUND_PARAMS: BoundParams;
+export declare function createRedeemBoundParams(btcScripts: Uint8Array | Uint8Array[], stealthDataHash: Uint8Array, requester: Uint8Array, chainId?: bigint, treeNumber?: number): BoundParams;
+/**
+ * Create bound params for an unshield (public withdrawal, multi-output)
+ *
+ * For multi-output: destinations_hash = SHA256(owner_1 || owner_2 || ...)
+ * For single output: SHA256(owner_1) — no special case.
+ */
+export declare function createUnshieldBoundParams(recipientAddresses: Uint8Array | Uint8Array[], stealthDataHash: Uint8Array, chainId?: bigint, treeNumber?: number): BoundParams;

package/packages/sdk/dist/bound-params.js

@@ -0,0 +1,249 @@
+/**
+ * Bound Parameters Hash for JoinSplit transactions
+ *
+ * The operation hash binds transaction metadata to the proof:
+ * - treeNumber: Which commitment tree (for multi-tree support)
+ * - unshieldAddress: Recipient for public unshield (null = private transfer)
+ * - chainId: Prevents cross-chain replay
+ * - stealthDataHash: SHA256 of concatenated stealth data (prevents relayer tampering)
+ *
+ * Hash: SHA256(serialize(params)) mod BN254_SCALAR_FIELD
+ *
+ * Solana callers must wrap this operation hash with
+ * `computeSolanaDomainBoundParamsHash()` before generating a proof.
+ */
+import { sha256 } from "@noble/hashes/sha2.js";
+import { BN254_FIELD_PRIME, bytesToBigint } from "./crypto";
+import { poseidonHashSync } from "./poseidon";
+const SOLANA_DOMAIN_TAG = new TextEncoder().encode("UTXOPIA_DOMAIN_V1");
+function assert32Bytes(value, name) {
+    if (value.length !== 32) {
+        throw new Error(`${name} must be 32 bytes`);
+    }
+}
+function u64le(value) {
+    if (value < 0n || value > 0xffffffffffffffffn) {
+        throw new Error("chainId must fit in u64");
+    }
+    const bytes = new Uint8Array(8);
+    let remaining = value;
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = Number(remaining & 0xffn);
+        remaining >>= 8n;
+    }
+    return bytes;
+}
+/**
+ * Compute the canonical public/institution domain field for Solana.
+ *
+ * SHA256("UTXOPIA_DOMAIN_V1" || chainIdLE || programId || poolState || kind)
+ * reduced modulo BN254 Fr. The on-chain verifier recomputes this from the
+ * actual program, pool account, and PoolState.permissioned flag.
+ */
+export function computeSolanaDomainSeparator(context, chainId = SOLANA_BOUND_CHAIN_ID) {
+    assert32Bytes(context.programId, "programId");
+    assert32Bytes(context.poolState, "poolState");
+    if (context.kind !== "public" && context.kind !== "institution") {
+        throw new Error("kind must be public or institution");
+    }
+    const preimage = new Uint8Array(SOLANA_DOMAIN_TAG.length + 8 + 32 + 32 + 1);
+    let offset = 0;
+    preimage.set(SOLANA_DOMAIN_TAG, offset);
+    offset += SOLANA_DOMAIN_TAG.length;
+    preimage.set(u64le(chainId), offset);
+    offset += 8;
+    preimage.set(context.programId, offset);
+    offset += 32;
+    preimage.set(context.poolState, offset);
+    offset += 32;
+    preimage[offset] = context.kind === "institution" ? 1 : 0;
+    return bytesToBigint(sha256(preimage)) % BN254_FIELD_PRIME;
+}
+/**
+ * Bind an operation-specific hash to its exact Solana privacy domain.
+ *
+ * This occupies the existing boundParamsHash public input, so circuit/VK
+ * dimensions remain unchanged while proofs become non-replayable across pools.
+ */
+export function computeSolanaDomainBoundParamsHash(params, context) {
+    if (params.chainId !== SOLANA_DEVNET_BOUND_CHAIN_ID
+        && params.chainId !== SOLANA_MAINNET_BOUND_CHAIN_ID) {
+        throw new Error("Solana domain binding requires a supported Solana chain ID");
+    }
+    return poseidonHashSync([
+        computeSolanaDomainSeparator(context, params.chainId),
+        computeBoundParamsHash(params),
+    ]);
+}
+/**
+ * Compute SHA256 hash of concatenated stealth data arrays.
+ * Returns 32-byte hash, or all zeros if no stealth data.
+ */
+export function computeStealthDataHash(stealthData) {
+    // Always SHA256 the concatenation — even for empty arrays.
+    // On-chain: sha256(&data[stealth_start..stealth_end]) — empty slice → sha256("")
+    const totalLen = stealthData.reduce((sum, sd) => sum + sd.length, 0);
+    const concat = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const sd of stealthData) {
+        concat.set(sd, offset);
+        offset += sd.length;
+    }
+    return sha256(concat);
+}
+/**
+ * Compute the operation-specific bound parameters hash.
+ *
+ * Solana callers must wrap this with
+ * `computeSolanaDomainBoundParamsHash()` to bind the program and pool.
+ *
+ * Deterministic serialization:
+ * - treeNumber: 4 bytes LE
+ * - flag: 1 byte (0=transfer, 1=unshield, 2=redeem)
+ * - unshieldAddress: 32 bytes (zeros if null)
+ * - chainId: 8 bytes LE
+ * - stealthDataHash: 32 bytes (SHA256 of concatenated stealth data)
+ * - requester: 32 bytes (redeem only — appended, extending the buffer to 109 bytes)
+ *
+ * Total: 77 bytes (transfer/unshield) or 109 bytes (redeem) → SHA256 → mod BN254
+ */
+export function computeBoundParamsHash(params) {
+    const isRedeem = params.mode === 'redeem';
+    // Redeem binds the requester pubkey, extending the preimage by 32 bytes (must match the
+    // on-chain compute_bound_params_hash_redeem layout).
+    const buf = new Uint8Array(isRedeem ? 109 : 77);
+    const view = new DataView(buf.buffer);
+    // treeNumber (4 bytes LE)
+    view.setUint32(0, params.treeNumber, true);
+    // flag byte: transfer=0, unshield=1, redeem=2
+    if (isRedeem) {
+        buf[4] = 2;
+    }
+    else if (params.mode === 'unshield' || params.unshieldAddress) {
+        buf[4] = 1;
+    }
+    else {
+        buf[4] = 0;
+    }
+    // unshieldAddress (32 bytes, zeros if null)
+    if (params.unshieldAddress) {
+        buf.set(params.unshieldAddress.slice(0, 32), 5);
+    }
+    // chainId (8 bytes LE)
+    const chainIdBuf = new Uint8Array(8);
+    let chainId = params.chainId;
+    for (let i = 0; i < 8; i++) {
+        chainIdBuf[i] = Number(chainId & 0xffn);
+        chainId >>= 8n;
+    }
+    buf.set(chainIdBuf, 37);
+    // stealthDataHash (32 bytes)
+    buf.set(params.stealthDataHash.slice(0, 32), 45);
+    // requester (32 bytes) — redeem only
+    if (isRedeem) {
+        if (!params.requester || params.requester.length !== 32) {
+            throw new Error("redeem bound params require a 32-byte requester pubkey");
+        }
+        buf.set(params.requester.slice(0, 32), 77);
+    }
+    // SHA256 → mod BN254
+    const hash = sha256(buf);
+    return bytesToBigint(hash) % BN254_FIELD_PRIME;
+}
+/** Canonical chain ids folded into bound-params hashes (must match on-chain). */
+export const SOLANA_MAINNET_BOUND_CHAIN_ID = 101n;
+export const SOLANA_DEVNET_BOUND_CHAIN_ID = 103n;
+/** Backward-compatible devnet alias. Prefer the network-specific constants. */
+export const SOLANA_BOUND_CHAIN_ID = SOLANA_DEVNET_BOUND_CHAIN_ID;
+/**
+ * Default bound params for Solana devnet (private transfer)
+ */
+export function createTransferBoundParams(stealthDataHash, chainId = 103n, treeNumber = 0) {
+    return {
+        treeNumber,
+        unshieldAddress: null,
+        chainId,
+        stealthDataHash,
+    };
+}
+/** @deprecated Use createTransferBoundParams instead */
+export const DEFAULT_BOUND_PARAMS = {
+    treeNumber: 0,
+    unshieldAddress: null,
+    chainId: 103n,
+    stealthDataHash: new Uint8Array(32),
+};
+/**
+ * Create bound params for a redeem (JoinSplit → BTC withdrawal, multi-output)
+ *
+ * The BTC scriptPubKeys are concatenated and SHA-256 hashed into the address field
+ * so the proof cryptographically binds ALL withdrawal destinations.
+ *
+ * For single output: SHA256(script_1) — no special case.
+ * For multi-output: SHA256(script_1 || script_2 || ...)
+ *
+ * `requester` is the 32-byte pubkey of the signer that will submit the redeem (becomes
+ * RedemptionRequest.requester); it is bound into the hash so the proof cannot be replayed
+ * under a different signer.
+ */
+function u32le(n) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setUint32(0, n >>> 0, true);
+    return b;
+}
+export function createRedeemBoundParams(btcScripts, stealthDataHash, requester, chainId = 103n, treeNumber = 0) {
+    if (!requester || requester.length !== 32) {
+        throw new Error("createRedeemBoundParams requires a 32-byte requester pubkey");
+    }
+    // Normalize to array
+    const scripts = btcScripts instanceof Uint8Array ? [btcScripts] : btcScripts;
+    // Length-prefixed scripts hash (audit #4): sha256(u32le(count) || per-script
+    // [u32le(len) || bytes]). Binds the script boundaries so a redeem proof cannot be
+    // replayed with the scripts re-partitioned to the same concatenation. Must match the
+    // on-chain Solana `length_prefixed_hash` in compute_bound_params_hash_redeem.
+    const lpParts = [u32le(scripts.length)];
+    for (const s of scripts) {
+        lpParts.push(u32le(s.length), s);
+    }
+    const lpTotal = lpParts.reduce((sum, p) => sum + p.length, 0);
+    const lp = new Uint8Array(lpTotal);
+    let off = 0;
+    for (const p of lpParts) {
+        lp.set(p, off);
+        off += p.length;
+    }
+    const scriptHash = sha256(lp);
+    return {
+        treeNumber,
+        unshieldAddress: scriptHash,
+        chainId,
+        mode: 'redeem',
+        stealthDataHash,
+        requester,
+    };
+}
+/**
+ * Create bound params for an unshield (public withdrawal, multi-output)
+ *
+ * For multi-output: destinations_hash = SHA256(owner_1 || owner_2 || ...)
+ * For single output: SHA256(owner_1) — no special case.
+ */
+export function createUnshieldBoundParams(recipientAddresses, stealthDataHash, chainId = 103n, treeNumber = 0) {
+    // Normalize to array
+    const addrs = recipientAddresses instanceof Uint8Array ? [recipientAddresses] : recipientAddresses;
+    // Concatenate all addresses
+    const totalLen = addrs.reduce((sum, a) => sum + a.length, 0);
+    const concat = new Uint8Array(totalLen);
+    let off = 0;
+    for (const a of addrs) {
+        concat.set(a, off);
+        off += a.length;
+    }
+    const addressHash = sha256(concat);
+    return {
+        treeNumber,
+        unshieldAddress: addressHash,
+        chainId,
+        stealthDataHash,
+    };
+}

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

@@ -0,0 +1,124 @@
+/**
+ * ChadBuffer Client
+ *
+ * Helper functions to upload Bitcoin transaction data to ChadBuffer
+ * for SPV verification on Solana.
+ *
+ * Networks: Bitcoin Testnet4, Solana Devnet
+ *
+ * Reference: https://github.com/deanmlittle/chadbuffer
+ */
+import { type Address, type KeyPairSigner, type Rpc, type RpcSubscriptions, type SolanaRpcApi, type SolanaRpcSubscriptionsApi } from "@solana/kit";
+export declare const CHADBUFFER_PROGRAM_ID: Address;
+export declare const AUTHORITY_SIZE = 32;
+export declare const SOLANA_TX_SIZE_LIMIT = 1232;
+/**
+ * Maximum data bytes per ChadBuffer Write transaction
+ * Dynamically calculated from TX limit minus overhead
+ */
+export declare const MAX_DATA_PER_WRITE: number;
+/**
+ * Upload raw Bitcoin transaction to ChadBuffer
+ *
+ * @param rpc - Solana RPC client
+ * @param rpcSubscriptions - Solana RPC subscriptions client
+ * @param payer - Transaction fee payer (KeyPairSigner)
+ * @param rawTx - Raw Bitcoin transaction bytes
+ * @param seed - Optional seed for buffer keypair derivation
+ * @returns Buffer address
+ */
+export declare function uploadTransactionToBuffer(rpc: Rpc<SolanaRpcApi>, rpcSubscriptions: RpcSubscriptions<SolanaRpcSubscriptionsApi>, payer: KeyPairSigner, rawTx: Uint8Array, seed?: Uint8Array): Promise<Address>;
+/**
+ * Close buffer and reclaim rent
+ */
+export declare function closeBuffer(rpc: Rpc<SolanaRpcApi>, rpcSubscriptions: RpcSubscriptions<SolanaRpcSubscriptionsApi>, payer: KeyPairSigner, bufferAddress: Address, recipient?: Address): Promise<string>;
+/**
+ * Read buffer data
+ */
+export declare function readBufferData(rpc: Rpc<SolanaRpcApi>, bufferAddress: Address): Promise<{
+    authority: Address;
+    data: Uint8Array;
+}>;
+/**
+ * Fetch raw Bitcoin transaction from Esplora/Blockstream API
+ */
+export declare function fetchRawTransaction(txid: string, network?: "mainnet" | "testnet" | "testnet4"): Promise<Uint8Array>;
+/**
+ * Fetch merkle proof from Esplora/Blockstream API
+ */
+export declare function fetchMerkleProof(txid: string, network?: "mainnet" | "testnet" | "testnet4"): Promise<{
+    blockHeight: number;
+    merkleProof: Uint8Array[];
+    txIndex: number;
+}>;
+export { bytesToHex } from "./crypto";
+/**
+ * Build merkle proof data for on-chain verification
+ *
+ * Layout:
+ * - txid: [u8; 32]
+ * - num_siblings: u8
+ * - siblings: [[u8; 32]; num_siblings]
+ * - tx_index: u32 (little-endian)
+ *
+ * @param txidBytes - 32-byte txid (already reversed for internal byte order)
+ * @param merkleProof - Array of 32-byte sibling hashes
+ * @param txIndex - Transaction index in block
+ * @returns Merkle proof data as Uint8Array
+ */
+export declare function buildMerkleProof(txidBytes: Uint8Array, merkleProof: Uint8Array[], txIndex: number): Uint8Array;
+/**
+ * Complete flow: Fetch tx, upload to buffer, return verification data
+ */
+export declare function prepareVerifyDeposit(rpc: Rpc<SolanaRpcApi>, rpcSubscriptions: RpcSubscriptions<SolanaRpcSubscriptionsApi>, payer: KeyPairSigner, txid: string, network?: "mainnet" | "testnet" | "testnet4"): Promise<{
+    bufferAddress: Address;
+    transactionSize: number;
+    merkleProof: Uint8Array[];
+    blockHeight: number;
+    txIndex: number;
+    txidBytes: Uint8Array;
+}>;
+/**
+ * Check if a proof needs buffer mode (too large for inline)
+ *
+ * @param proofBytes - Proof data
+ * @param availableSpace - Available space in transaction (default: use buffer for any proof > 900 bytes)
+ */
+export declare function needsBuffer(proofBytes: Uint8Array, availableSpace?: number): boolean;
+/**
+ * Result of uploading a proof to buffer
+ */
+export interface ProofUploadResult {
+    /** Buffer account address */
+    bufferAddress: Address;
+    /** Whether buffer was used (false = inline) */
+    usedBuffer: boolean;
+    /** Number of chunks uploaded */
+    chunksUploaded: number;
+    /** Total proof size */
+    proofSize: number;
+}
+/**
+ * Upload proof to ChadBuffer if needed
+ *
+ * Automatically determines if buffer mode is needed based on proof size.
+ * Returns buffer address for buffer mode, or null for inline mode.
+ *
+ * @param rpc - Solana RPC client
+ * @param rpcSubscriptions - Solana RPC subscriptions client
+ * @param payer - Transaction fee payer
+ * @param proofBytes - Raw proof bytes
+ * @returns Upload result with buffer address (or null if inline)
+ */
+export declare function uploadProofToBuffer(rpc: Rpc<SolanaRpcApi>, rpcSubscriptions: RpcSubscriptions<SolanaRpcSubscriptionsApi>, payer: KeyPairSigner, proofBytes: Uint8Array): Promise<ProofUploadResult>;
+/**
+ * Helper to determine proof source mode
+ */
+export declare function getProofSource(proofBytes: Uint8Array): "inline" | "buffer";
+/**
+ * Calculate required number of transactions for a proof upload
+ *
+ * @param proofSize - Size of proof in bytes
+ * @param useBuffer - Force buffer mode (default: true for proofs > MAX_DATA_PER_WRITE)
+ */
+export declare function calculateUploadTransactions(proofSize: number, useBuffer?: boolean): number;