@babylonlabs-io/ts-sdk 0.0.0-semantic-release.2 → 0.1.0

package/dist/tbv/core/primitives/psbt/__tests__/constants.d.ts

@@ -0,0 +1,137 @@
+import { Buffer } from 'buffer';
+/**
+ * Tapscript leaf version as defined in BIP-341.
+ *
+ * The value 0xc0 (binary: 11000000) represents:
+ * - Bit 0: Parity bit for output key y-coordinate
+ * - Bits 1-7: Leaf version (0xc0 >> 1 = 0x60)
+ *
+ * This is the standard leaf version for Tapscript execution.
+ *
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki
+ * @see Rust: bitcoin::taproot::LeafVersion::TapScript
+ */
+export declare const TAPSCRIPT_LEAF_VERSION = 192;
+/**
+ * Maximum sequence value (no relative timelock).
+ *
+ * When set to 0xffffffff, BIP-68 relative timelocks are disabled.
+ * This is equivalent to Bitcoin's Sequence::MAX.
+ *
+ * @see https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki
+ * @see Rust: bitcoin::Sequence::MAX
+ */
+export declare const SEQUENCE_MAX = 4294967295;
+/**
+ * P2WPKH script prefix (OP_0 + 20-byte push).
+ *
+ * Format: 0x00 (witness version 0) + 0x14 (20 bytes)
+ *
+ * @see BIP-141: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki
+ */
+export declare const P2WPKH_PREFIX = "0014";
+/**
+ * P2TR script prefix (OP_1 + 32-byte push).
+ *
+ * Format: 0x51 (witness version 1 / OP_1) + 0x20 (32 bytes)
+ *
+ * @see BIP-341: https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki
+ */
+export declare const P2TR_PREFIX = "5120";
+/**
+ * All-zeros transaction ID (null/invalid reference).
+ *
+ * Used in tests to create dummy inputs that don't reference real transactions.
+ * Equivalent to Txid::all_zeros() in Rust.
+ *
+ * @see Rust: bitcoin::Txid::all_zeros()
+ */
+export declare const NULL_TXID: Buffer<ArrayBuffer>;
+/**
+ * Dummy transaction ID (filled with 0x01).
+ *
+ * Used to create distinct dummy transactions for claim outputs.
+ */
+export declare const DUMMY_TXID_1: Buffer<ArrayBuffer>;
+/**
+ * Dummy transaction ID (filled with 0x02).
+ *
+ * Used to create distinct dummy transactions for assert outputs.
+ */
+export declare const DUMMY_TXID_2: Buffer<ArrayBuffer>;
+/**
+ * All-ones transaction ID (invalid reference).
+ *
+ * Used in error handling tests to verify behavior with invalid txids.
+ */
+export declare const INVALID_TXID: Buffer<ArrayBuffer>;
+/**
+ * Test pegin amount: 100,000 satoshis (0.001 BTC).
+ *
+ * Represents the vault output value from a peg-in transaction.
+ * This is the amount locked in the vault that the depositor can later claim.
+ *
+ * Equivalent to Rust test constant in pegin_claim_graph.rs.
+ */
+export declare const TEST_PEGIN_VALUE = 100000n;
+/**
+ * Test claim output value: 50,000 satoshis (0.0005 BTC).
+ *
+ * Represents a claim transaction output that can be spent in payout.
+ * In production, claim transactions have 2 outputs for different spending paths.
+ */
+export declare const TEST_CLAIM_VALUE = 50000n;
+/**
+ * Test payout output value: 95,000 satoshis (0.00095 BTC).
+ *
+ * Calculated as: TEST_PEGIN_VALUE - 5,000 sats fee
+ * Represents the amount sent to recipient after deducting transaction fees.
+ */
+export declare const TEST_PAYOUT_VALUE = 95000n;
+/**
+ * Combined payout value with claim inputs: 145,000 satoshis (0.00145 BTC).
+ *
+ * Calculated as: TEST_PEGIN_VALUE + TEST_CLAIM_VALUE - 5,000 sats fee
+ * Used when payout transaction spends both pegin and claim outputs.
+ */
+export declare const TEST_COMBINED_VALUE = 145000n;
+/**
+ * Witness UTXO value for tests: 100,000 satoshis.
+ *
+ * Standard test value used for witnessUtxo in PSBT inputs.
+ */
+export declare const TEST_WITNESS_UTXO_VALUE = 100000;
+/**
+ * Output value after fees: 95,000 satoshis.
+ *
+ * Standard test value for PSBT outputs.
+ */
+export declare const TEST_OUTPUT_VALUE = 95000;
+/**
+ * Creates a dummy P2WPKH scriptPubKey for testing.
+ *
+ * Format: OP_0 <20-byte-hash>
+ * The hash is filled with a repeating character for easy identification in tests.
+ *
+ * @param fillByte - Hex character to repeat (0-f), defaults to "0"
+ * @returns P2WPKH scriptPubKey buffer
+ *
+ * @example
+ * ```typescript
+ * createDummyP2WPKH("0"); // 0x0014 + "0".repeat(40)
+ * createDummyP2WPKH("a"); // 0x0014 + "a".repeat(40)
+ * createDummyP2WPKH("f"); // 0x0014 + "f".repeat(40)
+ * ```
+ */
+export declare function createDummyP2WPKH(fillByte?: string): Buffer;
+/**
+ * Creates a dummy P2TR scriptPubKey using secp256k1 generator point.
+ *
+ * Format: OP_1 <32-byte-x-only-pubkey>
+ *
+ * @returns P2TR scriptPubKey buffer with generator point
+ *
+ * @see secp256k1 specification: https://en.bitcoin.it/wiki/Secp256k1
+ */
+export declare function createDummyP2TR(): Buffer;
+//# sourceMappingURL=constants.d.ts.map

