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

package/dist/tbv/core/managers/PeginManager.d.ts

@@ -0,0 +1,327 @@
+import { Address, Chain, Hex, WalletClient } from 'viem';
+import { BitcoinWallet } from '../../../shared/wallets/interfaces/BitcoinWallet';
+import { Hash } from '../../../shared/wallets/interfaces/EthereumWallet';
+import { Network } from '../primitives';
+import { UTXO } from '../utils';
+/**
+ * Configuration for the PeginManager.
+ */
+export interface PeginManagerConfig {
+    /**
+     * Bitcoin network to use for transactions.
+     */
+    btcNetwork: Network;
+    /**
+     * Bitcoin wallet for signing peg-in transactions.
+     */
+    btcWallet: BitcoinWallet;
+    /**
+     * Ethereum wallet for registering peg-in on-chain.
+     * Uses viem's WalletClient directly for proper gas estimation.
+     */
+    ethWallet: WalletClient;
+    /**
+     * Ethereum chain configuration.
+     * Required for proper gas estimation in contract calls.
+     */
+    ethChain: Chain;
+    /**
+     * Vault contract addresses.
+     */
+    vaultContracts: {
+        /**
+         * BTCVaultsManager contract address on Ethereum.
+         */
+        btcVaultsManager: Address;
+    };
+    /**
+     * Mempool API URL for fetching UTXO data and broadcasting transactions.
+     * Use MEMPOOL_API_URLS constant for standard mempool.space URLs, or provide
+     * a custom URL if running your own mempool instance.
+     */
+    mempoolApiUrl: string;
+}
+/**
+ * Parameters for creating a peg-in transaction.
+ */
+export interface CreatePeginParams {
+    /**
+     * Amount to peg in (in satoshis).
+     */
+    amount: bigint;
+    /**
+     * Vault provider's Ethereum address.
+     */
+    vaultProvider: Address;
+    /**
+     * Vault provider's BTC public key (x-only, 64-char hex).
+     * Can be provided with or without "0x" prefix (will be stripped automatically).
+     */
+    vaultProviderBtcPubkey: string;
+    /**
+     * Vault keeper BTC public keys (x-only, 64-char hex).
+     * Can be provided with or without "0x" prefix (will be stripped automatically).
+     */
+    vaultKeeperBtcPubkeys: string[];
+    /**
+     * Universal challenger BTC public keys (x-only, 64-char hex).
+     * Can be provided with or without "0x" prefix (will be stripped automatically).
+     */
+    universalChallengerBtcPubkeys: string[];
+    /**
+     * CSV timelock in blocks for the PegIn output.
+     */
+    timelockPegin: number;
+    /**
+     * Amount in satoshis for the depositor's claim output.
+     */
+    depositorClaimValue: bigint;
+    /**
+     * Available UTXOs from the depositor's wallet for funding the transaction.
+     */
+    availableUTXOs: UTXO[];
+    /**
+     * Fee rate in satoshis per vbyte for the transaction.
+     */
+    feeRate: number;
+    /**
+     * Bitcoin address for receiving change from the transaction.
+     */
+    changeAddress: string;
+}
+/**
+ * Result of a peg-in preparation.
+ */
+export interface PeginResult {
+    /**
+     * Bitcoin transaction hash (without 0x prefix).
+     * This is the hash of the unsigned transaction and will NOT change after signing.
+     * Used as the unique vault identifier in the contract.
+     */
+    btcTxHash: string;
+    /**
+     * Funded but unsigned transaction hex.
+     * This transaction has inputs and outputs but is not yet signed.
+     */
+    fundedTxHex: string;
+    /**
+     * Vault script pubkey hex.
+     */
+    vaultScriptPubKey: string;
+    /**
+     * UTXOs selected for funding the transaction.
+     */
+    selectedUTXOs: UTXO[];
+    /**
+     * Transaction fee in satoshis.
+     */
+    fee: bigint;
+    /**
+     * Change amount in satoshis (if any).
+     */
+    changeAmount: bigint;
+    /**
+     * Ethereum transaction hash (peg-in registration).
+     * Will be null until registerPeginOnChain is called.
+     */
+    ethTxHash: Hash | null;
+}
+/**
+ * Parameters for signing and broadcasting a transaction.
+ */
+export interface SignAndBroadcastParams {
+    /**
+     * Funded transaction hex from preparePegin().
+     */
+    fundedTxHex: string;
+    /**
+     * Depositor's BTC public key (x-only, 64-char hex).
+     * Can be provided with or without "0x" prefix.
+     * Required for Taproot signing.
+     */
+    depositorBtcPubkey: string;
+}
+/**
+ * Parameters for registering a peg-in on Ethereum.
+ */
+export interface RegisterPeginParams {
+    /**
+     * Depositor's BTC public key (x-only, 64-char hex).
+     * Can be provided with or without "0x" prefix.
+     */
+    depositorBtcPubkey: string;
+    /**
+     * Funded but unsigned BTC transaction hex.
+     */
+    unsignedBtcTx: string;
+    /**
+     * Vault provider's Ethereum address.
+     */
+    vaultProvider: Address;
+    /**
+     * Optional callback invoked after PoP signing completes but before ETH transaction.
+     */
+    onPopSigned?: () => void | Promise<void>;
+    /**
+     * Depositor's BTC payout address (e.g. bc1p..., bc1q...).
+     * Converted to scriptPubKey internally via bitcoinjs-lib.
+     *
+     * If omitted, defaults to the connected BTC wallet's address
+     * via `btcWallet.getAddress()`.
+     */
+    depositorPayoutBtcAddress?: string;
+    /** Keccak256 hash of the depositor's Lamport public key (bytes32) */
+    depositorLamportPkHash: Hex;
+    /**
+     * Pre-signed BTC PoP signature (hex with 0x prefix).
+     * When provided, the BTC wallet signing step is skipped and this signature is used directly.
+     * Useful for multi-vault deposits where PoP only needs to be signed once.
+     */
+    preSignedBtcPopSignature?: Hex;
+}
+/**
+ * Result of registering a peg-in on Ethereum.
+ */
+export interface RegisterPeginResult {
+    /**
+     * Ethereum transaction hash for the peg-in registration.
+     */
+    ethTxHash: Hash;
+    /**
+     * Vault identifier used in the BTCVaultsManager contract.
+     * This is the Bitcoin transaction hash with 0x prefix for Ethereum compatibility.
+     * Corresponds to btcTxHash from PeginResult, but formatted as Hex with '0x' prefix.
+     */
+    vaultId: Hex;
+    /**
+     * The BTC PoP signature used for this registration (hex with 0x prefix).
+     * Returned so callers can reuse it for subsequent pegins without re-signing.
+     */
+    btcPopSignature: Hex;
+}
+/**
+ * Manager for orchestrating peg-in operations.
+ *
+ * This manager provides a high-level API for creating peg-in transactions
+ * by coordinating between SDK primitives, utilities, and wallet interfaces.
+ *
+ * @remarks
+ * The complete peg-in flow consists of 4 steps:
+ *
+ * | Step | Method | Description |
+ * |------|--------|-------------|
+ * | 1 | {@link preparePegin} | Build and fund the transaction |
+ * | 2 | {@link registerPeginOnChain} | Submit to Ethereum contract with PoP |
+ * | 3 | {@link PayoutManager} | Sign BOTH payout authorizations |
+ * | 4 | {@link signAndBroadcast} | Sign and broadcast to Bitcoin network |
+ *
+ * **Important:** Step 3 uses {@link PayoutManager}, not this class. After step 2,
+ * the vault provider prepares 3 transactions per claimer:
+ * - `claim_tx` - Claim transaction
+ * - `assert_tx` - Assert transaction
+ * - `payout_tx` - Payout transaction
+ *
+ * You must sign the Payout transaction for each claimer:
+ * - {@link PayoutManager.signPayoutTransaction} - uses assert_tx as input reference
+ *
+ * Submit all signatures to the vault provider before proceeding to step 4.
+ *
+ * @see {@link PayoutManager} - Required for Step 3 (payout authorization)
+ * @see {@link buildPeginPsbt} - Lower-level primitive for custom implementations
+ * @see {@link https://github.com/babylonlabs-io/babylon-toolkit/blob/main/packages/babylon-ts-sdk/docs/quickstart/managers.md | Managers Quickstart}
+ */
+export declare class PeginManager {
+    private readonly config;
+    /**
+     * Creates a new PeginManager instance.
+     *
+     * @param config - Manager configuration including wallets and contract addresses
+     */
+    constructor(config: PeginManagerConfig);
+    /**
+     * Prepares a peg-in transaction by building and funding it.
+     *
+     * This method orchestrates the following steps:
+     * 1. Get depositor BTC public key from wallet
+     * 2. Build unfunded PSBT using primitives
+     * 3. Select UTXOs using iterative fee calculation
+     * 4. Fund transaction by adding inputs and change output
+     *
+     * The returned transaction is funded but unsigned. Use `signAndBroadcast()`
+     * to complete the Bitcoin side, and `registerPeginOnChain()` for Ethereum.
+     *
+     * @param params - Peg-in parameters including amount, provider, UTXOs, and fee rate
+     * @returns Peg-in result with funded transaction and selection details
+     * @throws Error if wallet operations fail or insufficient funds
+     */
+    preparePegin(params: CreatePeginParams): Promise<PeginResult>;
+    /**
+     * Signs and broadcasts a funded peg-in transaction to the Bitcoin network.
+     *
+     * This method:
+     * 1. Parses the funded transaction hex
+     * 2. Fetches UTXO data from mempool for each input
+     * 3. Creates a PSBT with proper witnessUtxo/tapInternalKey
+     * 4. Signs via btcWallet.signPsbt()
+     * 5. Finalizes and extracts the transaction
+     * 6. Broadcasts via mempool API
+     *
+     * @param params - Transaction hex and depositor public key
+     * @returns The broadcasted Bitcoin transaction ID
+     * @throws Error if signing or broadcasting fails
+     */
+    signAndBroadcast(params: SignAndBroadcastParams): Promise<string>;
+    /**
+     * Registers a peg-in on Ethereum by calling the BTCVaultsManager contract.
+     *
+     * This method:
+     * 1. Gets depositor ETH address from wallet
+     * 2. Creates proof of possession (BTC signature of ETH address)
+     * 3. Checks if vault already exists (pre-flight check)
+     * 4. Encodes the contract call using viem
+     * 5. Estimates gas (catches contract errors early with proper revert reasons)
+     * 6. Sends transaction with pre-estimated gas via ethWallet.sendTransaction()
+     *
+     * @param params - Registration parameters including BTC pubkey and unsigned tx
+     * @returns Result containing Ethereum transaction hash and vault ID
+     * @throws Error if signing or transaction fails
+     * @throws Error if vault already exists
+     * @throws Error if contract simulation fails (e.g., invalid signature, unauthorized)
+     */
+    registerPeginOnChain(params: RegisterPeginParams): Promise<RegisterPeginResult>;
+    /**
+     * Check if a vault already exists for a given vault ID.
+     *
+     * @param vaultId - The Bitcoin transaction hash (vault ID)
+     * @returns True if vault exists, false otherwise
+     */
+    private checkVaultExists;
+    /**
+     * Resolve the BTC payout address to a scriptPubKey hex for the contract.
+     *
+     * If a payout address is provided, converts it directly.
+     * If omitted, uses the wallet's address and validates it against the
+     * wallet's public key to guard against a compromised wallet provider.
+     */
+    private resolvePayoutScriptPubKey;
+    /**
+     * Resolve or create a BTC Proof-of-Possession signature.
+     *
+     * Reuses a pre-signed signature when provided (e.g. multi-vault deposits),
+     * otherwise signs a BIP-322 message with the BTC wallet.
+     */
+    private resolvePopSignature;
+    /**
+     * Gets the configured Bitcoin network.
+     *
+     * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
+     */
+    getNetwork(): Network;
+    /**
+     * Gets the configured BTCVaultsManager contract address.
+     *
+     * @returns The Ethereum address of the BTCVaultsManager contract
+     */
+    getVaultContractAddress(): Address;
+}
+//# sourceMappingURL=PeginManager.d.ts.map

