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

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

@@ -0,0 +1,102 @@
+import { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+/**
+ * Parameters for creating a payout script.
+ *
+ * These parameters define the participants in a vault and are used to generate
+ * the taproot script that controls how funds can be spent from the vault.
+ */
+export interface PayoutScriptParams {
+    /**
+     * Depositor's BTC public key (x-only, 64-char hex without 0x prefix).
+     *
+     * This is the user depositing BTC into the vault. The depositor must sign
+     * payout transactions to authorize fund distribution.
+     */
+    depositor: string;
+    /**
+     * Vault provider's BTC public key (x-only, 64-char hex without 0x prefix).
+     *
+     * The service provider managing vault operations. Also referred to as
+     * "claimer" in the WASM layer.
+     */
+    vaultProvider: string;
+    /**
+     * Array of vault keeper BTC public keys (x-only, 64-char hex without 0x prefix).
+     *
+     * Vault keepers participate in vault operations and script spending conditions.
+     */
+    vaultKeepers: string[];
+    /**
+     * Array of universal challenger BTC public keys (x-only, 64-char hex without 0x prefix).
+     *
+     * These parties can challenge the vault under certain conditions.
+     */
+    universalChallengers: string[];
+    /**
+     * CSV timelock in blocks for the PegIn output.
+     */
+    timelockPegin: number;
+    /**
+     * Bitcoin network for script generation.
+     *
+     * Must match the network used for all other vault operations to ensure
+     * address encoding compatibility.
+     */
+    network: Network;
+}
+/**
+ * Result of creating a payout script.
+ *
+ * Contains all the taproot-related data needed for constructing and signing
+ * payout transactions from the vault.
+ */
+export interface PayoutScriptResult {
+    /**
+     * The payout script hex used in taproot script path spending.
+     *
+     * This is the raw script bytes that define the spending conditions,
+     * encoded as a hexadecimal string. Used when constructing the
+     * tapLeafScript for PSBT signing.
+     */
+    payoutScript: string;
+    /**
+     * The taproot script hash (leaf hash) for the payout script.
+     *
+     * This is the tagged hash of the script used in taproot tree construction.
+     * Required for computing the control block during script path spending.
+     */
+    taprootScriptHash: string;
+    /**
+     * The full scriptPubKey for the vault output address.
+     *
+     * This is the complete output script (OP_1 <32-byte-key>) that should be
+     * used when creating the vault output in a peg-in transaction.
+     */
+    scriptPubKey: string;
+    /**
+     * The vault Bitcoin address derived from the script.
+     *
+     * A human-readable bech32m address (bc1p... for mainnet, tb1p... for testnet/signet)
+     * that can be used to receive funds into the vault.
+     */
+    address: string;
+}
+/**
+ * Create payout script and taproot information using WASM.
+ *
+ * This is a pure function that wraps the Rust WASM implementation.
+ * The payout connector generates the necessary taproot scripts and information
+ * required for signing payout transactions.
+ *
+ * @remarks
+ * The generated script encodes spending conditions that require signatures from
+ * the depositor and vault provider (or liquidators in challenge scenarios).
+ * This script is used internally by {@link buildPayoutPsbt}.
+ *
+ * @param params - Payout script parameters defining vault participants and network
+ * @returns Payout script and taproot information for PSBT construction
+ *
+ * @see {@link buildPayoutPsbt} - Use this for building complete payout PSBTs
+ */
+export declare function createPayoutScript(params: PayoutScriptParams): Promise<PayoutScriptResult>;
+//# sourceMappingURL=payout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"payout.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/scripts/payout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAEL,KAAK,OAAO,EACb,MAAM,uCAAuC,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;OAKG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAE/B;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;OAKG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,kBAAkB,CAAC,CAmB7B"}

package/dist/tbv/core/primitives/utils/__tests__/bitcoin.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for Bitcoin utility functions
+ */
+export {};
+//# sourceMappingURL=bitcoin.test.d.ts.map

package/dist/tbv/core/primitives/utils/__tests__/bitcoin.test.d.ts.map

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

package/dist/tbv/core/primitives/utils/bitcoin.d.ts

@@ -0,0 +1,132 @@
+import { networks } from 'bitcoinjs-lib';
+import { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+/**
+ * Strip "0x" prefix from hex string if present.
+ *
+ * Bitcoin expects plain hex (no "0x" prefix), but frontend often uses
+ * Ethereum-style "0x"-prefixed hex.
+ *
+ * @param hex - Hex string with or without "0x" prefix
+ * @returns Hex string without "0x" prefix
+ */
+export declare function stripHexPrefix(hex: string): string;
+/**
+ * Convert hex string to Uint8Array.
+ *
+ * @param hex - Hex string (with or without 0x prefix)
+ * @returns Uint8Array
+ * @throws If hex is invalid
+ */
+export declare function hexToUint8Array(hex: string): Uint8Array;
+/**
+ * Convert Uint8Array to hex string (without 0x prefix).
+ *
+ * @param bytes - Uint8Array to convert
+ * @returns Hex string without 0x prefix
+ */
+export declare function uint8ArrayToHex(bytes: Uint8Array): string;
+/**
+ * Convert a 33-byte public key to 32-byte x-only format (removes first byte).
+ *
+ * Used for Taproot/Schnorr signatures which only need the x-coordinate.
+ * If the input is already 32 bytes, returns it unchanged.
+ *
+ * @param pubKey - 33-byte or 32-byte public key
+ * @returns 32-byte x-only public key
+ */
+export declare function toXOnly(pubKey: Uint8Array): Uint8Array;
+/**
+ * Process and convert a public key to x-only format (32 bytes hex).
+ *
+ * Handles:
+ * - 0x prefix removal
+ * - Hex character validation
+ * - Length validation
+ * - Conversion to x-only format
+ *
+ * Accepts:
+ * - 64 hex chars (32 bytes) - already x-only
+ * - 66 hex chars (33 bytes) - compressed pubkey
+ * - 130 hex chars (65 bytes) - uncompressed pubkey
+ *
+ * @param publicKeyHex - Public key in hex format (with or without 0x prefix)
+ * @returns X-only public key as 32 bytes hex string (without 0x prefix)
+ * @throws If public key format is invalid or contains invalid hex characters
+ */
+export declare function processPublicKeyToXOnly(publicKeyHex: string): string;
+/**
+ * Validate hex string format.
+ *
+ * Checks that the string contains only valid hexadecimal characters (0-9, a-f, A-F)
+ * and has an even length (since each byte is represented by 2 hex characters).
+ *
+ * @param hex - String to validate (with or without 0x prefix)
+ * @returns true if valid hex string
+ */
+export declare function isValidHex(hex: string): boolean;
+/**
+ * Result of validating a wallet public key against an expected depositor public key.
+ */
+export interface WalletPubkeyValidationResult {
+    /** Wallet's raw public key (as returned by wallet, may be compressed) */
+    walletPubkeyRaw: string;
+    /** Wallet's public key in x-only format (32 bytes, 64 hex chars) */
+    walletPubkeyXOnly: string;
+    /** The validated depositor public key (x-only format) */
+    depositorPubkey: string;
+}
+/**
+ * Validate that a wallet's public key matches the expected depositor public key.
+ *
+ * This function:
+ * 1. Converts the wallet pubkey to x-only format
+ * 2. Uses the expected depositor pubkey if provided, otherwise falls back to wallet pubkey
+ * 3. Validates they match (case-insensitive)
+ *
+ * @param walletPubkeyRaw - Raw public key from wallet (may be compressed 66 chars or x-only 64 chars)
+ * @param expectedDepositorPubkey - Expected depositor public key (x-only, optional)
+ * @returns Validation result with both pubkey formats
+ * @throws If wallet pubkey doesn't match expected depositor pubkey
+ */
+export declare function validateWalletPubkey(walletPubkeyRaw: string, expectedDepositorPubkey?: string): WalletPubkeyValidationResult;
+/**
+ * Map SDK network type to bitcoinjs-lib Network object.
+ *
+ * @param network - Network type ("bitcoin", "testnet", "signet", "regtest")
+ * @returns bitcoinjs-lib Network object
+ */
+export declare function getNetwork(network: Network): networks.Network;
+/**
+ * Derive a Taproot (P2TR) address from a public key.
+ *
+ * @param publicKeyHex - Compressed (66 hex) or x-only (64 hex) public key
+ * @param network - Bitcoin network
+ * @returns Taproot address (bc1p... / tb1p... / bcrt1p...)
+ */
+export declare function deriveTaprootAddress(publicKeyHex: string, network: Network): string;
+/**
+ * Derive a Native SegWit (P2WPKH) address from a compressed public key.
+ *
+ * @param publicKeyHex - Compressed public key (66 hex chars, with or without 0x prefix)
+ * @param network - Bitcoin network
+ * @returns Native SegWit address (bc1q... / tb1q... / bcrt1q...)
+ * @throws If publicKeyHex is not a compressed public key (66 hex chars)
+ */
+export declare function deriveNativeSegwitAddress(publicKeyHex: string, network: Network): string;
+/**
+ * Validate that a BTC address was derived from the given public key.
+ *
+ * Derives Taproot (P2TR) and Native SegWit (P2WPKH) addresses from the
+ * public key and checks if the provided address matches any of them.
+ *
+ * When the input is an x-only key (64 hex chars), both possible compressed
+ * keys (`02` + x and `03` + x) are tried for Native SegWit derivation,
+ * since the y-parity is unknown.
+ *
+ * @param address - BTC address to validate
+ * @param publicKeyHex - Public key from the wallet (x-only 64 or compressed 66 hex chars)
+ * @param network - Bitcoin network
+ * @returns true if the address matches the public key
+ */
+export declare function isAddressFromPublicKey(address: string, publicKeyHex: string, network: Network): boolean;
+//# sourceMappingURL=bitcoin.d.ts.map

package/dist/tbv/core/primitives/utils/bitcoin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/utils/bitcoin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,EAAc,QAAQ,EAAY,MAAM,eAAe,CAAC;AAE/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAErE;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAUvD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAEtD;AAaD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAuBpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAG/C;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,yEAAyE;IACzE,eAAe,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,MAAM,EACvB,uBAAuB,CAAC,EAAE,MAAM,GAC/B,4BAA4B,CAa9B;AAeD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAY7D;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,GACf,MAAM,CAWR;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,GACf,MAAM,CAiBR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,GACf,OAAO,CAgCT"}

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

@@ -0,0 +1,9 @@
+/**
+ * Utility Functions
+ *
+ * Pure utility functions for Bitcoin operations
+ *
+ * @module primitives/utils
+ */
+export { hexToUint8Array, isValidHex, processPublicKeyToXOnly, stripHexPrefix, toXOnly, uint8ArrayToHex, validateWalletPubkey, type WalletPubkeyValidationResult, } from './bitcoin';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,eAAe,EACf,UAAU,EACV,uBAAuB,EACvB,cAAc,EACd,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,KAAK,4BAA4B,GAClC,MAAM,WAAW,CAAC"}

package/dist/tbv/core/utils/btc/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bitcoin Utilities
+ *
+ * Utilities for Bitcoin script detection and PSBT construction.
+ *
+ * @module utils/btc
+ */
+export { BitcoinScriptType, getScriptType } from './scriptType';
+export { getPsbtInputFields, type PsbtInputFields, type UtxoForPsbt, } from './psbtInputFields';
+//# sourceMappingURL=index.d.ts.map

package/dist/tbv/core/utils/btc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/btc/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,EACL,kBAAkB,EAClB,KAAK,eAAe,EACpB,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC"}

package/dist/tbv/core/utils/btc/psbtInputFields.d.ts

@@ -0,0 +1,41 @@
+import { Buffer } from 'buffer';
+/**
+ * PSBT input fields for supported script types (P2TR, P2WPKH, P2WSH).
+ */
+export interface PsbtInputFields {
+    witnessUtxo?: {
+        script: Buffer;
+        value: number;
+    };
+    witnessScript?: Buffer;
+    tapInternalKey?: Buffer;
+}
+/**
+ * UTXO information for PSBT construction.
+ *
+ * Only supports Taproot (P2TR) and native SegWit (P2WPKH, P2WSH) script types.
+ */
+export interface UtxoForPsbt {
+    /** Transaction ID of the UTXO */
+    txid: string;
+    /** Output index (vout) of the UTXO */
+    vout: number;
+    /** Value of the UTXO in satoshis */
+    value: number;
+    /** ScriptPubKey of the UTXO (hex string) */
+    scriptPubKey: string;
+    /** Witness script (required for P2WSH) */
+    witnessScript?: string;
+}
+/**
+ * Get PSBT input fields for a given UTXO based on its script type.
+ *
+ * Only supports Taproot (P2TR) and native SegWit (P2WPKH, P2WSH) script types.
+ *
+ * @param utxo - The unspent transaction output to process
+ * @param publicKeyNoCoord - The x-only public key (32 bytes) for Taproot signing
+ * @returns PSBT input fields object containing the necessary data
+ * @throws Error if required input data is missing or unsupported script type
+ */
+export declare function getPsbtInputFields(utxo: UtxoForPsbt, publicKeyNoCoord?: Buffer): PsbtInputFields;
+//# sourceMappingURL=psbtInputFields.d.ts.map

package/dist/tbv/core/utils/btc/psbtInputFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psbtInputFields.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/btc/psbtInputFields.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,WAAW,CAAC,EAAE;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,YAAY,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,WAAW,EACjB,gBAAgB,CAAC,EAAE,MAAM,GACxB,eAAe,CA8CjB"}

package/dist/tbv/core/utils/btc/scriptType.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bitcoin Script Type Detection
+ *
+ * Utilities to detect Bitcoin script types for proper PSBT input construction.
+ *
+ * @module utils/btc/scriptType
+ */
+/**
+ * Bitcoin script types.
+ */
+export declare enum BitcoinScriptType {
+    P2PKH = "P2PKH",
+    P2SH = "P2SH",
+    P2WPKH = "P2WPKH",
+    P2WSH = "P2WSH",
+    P2TR = "P2TR",
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Detect the type of a Bitcoin script.
+ *
+ * @param scriptPubKey - The script public key buffer
+ * @returns The detected script type
+ *
+ * @example
+ * ```typescript
+ * const scriptType = getScriptType(Buffer.from(scriptPubKeyHex, 'hex'));
+ * if (scriptType === BitcoinScriptType.P2TR) {
+ *   // Handle Taproot input
+ * }
+ * ```
+ */
+export declare function getScriptType(scriptPubKey: Buffer): BitcoinScriptType;
+//# sourceMappingURL=scriptType.d.ts.map

package/dist/tbv/core/utils/btc/scriptType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scriptType.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/btc/scriptType.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,oBAAY,iBAAiB;IAC3B,KAAK,UAAU;IACf,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,iBAAiB,CAqDrE"}

package/dist/tbv/core/utils/fee/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Fee calculation constants for Bitcoin transactions.
+ * Based on btc-staking-ts values, adapted for vault peg-in transactions.
+ */
+export declare const P2TR_INPUT_SIZE = 58;
+export declare const MAX_NON_LEGACY_OUTPUT_SIZE = 43;
+export declare const TX_BUFFER_SIZE_OVERHEAD = 11;
+export declare const BTC_DUST_SAT = 546;
+/** Pre-computed BigInt dust threshold to avoid repeated conversions in hot paths */
+export declare const DUST_THRESHOLD: bigint;
+export declare const LOW_RATE_ESTIMATION_ACCURACY_BUFFER = 30;
+export declare const WALLET_RELAY_FEE_RATE_THRESHOLD = 2;
+export declare const FEE_SAFETY_MARGIN = 1.1;
+/**
+ * Adds a buffer to the transaction fee calculation if the fee rate is low.
+ *
+ * Some wallets have a relayer fee requirement. If the fee rate is <= 2 sat/vbyte,
+ * there's a risk the fee might not be sufficient for transaction relay.
+ * We add a buffer to ensure the transaction can be relayed.
+ *
+ * @param feeRate - Fee rate in satoshis per vbyte
+ * @returns Buffer amount in satoshis to add to the transaction fee
+ */
+export declare function rateBasedTxBufferFee(feeRate: number): number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/tbv/core/utils/fee/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/fee/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,eAAO,MAAM,eAAe,KAAK,CAAC;AAGlC,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAG7C,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAG1C,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC,oFAAoF;AACpF,eAAO,MAAM,cAAc,QAAuB,CAAC;AAGnD,eAAO,MAAM,mCAAmC,KAAK,CAAC;AAGtD,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAGjD,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAI5D"}

package/dist/tbv/core/utils/fee/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Fee calculation utilities and constants
+ *
+ * @module utils/fee
+ */
+export * from './constants';
+//# sourceMappingURL=index.d.ts.map

package/dist/tbv/core/utils/fee/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/fee/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,aAAa,CAAC"}

package/dist/tbv/core/utils/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * SDK Level 2 Utilities
+ *
+ * Transaction building utilities including:
+ * - Fee calculation constants
+ * - UTXO selection
+ * - Transaction funding
+ * - Bitcoin script utilities
+ *
+ * @module utils
+ */
+export * from './fee';
+export * from './utxo';
+export * from './transaction';
+export * from './btc';
+//# sourceMappingURL=index.d.ts.map

package/dist/tbv/core/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,OAAO,CAAC"}

package/dist/tbv/core/utils/transaction/__tests__/btcTxHash.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for calculateBtcTxHash
+ */
+export {};
+//# sourceMappingURL=btcTxHash.test.d.ts.map

package/dist/tbv/core/utils/transaction/__tests__/btcTxHash.test.d.ts.map

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

package/dist/tbv/core/utils/transaction/__tests__/createSplitTransaction.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for UTXO split transaction builder
+ */
+export {};
+//# sourceMappingURL=createSplitTransaction.test.d.ts.map

package/dist/tbv/core/utils/transaction/__tests__/createSplitTransaction.test.d.ts.map

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

package/dist/tbv/core/utils/transaction/__tests__/fundPeginTransaction.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for transaction funding utilities
+ */
+export {};
+//# sourceMappingURL=fundPeginTransaction.test.d.ts.map

package/dist/tbv/core/utils/transaction/__tests__/fundPeginTransaction.test.d.ts.map

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

package/dist/tbv/core/utils/transaction/btcTxHash.d.ts

@@ -0,0 +1,15 @@
+import { Hex } from 'viem';
+/**
+ * Calculate Bitcoin transaction hash
+ *
+ * This matches the contract's BtcUtils.hashBtcTx() implementation:
+ * 1. Double SHA256 the transaction bytes
+ * 2. Reverse the byte order (Bitcoin convention)
+ *
+ * The resulting hash is used as the unique vault identifier in the BTCVaultsManager contract.
+ *
+ * @param txHex - Transaction hex (with or without 0x prefix)
+ * @returns The transaction hash as Hex (with 0x prefix)
+ */
+export declare function calculateBtcTxHash(txHex: string): Hex;
+//# sourceMappingURL=btcTxHash.d.ts.map

package/dist/tbv/core/utils/transaction/btcTxHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"btcTxHash.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/transaction/btcTxHash.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAUrD"}

package/dist/tbv/core/utils/transaction/createSplitTransaction.d.ts

@@ -0,0 +1,106 @@
+import { Buffer } from 'buffer';
+import { Network } from '../../primitives';
+import { UTXO } from '../utxo/selectUtxos';
+/**
+ * Output specification for split transaction.
+ */
+export interface SplitOutput {
+    /** Amount in satoshis */
+    amount: bigint;
+    /** Bitcoin address to send to */
+    address: string;
+}
+/**
+ * Result of creating a split transaction.
+ */
+export interface SplitTransactionResult {
+    /** Unsigned transaction hex */
+    txHex: string;
+    /** Transaction ID (deterministic, calculated before signing) */
+    txid: string;
+    /** Output UTXOs that will be created when transaction is broadcast */
+    outputs: Array<{
+        /** Transaction ID of this output */
+        txid: string;
+        /** Output index */
+        vout: number;
+        /** Amount in satoshis */
+        value: number;
+        /** Script pubkey hex */
+        scriptPubKey: string;
+    }>;
+}
+/**
+ * Create a UTXO split transaction.
+ *
+ * This function creates a Bitcoin transaction that takes input UTXOs
+ * and splits them into multiple outputs with specified amounts.
+ *
+ * The transaction is returned unsigned. The caller must:
+ * 1. Sign the transaction using a Bitcoin wallet
+ * 2. Broadcast it to the Bitcoin network
+ * 3. Use the output UTXOs for subsequent peg-in transactions
+ *
+ * @param inputs - Input UTXOs to split
+ * @param outputs - Desired output amounts and addresses
+ * @param network - Bitcoin network (mainnet, testnet, signet, regtest)
+ * @returns Unsigned transaction hex, txid, and output UTXO references
+ * @throws Error if inputs or outputs are empty
+ * @throws Error if address decoding fails (invalid address for network)
+ *
+ * @example
+ * ```typescript
+ * const result = createSplitTransaction(
+ *   [{ txid: "abc...", vout: 0, value: 100000, scriptPubKey: "..." }],
+ *   [
+ *     { amount: 50000n, address: "tb1p..." },
+ *     { amount: 45000n, address: "tb1p..." }
+ *   ],
+ *   "testnet"
+ * );
+ * // result.txHex → unsigned transaction
+ * // result.txid → deterministic transaction ID
+ * // result.outputs → UTXO references for pegin creation
+ * ```
+ */
+export declare function createSplitTransaction(inputs: UTXO[], outputs: SplitOutput[], network: Network): SplitTransactionResult;
+/**
+ * Create a PSBT for signing a split transaction with Taproot inputs.
+ *
+ * IMPORTANT: This function assumes ALL inputs are P2TR (Taproot) addresses.
+ * It unconditionally adds tapInternalKey for Taproot signing. Using non-P2TR
+ * inputs will cause wallet signing failures.
+ *
+ * This function takes an unsigned split transaction and creates a PSBT
+ * that is intended to be signed by a Bitcoin wallet; this function does not
+ * perform any signing itself.
+ *
+ * The PSBT includes:
+ * - witnessUtxo: Script and value for each input (required for segwit)
+ * - tapInternalKey: Depositor's x-only pubkey (required for P2TR signing)
+ *
+ * Technical Note:
+ * For P2TR (Taproot) inputs, we need the witnessUtxo and tapInternalKey.
+ * This is different from legacy inputs which would need the full previous transaction.
+ *
+ * @param unsignedTxHex - Unsigned transaction hex from createSplitTransaction
+ * @param inputs - Input UTXOs with full data for PSBT
+ * @param publicKeyNoCoord - Depositor's public key (x-only, 32 bytes) for P2TR signing
+ * @returns PSBT hex ready for wallet signing
+ * @throws Error if publicKeyNoCoord is not a 32-byte Buffer
+ * @throws Error if UTXO count doesn't match transaction inputs
+ * @throws Error if any input is not P2TR format
+ *
+ * @example
+ * ```typescript
+ * const psbtHex = createSplitTransactionPsbt(
+ *   result.txHex,
+ *   inputUtxos,
+ *   Buffer.from(depositorPubkeyXOnly, "hex")
+ * );
+ * // Sign via wallet
+ * const signedPsbtHex = await wallet.signPsbt(psbtHex);
+ * ```
+ */
+export declare function createSplitTransactionPsbt(unsignedTxHex: string, inputs: UTXO[], publicKeyNoCoord: Buffer): string;
+//# sourceMappingURL=createSplitTransaction.d.ts.map

package/dist/tbv/core/utils/transaction/createSplitTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSplitTransaction.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/transaction/createSplitTransaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAIhD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,yBAAyB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,OAAO,EAAE,KAAK,CAAC;QACb,oCAAoC;QACpC,IAAI,EAAE,MAAM,CAAC;QACb,mBAAmB;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,yBAAyB;QACzB,KAAK,EAAE,MAAM,CAAC;QACd,wBAAwB;QACxB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;CACJ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,IAAI,EAAE,EACd,OAAO,EAAE,WAAW,EAAE,EACtB,OAAO,EAAE,OAAO,GACf,sBAAsB,CA8ExB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,IAAI,EAAE,EACd,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAyFR"}