package/dist/tbv/core/primitives/psbt/__tests__/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/primitives/psbt/__tests__/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,MAAO,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,aAAa,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,SAAS,CAAC;AAEpC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,SAAS,CAAC;AAIlC;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,qBAAsB,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,YAAY,qBAAsB,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,YAAY,qBAAsB,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,YAAY,qBAAyB,CAAC;AAInD;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,UAAW,CAAC;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,SAAU,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,UAAW,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,SAAU,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,QAAS,CAAC;AAIxC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,GAAE,MAAY,GAAG,MAAM,CAMhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAQxC"}

package/dist/tbv/core/primitives/psbt/__tests__/helpers.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Test helpers and constants for PSBT primitive tests
+ *
+ * This module provides deterministic test keys and utilities for testing
+ * peg-in PSBT functionality. The keys are derived from simple secret keys
+ * to ensure reproducible test results.
+ *
+ * @module primitives/psbt/__tests__/helpers
+ */
+/**
+ * Test public key constants derived from deterministic secret keys.
+ *
+ * These are valid secp256k1 x-only public keys (32 bytes, 64 hex chars)
+ */
+export declare const TEST_KEYS: {
+    readonly DEPOSITOR: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798";
+    /** Vault provider (formerly claimer) */
+    readonly VAULT_PROVIDER: "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5";
+    /** Vault keeper 1 */
+    readonly VAULT_KEEPER_1: "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9";
+    /** Vault keeper 2 */
+    readonly VAULT_KEEPER_2: "e493dbf1c10d80f3581e4904930b1404cc6c13900ee0758474fa94abe8c4cd13";
+    /** Universal challenger 1 */
+    readonly UNIVERSAL_CHALLENGER_1: "2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4";
+    /** Universal challenger 2 */
+    readonly UNIVERSAL_CHALLENGER_2: "fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556";
+};
+/**
+ * Common test amounts used in peg-in scenarios (in satoshis)
+ */
+export declare const TEST_AMOUNTS: {
+    /** Minimum dust amount (546 sats) */
+    readonly DUST: 546n;
+    /** Small test amount (1,000 sats) */
+    readonly SMALL: 1000n;
+    /** Small peg-in amount (50,000 sats) */
+    readonly PEGIN_SMALL: 50000n;
+    /** Standard peg-in amount (90,000 sats) */
+    readonly PEGIN: 90000n;
+    /** Medium peg-in amount (0.001 BTC = 100,000 sats) */
+    readonly PEGIN_MEDIUM: 100000n;
+    /** Large peg-in amount (0.01 BTC = 1,000,000 sats) */
+    readonly PEGIN_LARGE: 1000000n;
+    /** 1 BTC amount (100,000,000 sats) */
+    readonly ONE_BTC: 100000000n;
+    /** Maximum Bitcoin supply (21M BTC in sats) */
+    readonly MAX: 2100000000000000n;
+};
+/**
+ * Initialize WASM module for Node.js testing environment.
+ *
+ * This function loads the WASM binary from the workspace and initializes it
+ * properly for the test environment. It uses require.resolve() to find the
+ * WASM file reliably regardless of the workspace structure.
+ *
+ * **Note:** This should be called once in beforeAll() for each test suite.
+ *
+ * @returns Promise that resolves when WASM is initialized
+ *
+ * @example
+ * ```typescript
+ * describe("buildPeginPsbt", () => {
+ *   beforeAll(async () => {
+ *     await initializeWasmForTests();
+ *   });
+ *   // ... tests
+ * });
+ * ```
+ */
+export declare function initializeWasmForTests(): Promise<void>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/tbv/core/primitives/psbt/__tests__/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/primitives/psbt/__tests__/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;;GAIG;AACH,eAAO,MAAM,SAAS;;IAGpB,wCAAwC;;IAIxC,qBAAqB;;IAIrB,qBAAqB;;IAIrB,6BAA6B;;IAI7B,6BAA6B;;CAGrB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB,qCAAqC;;IAGrC,qCAAqC;;IAGrC,wCAAwC;;IAGxC,2CAA2C;;IAG3C,sDAAsD;;IAGtD,sDAAsD;;IAGtD,sCAAsC;;IAGtC,+CAA+C;;CAEvC,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC,CAyB5D"}