package/dist/tbv/core/managers/PeginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PeginManager.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/managers/PeginManager.ts"],"names":[],"mappings":"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"}

package/dist/tbv/core/managers/__tests__/PayoutManager.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for PayoutManager
+ *
+ * Tests the manager's ability to orchestrate payout signing operations
+ * using primitives and mock wallets.
+ */
+export {};
+//# sourceMappingURL=PayoutManager.test.d.ts.map

package/dist/tbv/core/managers/__tests__/PayoutManager.test.d.ts.map

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

package/dist/tbv/core/managers/__tests__/PeginManager.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for PeginManager
+ *
+ * Tests the manager's ability to orchestrate peg-in operations
+ * using primitives, utilities, and mock wallets.
+ */
+export {};
+//# sourceMappingURL=PeginManager.test.d.ts.map

package/dist/tbv/core/managers/__tests__/PeginManager.test.d.ts.map

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

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

@@ -0,0 +1,75 @@
+/**
+ * @packageDocumentation
+ *
+ * # Manager Layer - Wallet Orchestration (Level 2)
+ *
+ * High-level managers that orchestrate complex flows using primitives and utilities.
+ * These managers accept wallet interfaces and handle the complete operation lifecycle.
+ *
+ * ## Architecture
+ *
+ * Managers sit between your application and the primitives layer:
+ *
+ * ```
+ * Your Application
+ *       ↓
+ * Managers (Level 2)    ← This module
+ *       ↓
+ * Primitives (Level 1)  ← Pure functions
+ *       ↓
+ * WASM (Rust Core)      ← Cryptographic operations
+ * ```
+ *
+ * ## When to Use Managers
+ *
+ * Use managers when you have:
+ * - **Frontend apps** with browser wallet integration (UniSat, OKX, etc.)
+ * - **Quick integration** needs with minimal code
+ * - **Standard flows** that don't require custom signing logic
+ *
+ * Use primitives instead when you need:
+ * - Backend services with KMS/HSM signing
+ * - Full control over every operation
+ * - Custom wallet integrations
+ *
+ * ## Available Managers
+ *
+ * ### {@link PeginManager}
+ * Orchestrates the peg-in deposit flow:
+ * - {@link PeginManager.preparePegin | preparePegin()} - Build and fund transaction
+ * - {@link PeginManager.registerPeginOnChain | registerPeginOnChain()} - Submit to Ethereum
+ * - {@link PeginManager.signAndBroadcast | signAndBroadcast()} - Broadcast to Bitcoin
+ *
+ * ### {@link PayoutManager}
+ * Signs payout authorization transactions (Step 3 of peg-in).
+ * - {@link PayoutManager.signPayoutTransaction | signPayoutTransaction()} - Sign payout (uses Assert tx as reference)
+ *
+ * ## Complete Peg-in Flow
+ *
+ * The 4-step peg-in flow uses both managers:
+ *
+ * | Step | Manager | Method |
+ * |------|---------|--------|
+ * | 1 | PeginManager | `preparePegin()` |
+ * | 2 | PeginManager | `registerPeginOnChain()` |
+ * | 3 | PayoutManager | `signPayoutTransaction()` |
+ * | 4 | PeginManager | `signAndBroadcast()` |
+ *
+ * **Step 3 Details:** The vault provider provides 3 transactions per claimer:
+ * - `claim_tx` - Claim transaction
+ * - `assert_tx` - Assert transaction
+ * - `payout_tx` - Payout transaction
+ *
+ * You must sign the Payout transaction (uses assert_tx as input reference) for each claimer.
+ *
+ * @see {@link https://github.com/babylonlabs-io/babylon-toolkit/blob/main/packages/babylon-ts-sdk/docs/quickstart/managers.md | Managers Quickstart}
+ *
+ * @module managers
+ */
+export { PeginManager } from './PeginManager';
+export type { CreatePeginParams, PeginManagerConfig, PeginResult, RegisterPeginParams, RegisterPeginResult, SignAndBroadcastParams, } from './PeginManager';
+export { PayoutManager } from './PayoutManager';
+export type { PayoutManagerConfig, PayoutSignatureResult, SignPayoutParams, } from './PayoutManager';
+export type { UTXO } from '../utils/utxo/selectUtxos';
+export type { BitcoinNetwork, BitcoinWallet, SignInputOptions, SignPsbtOptions, } from '../../../shared/wallets/interfaces/BitcoinWallet';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/managers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,mBAAmB,EACnB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EACV,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AACtD,YAAY,EACV,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,eAAe,GAChB,MAAM,kDAAkD,CAAC"}