package/dist/tbv/core/primitives/psbt/__tests__/payout.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for buildPayoutPsbt and extractPayoutSignature primitive functions
+ *
+ * These tests verify the PSBT building and signature extraction logic for payout
+ * transactions in the Babylon vault protocol.
+ */
+export {};
+//# sourceMappingURL=payout.test.d.ts.map

package/dist/tbv/core/primitives/psbt/__tests__/payout.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payout.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/primitives/psbt/__tests__/payout.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/tbv/core/primitives/psbt/__tests__/pegin.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for buildPeginPsbt primitive function
+ */
+export {};
+//# sourceMappingURL=pegin.test.d.ts.map

package/dist/tbv/core/primitives/psbt/__tests__/pegin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pegin.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/primitives/psbt/__tests__/pegin.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tbv/core/primitives/psbt/challengeAssert.d.ts

@@ -0,0 +1,27 @@
+import { ChallengeAssertConnectorParams } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+/**
+ * Parameters for building a ChallengeAssert PSBT
+ */
+export interface ChallengeAssertParams {
+    /** ChallengeAssert transaction hex (unsigned) from VP */
+    challengeAssertTxHex: string;
+    /** Prevouts for all inputs [{script_pubkey, value}] from VP (flat, one per input) */
+    prevouts: Array<{
+        script_pubkey: string;
+        value: number;
+    }>;
+    /** Per-input connector params (one per input/segment, determines the taproot script) */
+    connectorParamsPerInput: ChallengeAssertConnectorParams[];
+}
+/**
+ * Build unsigned ChallengeAssert PSBT.
+ *
+ * The ChallengeAssert transaction has 3 inputs (one per Assert output segment).
+ * Each input has its own taproot script derived from its connector params.
+ * The depositor signs all inputs.
+ *
+ * @param params - ChallengeAssert parameters
+ * @returns Unsigned PSBT hex ready for signing
+ */
+export declare function buildChallengeAssertPsbt(params: ChallengeAssertParams): Promise<string>;
+//# sourceMappingURL=challengeAssert.d.ts.map

package/dist/tbv/core/primitives/psbt/challengeAssert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"challengeAssert.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/challengeAssert.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,KAAK,8BAA8B,EAGpC,MAAM,uCAAuC,CAAC;AAS/C;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,yDAAyD;IACzD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qFAAqF;IACrF,QAAQ,EAAE,KAAK,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,wFAAwF;IACxF,uBAAuB,EAAE,8BAA8B,EAAE,CAAC;CAC3D;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,CAAC,CA4DjB"}

package/dist/tbv/core/primitives/psbt/depositorPayout.d.ts

@@ -0,0 +1,27 @@
+import { PayoutConnectorParams } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+/**
+ * Parameters for building a depositor Payout PSBT
+ */
+export interface DepositorPayoutParams {
+    /** Payout transaction hex (unsigned) from VP */
+    payoutTxHex: string;
+    /** Prevouts for all inputs [{script_pubkey, value}] from VP */
+    prevouts: Array<{
+        script_pubkey: string;
+        value: number;
+    }>;
+    /** Parameters for the PeginPayout connector (depositor, VP, VKs, UCs, timelock) */
+    connectorParams: PayoutConnectorParams;
+}
+/**
+ * Build unsigned depositor Payout PSBT.
+ *
+ * The depositor's payout transaction has 2 inputs:
+ * - Input 0: PegIn:0 (vault UTXO) — depositor signs using PeginPayoutConnector payout script
+ * - Input 1: Assert:0 — NOT signed by depositor
+ *
+ * @param params - Depositor payout parameters
+ * @returns Unsigned PSBT hex ready for signing
+ */
+export declare function buildDepositorPayoutPsbt(params: DepositorPayoutParams): Promise<string>;
+//# sourceMappingURL=depositorPayout.d.ts.map

package/dist/tbv/core/primitives/psbt/depositorPayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depositorPayout.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/depositorPayout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,uCAAuC,CAAC;AAa/C;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,QAAQ,EAAE,KAAK,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,mFAAmF;IACnF,eAAe,EAAE,qBAAqB,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,CAAC,CAwDjB"}

package/dist/tbv/core/primitives/psbt/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * PSBT Builder Primitives
+ *
+ * Pure functions for building unsigned PSBTs for vault operations.
+ * These functions wrap the WASM implementation with a clean TypeScript API.
+ *
+ * Exports:
+ * - {@link buildPeginPsbt} - Create unfunded peg-in transaction
+ * - {@link buildPayoutPsbt} - Create payout PSBT for signing
+ * - {@link extractPayoutSignature} - Extract Schnorr signature from signed PSBT
+ * - {@link buildDepositorPayoutPsbt} - Create depositor's own Payout PSBT (depositor-as-claimer path)
+ * - {@link buildNoPayoutPsbt} - Create NoPayout PSBT per challenger (depositor-as-claimer path)
+ * - {@link buildChallengeAssertPsbt} - Create ChallengeAssert PSBT per challenger (depositor-as-claimer path)
+ *
+ * @module primitives/psbt
+ */
+export { buildPeginPsbt } from './pegin';
+export type { PeginParams, PeginPsbtResult } from './pegin';
+export { buildPayoutPsbt, extractPayoutSignature } from './payout';
+export type { PayoutParams, PayoutPsbtResult } from './payout';
+export { buildDepositorPayoutPsbt } from './depositorPayout';
+export type { DepositorPayoutParams } from './depositorPayout';
+export { buildNoPayoutPsbt } from './noPayout';
+export type { NoPayoutParams } from './noPayout';
+export { buildChallengeAssertPsbt } from './challengeAssert';
+export type { ChallengeAssertParams } from './challengeAssert';
+//# sourceMappingURL=index.d.ts.map

package/dist/tbv/core/primitives/psbt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AACnE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/tbv/core/primitives/psbt/noPayout.d.ts

@@ -0,0 +1,28 @@
+import { AssertPayoutNoPayoutConnectorParams } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+/**
+ * Parameters for building a NoPayout PSBT
+ */
+export interface NoPayoutParams {
+    /** NoPayout transaction hex (unsigned) from VP */
+    noPayoutTxHex: string;
+    /** Challenger's x-only public key (hex encoded) */
+    challengerPubkey: string;
+    /** Prevouts for all inputs [{script_pubkey, value}] from VP */
+    prevouts: Array<{
+        script_pubkey: string;
+        value: number;
+    }>;
+    /** Parameters for the Assert Payout/NoPayout connector */
+    connectorParams: AssertPayoutNoPayoutConnectorParams;
+}
+/**
+ * Build unsigned NoPayout PSBT.
+ *
+ * The NoPayout transaction is specific to each challenger.
+ * Input 0 is the one the depositor signs using the NoPayout taproot script path.
+ *
+ * @param params - NoPayout parameters
+ * @returns Unsigned PSBT hex ready for signing
+ */
+export declare function buildNoPayoutPsbt(params: NoPayoutParams): Promise<string>;
+//# sourceMappingURL=noPayout.d.ts.map