package/dist/tbv/core/primitives/index.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../../challengeAssert-34HqeVFH.cjs");exports.buildChallengeAssertPsbt=e.buildChallengeAssertPsbt;exports.buildDepositorPayoutPsbt=e.buildDepositorPayoutPsbt;exports.buildNoPayoutPsbt=e.buildNoPayoutPsbt;exports.buildPayoutPsbt=e.buildPayoutPsbt;exports.buildPeginPsbt=e.buildPeginPsbt;exports.createPayoutScript=e.createPayoutScript;exports.deriveNativeSegwitAddress=e.deriveNativeSegwitAddress;exports.deriveTaprootAddress=e.deriveTaprootAddress;exports.extractPayoutSignature=e.extractPayoutSignature;exports.hexToUint8Array=e.hexToUint8Array;exports.isAddressFromPublicKey=e.isAddressFromPublicKey;exports.isValidHex=e.isValidHex;exports.processPublicKeyToXOnly=e.processPublicKeyToXOnly;exports.stripHexPrefix=e.stripHexPrefix;exports.toXOnly=e.toXOnly;exports.uint8ArrayToHex=e.uint8ArrayToHex;exports.validateWalletPubkey=e.validateWalletPubkey;
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1,77 @@
+/**
+ * @packageDocumentation
+ *
+ * # Vault Primitives
+ *
+ * Pure functions for vault operations with no wallet dependencies.
+ * These functions wrap the WASM implementation and provide:
+ *
+ * - **PSBT Building** - Create unsigned PSBTs for peg-in and payout transactions
+ * - **Script Creation** - Generate taproot scripts for vault spending conditions
+ * - **Signature Extraction** - Extract Schnorr signatures from signed PSBTs
+ * - **Bitcoin Utilities** - Public key conversion, hex manipulation, validation
+ *
+ * ## Architecture
+ *
+ * Primitives are the lowest level of the SDK, sitting directly above the Rust WASM core:
+ *
+ * ```
+ * Your Application
+ *       ↓
+ * Managers (Level 2)      ← High-level orchestration with wallet integration
+ *       ↓
+ * Primitives (Level 1)    ← Pure functions (this module)
+ *       ↓
+ * WASM (Rust Core)        ← Cryptographic operations
+ * ```
+ *
+ * ## When to Use Primitives
+ *
+ * Use primitives when you need:
+ * - **Full control** over every operation
+ * - **Custom wallet integrations** (KMS/HSM, hardware wallets)
+ * - **Backend services** with custom signing flows
+ * - **Serverless environments** with specific requirements
+ *
+ * For frontend apps with browser wallet integration, consider using
+ * the managers module instead (PeginManager and PayoutManager).
+ *
+ * ## Key Exports
+ *
+ * ### PSBT Builders
+ * - {@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)
+ *
+ * ### Script Generators
+ * - {@link createPayoutScript} - Generate taproot payout script
+ *
+ * ### Bitcoin Utilities
+ * - {@link processPublicKeyToXOnly} - Convert any pubkey format to x-only
+ * - {@link validateWalletPubkey} - Validate wallet matches expected depositor
+ * - {@link hexToUint8Array} / {@link uint8ArrayToHex} - Hex conversion
+ * - {@link stripHexPrefix} / {@link isValidHex} - Hex validation
+ * - {@link toXOnly} - Convert compressed pubkey bytes to x-only
+ *
+ * @see {@link https://github.com/babylonlabs-io/babylon-toolkit/blob/main/packages/babylon-ts-sdk/docs/quickstart/primitives.md | Primitives Quickstart}
+ *
+ * @module primitives
+ */
+export type { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+export { buildPeginPsbt } from './psbt/pegin';
+export type { PeginParams, PeginPsbtResult } from './psbt/pegin';
+export { buildPayoutPsbt, extractPayoutSignature } from './psbt/payout';
+export type { PayoutParams, PayoutPsbtResult } from './psbt/payout';
+export { buildDepositorPayoutPsbt } from './psbt/depositorPayout';
+export type { DepositorPayoutParams } from './psbt/depositorPayout';
+export { buildNoPayoutPsbt } from './psbt/noPayout';
+export type { NoPayoutParams } from './psbt/noPayout';
+export { buildChallengeAssertPsbt } from './psbt/challengeAssert';
+export type { ChallengeAssertParams } from './psbt/challengeAssert';
+export { createPayoutScript } from './scripts/payout';
+export type { PayoutScriptParams, PayoutScriptResult } from './scripts/payout';
+export { deriveNativeSegwitAddress, deriveTaprootAddress, hexToUint8Array, isAddressFromPublicKey, isValidHex, processPublicKeyToXOnly, stripHexPrefix, toXOnly, uint8ArrayToHex, validateWalletPubkey, type WalletPubkeyValidationResult, } from './utils/bitcoin';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/primitives/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAGH,YAAY,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAGrE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEjE,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACxE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,YAAY,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAEpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,YAAY,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAGpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG/E,OAAO,EACL,yBAAyB,EACzB,oBAAoB,EACpB,eAAe,EACf,sBAAsB,EACtB,UAAU,EACV,uBAAuB,EACvB,cAAc,EACd,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,KAAK,4BAA4B,GAClC,MAAM,iBAAiB,CAAC"}

package/dist/tbv/core/primitives/index.js

@@ -0,0 +1,21 @@
+import { f as e, c as t, d as i, a as r, b as o, g as d, h as l, i as u, e as P, j as b, k as y, l as c, p as n, s as p, t as x, u as A, v as g } from "../../../challengeAssert-DVErOd8l.js";
+export {
+  e as buildChallengeAssertPsbt,
+  t as buildDepositorPayoutPsbt,
+  i as buildNoPayoutPsbt,
+  r as buildPayoutPsbt,
+  o as buildPeginPsbt,
+  d as createPayoutScript,
+  l as deriveNativeSegwitAddress,
+  u as deriveTaprootAddress,
+  P as extractPayoutSignature,
+  b as hexToUint8Array,
+  y as isAddressFromPublicKey,
+  c as isValidHex,
+  n as processPublicKeyToXOnly,
+  p as stripHexPrefix,
+  x as toXOnly,
+  A as uint8ArrayToHex,
+  g as validateWalletPubkey
+};
+//# sourceMappingURL=index.js.map

package/dist/tbv/{integrations/morpho → core/primitives}/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}