package/dist/tbv/core/primitives/psbt/noPayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noPayout.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/noPayout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,KAAK,mCAAmC,EAGzC,MAAM,uCAAuC,CAAC;AAS/C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,gBAAgB,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,QAAQ,EAAE,KAAK,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,0DAA0D;IAC1D,eAAe,EAAE,mCAAmC,CAAC;CACtD;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,MAAM,CAAC,CA6DjB"}

package/dist/tbv/core/primitives/psbt/payout.d.ts

@@ -0,0 +1,99 @@
+import { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+/**
+ * Parameters for building an unsigned Payout PSBT
+ *
+ * Payout is used in the challenge path after Assert, when the claimer proves validity.
+ * Input 1 references the Assert transaction.
+ */
+export interface PayoutParams {
+    /**
+     * Payout transaction hex (unsigned)
+     * This is the transaction that needs to be signed by the depositor
+     */
+    payoutTxHex: string;
+    /**
+     * Assert transaction hex
+     * Payout input 1 references Assert output 0
+     */
+    assertTxHex: string;
+    /**
+     * Peg-in transaction hex
+     * This transaction created the vault output that we're spending
+     */
+    peginTxHex: string;
+    /**
+     * Depositor's BTC public key (x-only, 64-char hex without 0x prefix)
+     */
+    depositorBtcPubkey: string;
+    /**
+     * Vault provider's BTC public key (x-only, 64-char hex)
+     */
+    vaultProviderBtcPubkey: string;
+    /**
+     * Vault keeper BTC public keys (x-only, 64-char hex)
+     */
+    vaultKeeperBtcPubkeys: string[];
+    /**
+     * Universal challenger BTC public keys (x-only, 64-char hex)
+     */
+    universalChallengerBtcPubkeys: string[];
+    /**
+     * CSV timelock in blocks for the PegIn output.
+     */
+    timelockPegin: number;
+    /**
+     * Bitcoin network
+     */
+    network: Network;
+}
+/**
+ * Result of building an unsigned payout PSBT
+ */
+export interface PayoutPsbtResult {
+    /**
+     * Unsigned PSBT hex ready for signing
+     */
+    psbtHex: string;
+}
+/**
+ * Build unsigned Payout PSBT for depositor to sign.
+ *
+ * Payout is used in the **challenge path** when the claimer proves validity:
+ * 1. Vault provider submits Claim transaction
+ * 2. Challenge is raised during challenge period
+ * 3. Claimer submits Assert transaction to prove validity
+ * 4. Payout can be executed (references Assert tx)
+ *
+ * Payout transactions have the following structure:
+ * - Input 0: from PeginTx output0 (signed by depositor)
+ * - Input 1: from Assert output0 (NOT signed by depositor)
+ *
+ * @param params - Payout parameters
+ * @returns Unsigned PSBT ready for depositor to sign
+ *
+ * @throws If payout transaction does not have exactly 2 inputs
+ * @throws If input 0 does not reference the pegin transaction
+ * @throws If input 1 does not reference the assert transaction
+ * @throws If previous output is not found for either input
+ */
+export declare function buildPayoutPsbt(params: PayoutParams): Promise<PayoutPsbtResult>;
+/**
+ * Extract Schnorr signature from signed payout PSBT.
+ *
+ * This function supports two cases:
+ * 1. Non-finalized PSBT: Extracts from tapScriptSig field
+ * 2. Finalized PSBT: Extracts from witness data
+ *
+ * The signature is returned as a 64-byte hex string (128 hex characters)
+ * with any sighash flag byte removed if present.
+ *
+ * @param signedPsbtHex - Signed PSBT hex
+ * @param depositorPubkey - Depositor's public key (x-only, 64-char hex)
+ * @param inputIndex - Input index to extract signature from (default: 0)
+ * @returns 64-byte Schnorr signature (128 hex characters, no sighash flag)
+ *
+ * @throws If no signature is found in the PSBT
+ * @throws If the signature has an unexpected length
+ */
+export declare function extractPayoutSignature(signedPsbtHex: string, depositorPubkey: string, inputIndex?: number): string;
+//# sourceMappingURL=payout.d.ts.map

package/dist/tbv/core/primitives/psbt/payout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payout.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/payout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,KAAK,OAAO,EAEb,MAAM,uCAAuC,CAAC;AAc/C;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAE/B;;OAEG;IACH,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAEhC;;OAEG;IACH,6BAA6B,EAAE,MAAM,EAAE,CAAC;IAExC;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAqI3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,MAAM,EACvB,UAAU,SAAI,GACb,MAAM,CAsCR"}

package/dist/tbv/core/primitives/psbt/pegin.d.ts

@@ -0,0 +1,88 @@
+import { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+/**
+ * Parameters for building an unsigned peg-in PSBT
+ */
+export interface PeginParams {
+    /**
+     * Depositor's BTC public key (x-only, 64-char hex without 0x prefix)
+     */
+    depositorPubkey: string;
+    /**
+     * Vault provider's BTC public key (x-only, 64-char hex)
+     */
+    vaultProviderPubkey: string;
+    /**
+     * Array of vault keeper BTC public keys (x-only, 64-char hex)
+     */
+    vaultKeeperPubkeys: string[];
+    /**
+     * Array of universal challenger BTC public keys (x-only, 64-char hex)
+     */
+    universalChallengerPubkeys: string[];
+    /**
+     * CSV timelock in blocks for the PegIn output
+     */
+    timelockPegin: number;
+    /**
+     * Amount to peg in (in satoshis)
+     */
+    pegInAmount: bigint;
+    /**
+     * Amount in satoshis for the depositor's claim output
+     */
+    depositorClaimValue: bigint;
+    /**
+     * Bitcoin network
+     */
+    network: Network;
+}
+/**
+ * Result of building an unsigned peg-in PSBT
+ */
+export interface PeginPsbtResult {
+    /**
+     * Unsigned transaction hex
+     *
+     * Note: This is an unfunded transaction with no inputs and one output (the pegin output).
+     * The caller is responsible for:
+     * - Selecting UTXOs to fund the transaction
+     * - Calculating transaction fees
+     * - Adding inputs to cover pegInAmount + fees
+     * - Adding a change output if needed
+     * - Creating and signing the PSBT via wallet
+     */
+    psbtHex: string;
+    /**
+     * Transaction ID (will change after adding inputs and signing)
+     */
+    txid: string;
+    /**
+     * Vault script pubkey hex
+     */
+    vaultScriptPubKey: string;
+    /**
+     * Vault output value (in satoshis)
+     */
+    vaultValue: bigint;
+}
+/**
+ * Build unsigned peg-in PSBT using WASM.
+ *
+ * This is a pure function that wraps the Rust WASM implementation.
+ * It creates an unfunded Bitcoin transaction with no inputs and one output
+ * (the peg-in output to the vault address).
+ *
+ * The returned transaction must be funded by the caller by:
+ * 1. Selecting appropriate UTXOs from the wallet
+ * 2. Calculating transaction fees based on selected inputs
+ * 3. Adding inputs to cover pegInAmount + fees
+ * 4. Adding a change output if the input value exceeds pegInAmount + fees
+ * 5. Creating a PSBT and signing it via the wallet
+ *
+ * @param params - Peg-in parameters
+ * @returns Unsigned PSBT and transaction details
+ *
+ * @throws If WASM initialization fails or parameters are invalid
+ */
+export declare function buildPeginPsbt(params: PeginParams): Promise<PeginPsbtResult>;
+//# sourceMappingURL=pegin.d.ts.map

package/dist/tbv/core/primitives/psbt/pegin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pegin.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/pegin.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAEL,KAAK,OAAO,EACb,MAAM,uCAAuC,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAE7B;;OAEG;IACH,0BAA0B,EAAE,MAAM,EAAE,CAAC;IAErC;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;;OAUG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,eAAe,CAAC,CAmB1B"}

package/dist/tbv/core/primitives/scripts/__tests__/payout.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for createPayoutScript primitive function
+ */
+export {};
+//# sourceMappingURL=payout.test.d.ts.map

package/dist/tbv/core/primitives/scripts/__tests__/payout.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payout.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/primitives/scripts/__tests__/payout.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tbv/core/primitives/scripts/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Script Primitives
+ *
+ * Pure functions for generating Bitcoin scripts for vault operations.
+ *
+ * @module primitives/scripts
+ */
+export { createPayoutScript } from './payout';
+export type { PayoutScriptParams, PayoutScriptResult } from './payout';
+//# sourceMappingURL=index.d.ts.map

package/dist/tbv/core/primitives/scripts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/scripts/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC"}