@babylonlabs-io/ts-sdk 0.70.1 → 0.71.1

package/dist/tbv/core/utils/utxo/reservation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reservation.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/utxo/reservation.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,iEAAiE;AACjE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,2CAA2C;AAC3C,MAAM,WAAW,SAAS;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,kCAAkC;IACjD,iBAAiB,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;CACjD;AAkBD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,kCAAkC,GACzC,MAAM,EAAE,CAkCV"}
+{"version":3,"file":"reservation.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/utils/utxo/reservation.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,iEAAiE;AACjE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,2CAA2C;AAC3C,MAAM,WAAW,SAAS;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,kCAAkC;IACjD,iBAAiB,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;CACjD;AAkBD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,kCAAkC,GACzC,MAAM,EAAE,CAkCV"}

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

@@ -8,6 +8,10 @@
 export declare const HEX_RE: RegExp;
 /** Bitcoin txid: exactly 64 hex characters (32 bytes). */
 export declare const TXID_RE: RegExp;
+/** Hex-string length of a 32-byte BIP-340 x-only public key. */
+export declare const X_ONLY_PUBKEY_HEX_LEN = 64;
+/** Hex-string length of a 33-byte SEC1-compressed secp256k1 public key. */
+export declare const COMPRESSED_PUBKEY_HEX_LEN = 66;
 /**
  * Bitcoin address format gate: 25–90 alphanumeric characters.
  * Covers legacy (P2PKH/P2SH), bech32 (P2WPKH/P2WSH), bech32m (P2TR),

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

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/utils/validation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qEAAqE;AACrE,eAAO,MAAM,MAAM,QAAmB,CAAC;AAEvC,0DAA0D;AAC1D,eAAO,MAAM,OAAO,QAAsB,CAAC;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAyB,CAAC;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,qDAMxB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,WAAa,CAAC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/utils/validation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qEAAqE;AACrE,eAAO,MAAM,MAAM,QAAmB,CAAC;AAEvC,0DAA0D;AAC1D,eAAO,MAAM,OAAO,QAAsB,CAAC;AAE3C,gEAAgE;AAChE,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAyB,CAAC;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,qDAMxB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,WAAa,CAAC"}

package/dist/tbv/core/vault-secrets/deriveVaultRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deriveVaultRoot.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/vault-secrets/deriveVaultRoot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEtE;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,sBAAsB,CAAC;AAUlD;;;;;;GAMG;AACH,MAAM,WAAW,8BAA8B;IAC7C,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtE;AAED;;kCAEkC;AAClC,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,OAAO,CAAC,8BAA8B,CAAC,GAC9C,OAAO,CAAC,8BAA8B,CAAC,CAOzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,8BAA8B,EACtC,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,UAAU,CAAC,CAuBrB"}
+{"version":3,"file":"deriveVaultRoot.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/vault-secrets/deriveVaultRoot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEtE;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,sBAAsB,CAAC;AAUlD;;;;;;GAMG;AACH,MAAM,WAAW,8BAA8B;IAC7C,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtE;AAED;;kCAEkC;AAClC,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,OAAO,CAAC,8BAA8B,CAAC,GAC9C,OAAO,CAAC,8BAA8B,CAAC,CAWzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,8BAA8B,EACtC,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,UAAU,CAAC,CAuBrB"}

package/dist/tbv/core/vault-secrets/index.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("@babylonlabs-io/babylon-tbv-rust-wasm"),e=require("../../../parseFundingOutpoints-CIO9Ok1L.cjs");Object.defineProperty(exports,"expandAuthAnchor",{enumerable:!0,get:()=>t.expandAuthAnchor});Object.defineProperty(exports,"expandHashlockSecret",{enumerable:!0,get:()=>t.expandHashlockSecret});Object.defineProperty(exports,"expandWotsSeed",{enumerable:!0,get:()=>t.expandWotsSeed});exports.VAULT_APP_NAME=e.VAULT_APP_NAME;exports.buildFundingOutpointsCommitment=e.buildFundingOutpointsCommitment;exports.buildVaultContext=e.buildVaultContext;exports.deriveVaultRoot=e.deriveVaultRoot;exports.forwardDeriveContextHash=e.forwardDeriveContextHash;exports.parseFundingOutpointsFromTx=e.parseFundingOutpointsFromTx;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../wasm/index.cjs"),e=require("../../../parseFundingOutpoints-BkgGihaY.cjs");exports.expandAuthAnchor=t.expandAuthAnchor;exports.expandHashlockSecret=t.expandHashlockSecret;exports.expandWotsSeed=t.expandWotsSeed;exports.VAULT_APP_NAME=e.VAULT_APP_NAME;exports.buildFundingOutpointsCommitment=e.buildFundingOutpointsCommitment;exports.buildVaultContext=e.buildVaultContext;exports.deriveVaultRoot=e.deriveVaultRoot;exports.forwardDeriveContextHash=e.forwardDeriveContextHash;exports.parseFundingOutpointsFromTx=e.parseFundingOutpointsFromTx;
 //# sourceMappingURL=index.cjs.map

package/dist/tbv/core/vault-secrets/index.d.ts

@@ -12,7 +12,7 @@
  * @module tbv/core/vault-secrets
  */
 /** @stability frozen — owned by btc-vault Rust via babylon-tbv-rust-wasm; see CLAUDE.md §4 + wrapper JSDoc for failure modes. */
-export { expandAuthAnchor, expandHashlockSecret, expandWotsSeed, } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+export { expandAuthAnchor, expandHashlockSecret, expandWotsSeed, } from '../wasm';
 export { buildFundingOutpointsCommitment, buildVaultContext } from './context';
 export type { FundingOutpoint, VaultContextInput } from './context';
 export { VAULT_APP_NAME, deriveVaultRoot, forwardDeriveContextHash, } from './deriveVaultRoot';

package/dist/tbv/core/vault-secrets/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/vault-secrets/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,iIAAiI;AACjI,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,GACf,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,+BAA+B,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE/E,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEpE,OAAO,EACL,cAAc,EACd,eAAe,EACf,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAExE,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/vault-secrets/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,iIAAiI;AACjI,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,GACf,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,+BAA+B,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE/E,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAEpE,OAAO,EACL,cAAc,EACd,eAAe,EACf,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAExE,OAAO,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/tbv/core/vault-secrets/index.js

@@ -1,5 +1,5 @@
-import { expandAuthAnchor as a, expandHashlockSecret as o, expandWotsSeed as n } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { V as s, b as d, a as i, d as p, f as u, p as x } from "../../../parseFundingOutpoints-CO-f6IHK.js";
+import { expandAuthAnchor as a, expandHashlockSecret as o, expandWotsSeed as n } from "../wasm/index.js";
+import { V as s, b as d, a as i, d as p, f as u, p as x } from "../../../parseFundingOutpoints-DlINgQ3X.js";
 export {
   s as VAULT_APP_NAME,
   d as buildFundingOutpointsCommitment,

package/dist/tbv/core/wasm/__tests__/constants.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=constants.test.d.ts.map

package/dist/tbv/core/wasm/__tests__/constants.test.d.ts.map

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

package/dist/tbv/core/wasm/__tests__/loader.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=loader.test.d.ts.map

package/dist/tbv/core/wasm/__tests__/loader.test.d.ts.map

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

package/dist/tbv/core/wasm/__tests__/value-guards.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=value-guards.test.d.ts.map

package/dist/tbv/core/wasm/__tests__/value-guards.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-guards.test.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/wasm/__tests__/value-guards.test.ts"],"names":[],"mappings":""}

package/dist/tbv/core/wasm/constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Protocol constants that do not require loading the vault WASM module.
+ *
+ * Keeping these values local lets Bitcoin builders construct PSBT metadata
+ * without resolving or evaluating the WASM engine at module-import
+ * time. The hex value is the BIP-341 nothing-up-my-sleeve internal key and is
+ * pinned by the vault protocol.
+ */
+export declare const TAP_INTERNAL_KEY = "50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
+export declare const tapInternalPubkey: Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/tbv/core/wasm/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/wasm/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,qEACuC,CAAC;AAIrE,eAAO,MAAM,iBAAiB,yBAU7B,CAAC"}

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

@@ -0,0 +1,2 @@
+"use strict";var y=Object.create;var d=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var b=Object.getPrototypeOf,m=Object.prototype.hasOwnProperty;var w=(e,t,a,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of f(t))!m.call(e,o)&&o!==a&&d(e,o,{get:()=>t[o],enumerable:!(r=h(t,o))||r.enumerable});return e};var P=(e,t,a)=>(a=e!=null?y(b(e)):{},w(t||!e||!e.__esModule?d(a,"default",{value:e,enumerable:!0}):a,e));Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l="50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0",i=2,A=Uint8Array.from({length:l.length/i},(e,t)=>Number.parseInt(l.slice(t*i,t*i+i),16));let s,c;function n(){return s??(s=import("@babylonlabs-io/babylon-tbv-rust-wasm").catch(e=>{throw s=void 0,new Error("The vault-WASM engine @babylonlabs-io/babylon-tbv-rust-wasm failed to load. The module could not be resolved, or it threw while evaluating, commonly a missing or stale generated WASM build. See the cause for the underlying error.",{cause:e})})),s}function v(){return c??(c=import("@babylonlabs-io/babylon-tbv-rust-wasm/raw").catch(e=>{throw c=void 0,new Error("The raw vault-WASM entry @babylonlabs-io/babylon-tbv-rust-wasm/raw failed to load. The module could not be resolved, or it threw while evaluating. See the cause for the underlying error.",{cause:e})}).then(async e=>{try{await e.initWasm()}catch(t){throw c=void 0,new Error("The raw vault-WASM entry resolved but its WebAssembly binary failed to initialize.",{cause:t})}return e})),c}async function S(e){return(await n()).createPrePeginTransaction(e)}async function T(e,t,a,r){return(await n()).buildPeginTxFromPrePegin(e,t,a,r)}async function I(e){return(await n()).getPrePeginHtlcConnectorInfo(e)}async function x(e,t,a,r,o,u){return(await n()).computeMinClaimValue(e,t,a,r,o,u)}async function W(e,t,a,r){return(await n()).computeMinPeginFee(e,t,a,r)}async function C(e,t,a,r,o,u,p,g){return(await n()).computePayoutFeeFloor(e,t,a,r,o,u,p,g)}async function M(){return(await n()).supportedTxGraphVersions()}async function F(e){return(await n()).peginP2aAnchorOutput(e)}async function E(e,t){return(await n()).validatePeginP2aAnchor(e,t)}async function V(e,t){return(await n()).createPayoutConnector(e,t)}async function H(e){return(await n()).getAssertPayoutScriptInfo(e)}async function N(e,t){return(await n()).getAssertNoPayoutScriptInfo(e,t)}async function _(e){return(await n()).getChallengeAssertScriptInfo(e)}async function R(e){return(await n()).expandAuthAnchor(e)}async function k(e,t){return(await n()).expandHashlockSecret(e,t)}async function O(e,t){return(await n()).expandWotsSeed(e,t)}async function G(e,t){return(await n()).deriveVaultId(e,t)}exports.TAP_INTERNAL_KEY=l;exports.buildPeginTxFromPrePegin=T;exports.computeMinClaimValue=x;exports.computeMinPeginFee=W;exports.computePayoutFeeFloor=C;exports.createPayoutConnector=V;exports.createPrePeginTransaction=S;exports.deriveVaultId=G;exports.expandAuthAnchor=R;exports.expandHashlockSecret=k;exports.expandWotsSeed=O;exports.getAssertNoPayoutScriptInfo=N;exports.getAssertPayoutScriptInfo=H;exports.getChallengeAssertScriptInfo=_;exports.getPrePeginHtlcConnectorInfo=I;exports.loadRawTbvWasm=v;exports.loadTbvWasm=n;exports.peginP2aAnchorOutput=F;exports.supportedTxGraphVersions=M;exports.tapInternalPubkey=A;exports.validatePeginP2aAnchor=E;
+//# sourceMappingURL=index.cjs.map

package/dist/tbv/core/wasm/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../../src/tbv/core/wasm/constants.ts","../../../../src/tbv/core/wasm/index.ts"],"sourcesContent":["/**\n * Protocol constants that do not require loading the vault WASM module.\n *\n * Keeping these values local lets Bitcoin builders construct PSBT metadata\n * without resolving or evaluating the WASM engine at module-import\n * time. The hex value is the BIP-341 nothing-up-my-sleeve internal key and is\n * pinned by the vault protocol.\n */\nexport const TAP_INTERNAL_KEY =\n  \"50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0\";\n\nconst HEX_CHARS_PER_BYTE = 2;\n\nexport const tapInternalPubkey = Uint8Array.from(\n  { length: TAP_INTERNAL_KEY.length / HEX_CHARS_PER_BYTE },\n  (_, index) =>\n    Number.parseInt(\n      TAP_INTERNAL_KEY.slice(\n        index * HEX_CHARS_PER_BYTE,\n        index * HEX_CHARS_PER_BYTE + HEX_CHARS_PER_BYTE,\n      ),\n      16,\n    ),\n);\n","/**\n * Explicit lazy boundary around the vault-WASM engine package.\n *\n * Importing the SDK (including its legacy root barrels) does not resolve the\n * WASM package or generated binary. The engine is loaded only when a caller\n * invokes an operation that actually needs the Bitcoin transaction graph.\n * ETH-only entry points never import this module.\n *\n * @module tbv/core/wasm\n */\n\nimport type {\n  AssertNoPayoutScriptInfo,\n  AssertPayoutNoPayoutConnectorParams,\n  AssertPayoutScriptInfo,\n  ChallengeAssertConnectorParams,\n  ChallengeAssertScriptInfo,\n  HtlcConnectorInfo,\n  HtlcConnectorParams,\n  Network,\n  PayoutConnectorInfo,\n  PayoutConnectorParams,\n  PeginP2aAnchorInfo,\n  PeginTxResult,\n  PrePeginParams,\n  PrePeginResult,\n} from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\n\nexport { TAP_INTERNAL_KEY, tapInternalPubkey } from \"./constants\";\n\ntype TbvWasmModule = typeof import(\"@babylonlabs-io/babylon-tbv-rust-wasm\");\n\nlet wasmModulePromise: Promise<TbvWasmModule> | undefined;\ntype RawTbvWasmModule =\n  typeof import(\"@babylonlabs-io/babylon-tbv-rust-wasm/raw\");\nlet rawWasmModulePromise: Promise<RawTbvWasmModule> | undefined;\n\n/** Load the WASM engine on first use and share the in-flight import. */\nexport function loadTbvWasm(): Promise<TbvWasmModule> {\n  wasmModulePromise ??= import(\"@babylonlabs-io/babylon-tbv-rust-wasm\").catch(\n    (error: unknown) => {\n      wasmModulePromise = undefined;\n      throw new Error(\n        \"The vault-WASM engine @babylonlabs-io/babylon-tbv-rust-wasm failed \" +\n          \"to load. The module could not be resolved, or it threw while \" +\n          \"evaluating, commonly a missing or stale generated WASM build. \" +\n          \"See the cause for the underlying error.\",\n        { cause: error },\n      );\n    },\n  );\n  return wasmModulePromise;\n}\n\n/**\n * Load the explicit raw-class entry for the one SDK primitive that must\n * reconstruct a stateful WASM transaction object (refund construction).\n */\nexport function loadRawTbvWasm(): Promise<RawTbvWasmModule> {\n  rawWasmModulePromise ??= import(\"@babylonlabs-io/babylon-tbv-rust-wasm/raw\")\n    .catch((error: unknown) => {\n      rawWasmModulePromise = undefined;\n      throw new Error(\n        \"The raw vault-WASM entry @babylonlabs-io/babylon-tbv-rust-wasm/raw \" +\n          \"failed to load. The module could not be resolved, or it threw \" +\n          \"while evaluating. See the cause for the underlying error.\",\n        { cause: error },\n      );\n    })\n    .then(async (wasm) => {\n      try {\n        await wasm.initWasm();\n      } catch (error: unknown) {\n        rawWasmModulePromise = undefined;\n        throw new Error(\n          \"The raw vault-WASM entry resolved but its WebAssembly \" +\n            \"binary failed to initialize.\",\n          { cause: error },\n        );\n      }\n      return wasm;\n    });\n  return rawWasmModulePromise;\n}\n\n/**\n * Creates an unfunded Pre-PegIn transaction with no inputs and HTLC output(s).\n *\n * The HTLC output value (htlcValue) covers the peg-in amount, depositor claim value,\n * and minimum pegin fee — all computed internally from the provided contract parameters.\n *\n * After building the Pre-PegIn transaction, the caller must:\n * 1. Select UTXOs covering htlcValue + network fees\n * 2. Fund the transaction (add inputs and change output)\n * 3. Call reconstructFromFundedTx() with the funded tx hex\n * 4. Call buildPeginTx() to derive the PegIn transaction\n * 5. Sign the PegIn input using the HTLC hashlock leaf (leaf 0)\n *\n * @param params - Pre-PegIn parameters from contract and depositor wallet\n * @returns Unfunded transaction details with HTLC output information\n */\nexport async function createPrePeginTransaction(\n  params: PrePeginParams,\n): Promise<PrePeginResult> {\n  return (await loadTbvWasm()).createPrePeginTransaction(params);\n}\n\n/**\n * Derives the PegIn transaction from a funded Pre-PegIn transaction.\n *\n * The PegIn transaction has a single input spending the Pre-PegIn HTLC output\n * at `htlcVout` via the hashlock + all-party script (leaf 0).\n *\n * @param params - Same PrePeginParams used to create the Pre-PegIn transaction\n * @param timelockPegin - CSV timelock in blocks for the PegIn vault output\n * @param fundedPrePeginTxHex - Hex-encoded funded Pre-PegIn transaction\n * @param htlcVout - Index of the HTLC output to spend\n * @returns PegIn transaction details including vault output information\n */\nexport async function buildPeginTxFromPrePegin(\n  params: PrePeginParams,\n  timelockPegin: number,\n  fundedPrePeginTxHex: string,\n  htlcVout: number,\n): Promise<PeginTxResult> {\n  return (await loadTbvWasm()).buildPeginTxFromPrePegin(\n    params,\n    timelockPegin,\n    fundedPrePeginTxHex,\n    htlcVout,\n  );\n}\n\n/**\n * Returns HTLC connector script info for signing the PegIn transaction input.\n *\n * The depositor signs PegIn input 0 using the hashlock leaf (leaf 0) of the\n * Pre-PegIn HTLC output. Use getHashlockScript() and getHashlockControlBlock()\n * to construct the tapLeafScript entry in the PSBT.\n *\n * @param params - HTLC connector parameters (subset of PrePeginParams)\n * @returns Hashlock and refund script info for PSBT construction\n */\nexport async function getPrePeginHtlcConnectorInfo(\n  params: HtlcConnectorParams,\n): Promise<HtlcConnectorInfo> {\n  return (await loadTbvWasm()).getPrePeginHtlcConnectorInfo(params);\n}\n\n/**\n * Compute the minimum depositor claim value (PegIn output 1) in satoshis.\n *\n * This covers the full downstream tx graph cost (Claim → Assert → Payout)\n * based on the protocol parameters.\n */\nexport async function computeMinClaimValue(\n  txGraphVersion: number,\n  numLocalChallengers: number,\n  numUniversalChallengers: number,\n  councilQuorum: number,\n  councilSize: number,\n  feeRate: bigint,\n): Promise<bigint> {\n  return (await loadTbvWasm()).computeMinClaimValue(\n    txGraphVersion,\n    numLocalChallengers,\n    numUniversalChallengers,\n    councilQuorum,\n    councilSize,\n    feeRate,\n  );\n}\n\n/**\n * Compute the minimum PegIn (activation) transaction fee in satoshis.\n *\n * `minPeginFee = peginTxVsize(numVks, numUcs) × minPeginFeeRate`. Each HTLC\n * the depositor funds in the Pre-PegIn tx must reserve at least this fee\n * inside its value (`htlcValue = peginAmount + depositorClaimValue +\n * minPeginFee`), otherwise the VP cannot afford to broadcast the PegIn at\n * activation. The vsize comes from a Taproot script-path-spend weight\n * prediction whose witness shape depends on the VK + UC signer count.\n */\nexport async function computeMinPeginFee(\n  txGraphVersion: number,\n  numVks: number,\n  numUcs: number,\n  minPeginFeeRate: bigint,\n): Promise<bigint> {\n  return (await loadTbvWasm()).computeMinPeginFee(\n    txGraphVersion,\n    numVks,\n    numUcs,\n    minPeginFeeRate,\n  );\n}\n\n/**\n * Floor of the Payout transaction fee under `txGraphVersion`: the minimum of\n * `estimatedVsize * feeRate` across every output-sizing model a deployed\n * vault provider is known to have used (fixed-34, intermediate,\n * script-aware). A VP-built payout paying less than this is provably not\n * produced by any known VP build. `out0Len` must be the TRUSTED length of the\n * pinned outs[0] script (1..=128); `out1Len` is the measured, UNTRUSTED\n * commission-script length — safe here because padding cannot raise the floor\n * (the fixed-34 model saturates the minimum) and shortening only lowers it.\n * Pass `undefined` for `out1Len` on 2-output (non-VP-claimer) payouts.\n * `feeRate` is the vault's version-locked `offchainParams.feeRate`.\n */\nexport async function computePayoutFeeFloor(\n  txGraphVersion: number,\n  numVaultKeepers: number,\n  numUniversalChallengers: number,\n  numLocalChallengers: number,\n  councilSize: number,\n  out0Len: number,\n  out1Len: number | null | undefined,\n  feeRate: bigint,\n): Promise<bigint> {\n  return (await loadTbvWasm()).computePayoutFeeFloor(\n    txGraphVersion,\n    numVaultKeepers,\n    numUniversalChallengers,\n    numLocalChallengers,\n    councilSize,\n    out0Len,\n    out1Len,\n    feeRate,\n  );\n}\n\n/**\n * Tx graph versions the shipped vault-wasm binary can build. Callers must\n * preflight the required version (fresh: active; resume: stamped) against\n * this list and fail closed instead of hitting per-call errors mid-flow.\n *\n * Note: the facade constructors themselves fail closed on unsupported\n * versions, and derived objects carry the version they were built with —\n * value-level cross-checks live in `assertWasmPeginSizing` and the golden\n * byte-parity tests, not in a per-call version echo.\n */\nexport async function supportedTxGraphVersions(): Promise<number[]> {\n  return (await loadTbvWasm()).supportedTxGraphVersions();\n}\n\n/**\n * The PegIn transaction's P2A (pay-to-anchor) output for a graph version, or\n * `null` when that version's PegIn carries no anchor (v1). The facade returns\n * one record per version — never a zero-valued placeholder — so an absent\n * anchor can't be mistaken for a real output. For v2/v3: 240 sats at vout 2,\n * script `51024e73`.\n */\nexport async function peginP2aAnchorOutput(\n  txGraphVersion: number,\n): Promise<PeginP2aAnchorInfo | null> {\n  return (await loadTbvWasm()).peginP2aAnchorOutput(txGraphVersion);\n}\n\n/**\n * Validate a PegIn transaction's P2A anchor against a graph version's rules:\n * v2 and v3 require the exact anchor (240 sats, vout 2, P2A script) and v1\n * requires that NO output carries the P2A script. Throws on any mismatch — a\n * v2 PegIn checked as v1 fails closed, and vice versa.\n */\nexport async function validatePeginP2aAnchor(\n  txGraphVersion: number,\n  txHex: string,\n): Promise<void> {\n  return (await loadTbvWasm()).validatePeginP2aAnchor(txGraphVersion, txHex);\n}\n\n/**\n * Creates a payout connector for vault transactions.\n *\n * The payout connector generates the necessary taproot scripts and information\n * required for signing payout transactions (both optimistic and regular payout paths).\n *\n * @param params - Parameters for creating the payout connector\n * @param network - Bitcoin network\n * @returns Payout connector information including scripts, hashes, and address\n */\nexport async function createPayoutConnector(\n  params: PayoutConnectorParams,\n  network: Network,\n): Promise<PayoutConnectorInfo> {\n  return (await loadTbvWasm()).createPayoutConnector(params, network);\n}\n\n/**\n * Get the Payout script and control block for the depositor's Assert output.\n *\n * Used to build the depositor's Payout PSBT (depositor-as-claimer path).\n *\n * @param params - Assert Payout/NoPayout connector parameters\n * @returns Payout script and control block (hex encoded)\n */\nexport async function getAssertPayoutScriptInfo(\n  params: AssertPayoutNoPayoutConnectorParams,\n): Promise<AssertPayoutScriptInfo> {\n  return (await loadTbvWasm()).getAssertPayoutScriptInfo(params);\n}\n\n/**\n * Get the NoPayout script and control block for a specific challenger.\n *\n * Used to build the depositor's NoPayout PSBT (depositor-as-claimer path).\n * Each challenger has a distinct NoPayout script.\n *\n * @param params - Assert Payout/NoPayout connector parameters\n * @param challengerPubkey - The challenger's x-only public key (hex encoded)\n * @returns NoPayout script and control block (hex encoded)\n */\nexport async function getAssertNoPayoutScriptInfo(\n  params: AssertPayoutNoPayoutConnectorParams,\n  challengerPubkey: string,\n): Promise<AssertNoPayoutScriptInfo> {\n  return (await loadTbvWasm()).getAssertNoPayoutScriptInfo(\n    params,\n    challengerPubkey,\n  );\n}\n\n/**\n * Get the ChallengeAssert script and control block.\n *\n * Used to build ChallengeAssert PSBTs for the depositor-as-claimer path.\n * Each challenger has 3 ChallengeAssert transactions, and this connector\n * generates the spending scripts using WOTS public keys from the VP.\n *\n * @param params - ChallengeAssert connector parameters\n * @returns Script and control block (hex encoded)\n */\nexport async function getChallengeAssertScriptInfo(\n  params: ChallengeAssertConnectorParams,\n): Promise<ChallengeAssertScriptInfo> {\n  return (await loadTbvWasm()).getChallengeAssertScriptInfo(params);\n}\n\n/**\n * Derive 32-byte `authAnchor` (OP_RETURN preimage → VP bearer token).\n * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.\n */\n/**\n * Derive 32-byte `authAnchor` (OP_RETURN preimage → VP bearer token).\n * @stability frozen — owned by btc-vault Rust via the vault-wasm pin (`VAULT_WASM_COMMIT`); rotation breaks VP auth for existing deposits.\n */\nexport async function expandAuthAnchor(root: Uint8Array): Promise<Uint8Array> {\n  return (await loadTbvWasm()).expandAuthAnchor(root);\n}\n\n/**\n * Derive 32-byte `hashlockSecret` for HTLC `htlcVout` (preimage → `activateVaultWithSecret`).\n * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.\n */\n/**\n * Derive 32-byte `hashlockSecret` for HTLC `htlcVout` (preimage → `activateVaultWithSecret`).\n * @stability frozen — owned by btc-vault Rust; rotation means affected vaults can never activate.\n */\nexport async function expandHashlockSecret(\n  root: Uint8Array,\n  htlcVout: number,\n): Promise<Uint8Array> {\n  return (await loadTbvWasm()).expandHashlockSecret(root, htlcVout);\n}\n\n/**\n * Derive 64-byte `wotsSeed` for HTLC `htlcVout` (→ WOTS keys, hashed as `depositorWotsPkHash`).\n * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.\n */\n/**\n * Derive 64-byte `wotsSeed` for HTLC `htlcVout` (→ WOTS keys, hashed as `depositorWotsPkHash`).\n * @stability frozen — owned by btc-vault Rust; rotation breaks existing `depositorWotsPkHash` → no claim path.\n */\nexport async function expandWotsSeed(\n  root: Uint8Array,\n  htlcVout: number,\n): Promise<Uint8Array> {\n  return (await loadTbvWasm()).expandWotsSeed(root, htlcVout);\n}\n\n/**\n * Derives the vault ID from a PegIn transaction hash and depositor ETH address.\n *\n * Vault ID = keccak256(abi.encode(peginTxHash, depositor))\n * This matches the Solidity-side derivation in BTCVaultRegistry.\n *\n * @param peginTxHash - 32-byte PegIn tx hash in display order (big-endian), hex encoded\n * @param depositor - 20-byte Ethereum address of the depositor, hex encoded\n * @returns Hex-encoded vault ID (32 bytes)\n */\nexport async function deriveVaultId(\n  peginTxHash: string,\n  depositor: string,\n): Promise<string> {\n  return (await loadTbvWasm()).deriveVaultId(peginTxHash, depositor);\n}\n\nexport type {\n  AssertNoPayoutScriptInfo,\n  AssertPayoutNoPayoutConnectorParams,\n  AssertPayoutScriptInfo,\n  ChallengeAssertConnectorParams,\n  ChallengeAssertScriptInfo,\n  HtlcConnectorInfo,\n  HtlcConnectorParams,\n  Network,\n  PayoutConnectorInfo,\n  PayoutConnectorParams,\n  PeginP2aAnchorInfo,\n  PeginTxResult,\n  PrePeginParams,\n  PrePeginResult,\n};\n"],"names":["TAP_INTERNAL_KEY","HEX_CHARS_PER_BYTE","tapInternalPubkey","_","index","wasmModulePromise","rawWasmModulePromise","loadTbvWasm","error","loadRawTbvWasm","wasm","createPrePeginTransaction","params","buildPeginTxFromPrePegin","timelockPegin","fundedPrePeginTxHex","htlcVout","getPrePeginHtlcConnectorInfo","computeMinClaimValue","txGraphVersion","numLocalChallengers","numUniversalChallengers","councilQuorum","councilSize","feeRate","computeMinPeginFee","numVks","numUcs","minPeginFeeRate","computePayoutFeeFloor","numVaultKeepers","out0Len","out1Len","supportedTxGraphVersions","peginP2aAnchorOutput","validatePeginP2aAnchor","txHex","createPayoutConnector","network","getAssertPayoutScriptInfo","getAssertNoPayoutScriptInfo","challengerPubkey","getChallengeAssertScriptInfo","expandAuthAnchor","root","expandHashlockSecret","expandWotsSeed","deriveVaultId","peginTxHash","depositor"],"mappings":"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"}

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

@@ -0,0 +1,191 @@
+import { AssertNoPayoutScriptInfo, AssertPayoutNoPayoutConnectorParams, AssertPayoutScriptInfo, ChallengeAssertConnectorParams, ChallengeAssertScriptInfo, HtlcConnectorInfo, HtlcConnectorParams, Network, PayoutConnectorInfo, PayoutConnectorParams, PeginP2aAnchorInfo, PeginTxResult, PrePeginParams, PrePeginResult } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+export { TAP_INTERNAL_KEY, tapInternalPubkey } from './constants';
+type TbvWasmModule = typeof import("@babylonlabs-io/babylon-tbv-rust-wasm");
+type RawTbvWasmModule = typeof import("@babylonlabs-io/babylon-tbv-rust-wasm/raw");
+/** Load the WASM engine on first use and share the in-flight import. */
+export declare function loadTbvWasm(): Promise<TbvWasmModule>;
+/**
+ * Load the explicit raw-class entry for the one SDK primitive that must
+ * reconstruct a stateful WASM transaction object (refund construction).
+ */
+export declare function loadRawTbvWasm(): Promise<RawTbvWasmModule>;
+/**
+ * Creates an unfunded Pre-PegIn transaction with no inputs and HTLC output(s).
+ *
+ * The HTLC output value (htlcValue) covers the peg-in amount, depositor claim value,
+ * and minimum pegin fee — all computed internally from the provided contract parameters.
+ *
+ * After building the Pre-PegIn transaction, the caller must:
+ * 1. Select UTXOs covering htlcValue + network fees
+ * 2. Fund the transaction (add inputs and change output)
+ * 3. Call reconstructFromFundedTx() with the funded tx hex
+ * 4. Call buildPeginTx() to derive the PegIn transaction
+ * 5. Sign the PegIn input using the HTLC hashlock leaf (leaf 0)
+ *
+ * @param params - Pre-PegIn parameters from contract and depositor wallet
+ * @returns Unfunded transaction details with HTLC output information
+ */
+export declare function createPrePeginTransaction(params: PrePeginParams): Promise<PrePeginResult>;
+/**
+ * Derives the PegIn transaction from a funded Pre-PegIn transaction.
+ *
+ * The PegIn transaction has a single input spending the Pre-PegIn HTLC output
+ * at `htlcVout` via the hashlock + all-party script (leaf 0).
+ *
+ * @param params - Same PrePeginParams used to create the Pre-PegIn transaction
+ * @param timelockPegin - CSV timelock in blocks for the PegIn vault output
+ * @param fundedPrePeginTxHex - Hex-encoded funded Pre-PegIn transaction
+ * @param htlcVout - Index of the HTLC output to spend
+ * @returns PegIn transaction details including vault output information
+ */
+export declare function buildPeginTxFromPrePegin(params: PrePeginParams, timelockPegin: number, fundedPrePeginTxHex: string, htlcVout: number): Promise<PeginTxResult>;
+/**
+ * Returns HTLC connector script info for signing the PegIn transaction input.
+ *
+ * The depositor signs PegIn input 0 using the hashlock leaf (leaf 0) of the
+ * Pre-PegIn HTLC output. Use getHashlockScript() and getHashlockControlBlock()
+ * to construct the tapLeafScript entry in the PSBT.
+ *
+ * @param params - HTLC connector parameters (subset of PrePeginParams)
+ * @returns Hashlock and refund script info for PSBT construction
+ */
+export declare function getPrePeginHtlcConnectorInfo(params: HtlcConnectorParams): Promise<HtlcConnectorInfo>;
+/**
+ * Compute the minimum depositor claim value (PegIn output 1) in satoshis.
+ *
+ * This covers the full downstream tx graph cost (Claim → Assert → Payout)
+ * based on the protocol parameters.
+ */
+export declare function computeMinClaimValue(txGraphVersion: number, numLocalChallengers: number, numUniversalChallengers: number, councilQuorum: number, councilSize: number, feeRate: bigint): Promise<bigint>;
+/**
+ * Compute the minimum PegIn (activation) transaction fee in satoshis.
+ *
+ * `minPeginFee = peginTxVsize(numVks, numUcs) × minPeginFeeRate`. Each HTLC
+ * the depositor funds in the Pre-PegIn tx must reserve at least this fee
+ * inside its value (`htlcValue = peginAmount + depositorClaimValue +
+ * minPeginFee`), otherwise the VP cannot afford to broadcast the PegIn at
+ * activation. The vsize comes from a Taproot script-path-spend weight
+ * prediction whose witness shape depends on the VK + UC signer count.
+ */
+export declare function computeMinPeginFee(txGraphVersion: number, numVks: number, numUcs: number, minPeginFeeRate: bigint): Promise<bigint>;
+/**
+ * Floor of the Payout transaction fee under `txGraphVersion`: the minimum of
+ * `estimatedVsize * feeRate` across every output-sizing model a deployed
+ * vault provider is known to have used (fixed-34, intermediate,
+ * script-aware). A VP-built payout paying less than this is provably not
+ * produced by any known VP build. `out0Len` must be the TRUSTED length of the
+ * pinned outs[0] script (1..=128); `out1Len` is the measured, UNTRUSTED
+ * commission-script length — safe here because padding cannot raise the floor
+ * (the fixed-34 model saturates the minimum) and shortening only lowers it.
+ * Pass `undefined` for `out1Len` on 2-output (non-VP-claimer) payouts.
+ * `feeRate` is the vault's version-locked `offchainParams.feeRate`.
+ */
+export declare function computePayoutFeeFloor(txGraphVersion: number, numVaultKeepers: number, numUniversalChallengers: number, numLocalChallengers: number, councilSize: number, out0Len: number, out1Len: number | null | undefined, feeRate: bigint): Promise<bigint>;
+/**
+ * Tx graph versions the shipped vault-wasm binary can build. Callers must
+ * preflight the required version (fresh: active; resume: stamped) against
+ * this list and fail closed instead of hitting per-call errors mid-flow.
+ *
+ * Note: the facade constructors themselves fail closed on unsupported
+ * versions, and derived objects carry the version they were built with —
+ * value-level cross-checks live in `assertWasmPeginSizing` and the golden
+ * byte-parity tests, not in a per-call version echo.
+ */
+export declare function supportedTxGraphVersions(): Promise<number[]>;
+/**
+ * The PegIn transaction's P2A (pay-to-anchor) output for a graph version, or
+ * `null` when that version's PegIn carries no anchor (v1). The facade returns
+ * one record per version — never a zero-valued placeholder — so an absent
+ * anchor can't be mistaken for a real output. For v2/v3: 240 sats at vout 2,
+ * script `51024e73`.
+ */
+export declare function peginP2aAnchorOutput(txGraphVersion: number): Promise<PeginP2aAnchorInfo | null>;
+/**
+ * Validate a PegIn transaction's P2A anchor against a graph version's rules:
+ * v2 and v3 require the exact anchor (240 sats, vout 2, P2A script) and v1
+ * requires that NO output carries the P2A script. Throws on any mismatch — a
+ * v2 PegIn checked as v1 fails closed, and vice versa.
+ */
+export declare function validatePeginP2aAnchor(txGraphVersion: number, txHex: string): Promise<void>;
+/**
+ * Creates a payout connector for vault transactions.
+ *
+ * The payout connector generates the necessary taproot scripts and information
+ * required for signing payout transactions (both optimistic and regular payout paths).
+ *
+ * @param params - Parameters for creating the payout connector
+ * @param network - Bitcoin network
+ * @returns Payout connector information including scripts, hashes, and address
+ */
+export declare function createPayoutConnector(params: PayoutConnectorParams, network: Network): Promise<PayoutConnectorInfo>;
+/**
+ * Get the Payout script and control block for the depositor's Assert output.
+ *
+ * Used to build the depositor's Payout PSBT (depositor-as-claimer path).
+ *
+ * @param params - Assert Payout/NoPayout connector parameters
+ * @returns Payout script and control block (hex encoded)
+ */
+export declare function getAssertPayoutScriptInfo(params: AssertPayoutNoPayoutConnectorParams): Promise<AssertPayoutScriptInfo>;
+/**
+ * Get the NoPayout script and control block for a specific challenger.
+ *
+ * Used to build the depositor's NoPayout PSBT (depositor-as-claimer path).
+ * Each challenger has a distinct NoPayout script.
+ *
+ * @param params - Assert Payout/NoPayout connector parameters
+ * @param challengerPubkey - The challenger's x-only public key (hex encoded)
+ * @returns NoPayout script and control block (hex encoded)
+ */
+export declare function getAssertNoPayoutScriptInfo(params: AssertPayoutNoPayoutConnectorParams, challengerPubkey: string): Promise<AssertNoPayoutScriptInfo>;
+/**
+ * Get the ChallengeAssert script and control block.
+ *
+ * Used to build ChallengeAssert PSBTs for the depositor-as-claimer path.
+ * Each challenger has 3 ChallengeAssert transactions, and this connector
+ * generates the spending scripts using WOTS public keys from the VP.
+ *
+ * @param params - ChallengeAssert connector parameters
+ * @returns Script and control block (hex encoded)
+ */
+export declare function getChallengeAssertScriptInfo(params: ChallengeAssertConnectorParams): Promise<ChallengeAssertScriptInfo>;
+/**
+ * Derive 32-byte `authAnchor` (OP_RETURN preimage → VP bearer token).
+ * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.
+ */
+/**
+ * Derive 32-byte `authAnchor` (OP_RETURN preimage → VP bearer token).
+ * @stability frozen — owned by btc-vault Rust via the vault-wasm pin (`VAULT_WASM_COMMIT`); rotation breaks VP auth for existing deposits.
+ */
+export declare function expandAuthAnchor(root: Uint8Array): Promise<Uint8Array>;
+/**
+ * Derive 32-byte `hashlockSecret` for HTLC `htlcVout` (preimage → `activateVaultWithSecret`).
+ * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.
+ */
+/**
+ * Derive 32-byte `hashlockSecret` for HTLC `htlcVout` (preimage → `activateVaultWithSecret`).
+ * @stability frozen — owned by btc-vault Rust; rotation means affected vaults can never activate.
+ */
+export declare function expandHashlockSecret(root: Uint8Array, htlcVout: number): Promise<Uint8Array>;
+/**
+ * Derive 64-byte `wotsSeed` for HTLC `htlcVout` (→ WOTS keys, hashed as `depositorWotsPkHash`).
+ * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.
+ */
+/**
+ * Derive 64-byte `wotsSeed` for HTLC `htlcVout` (→ WOTS keys, hashed as `depositorWotsPkHash`).
+ * @stability frozen — owned by btc-vault Rust; rotation breaks existing `depositorWotsPkHash` → no claim path.
+ */
+export declare function expandWotsSeed(root: Uint8Array, htlcVout: number): Promise<Uint8Array>;
+/**
+ * Derives the vault ID from a PegIn transaction hash and depositor ETH address.
+ *
+ * Vault ID = keccak256(abi.encode(peginTxHash, depositor))
+ * This matches the Solidity-side derivation in BTCVaultRegistry.
+ *
+ * @param peginTxHash - 32-byte PegIn tx hash in display order (big-endian), hex encoded
+ * @param depositor - 20-byte Ethereum address of the depositor, hex encoded
+ * @returns Hex-encoded vault ID (32 bytes)
+ */
+export declare function deriveVaultId(peginTxHash: string, depositor: string): Promise<string>;
+export type { AssertNoPayoutScriptInfo, AssertPayoutNoPayoutConnectorParams, AssertPayoutScriptInfo, ChallengeAssertConnectorParams, ChallengeAssertScriptInfo, HtlcConnectorInfo, HtlcConnectorParams, Network, PayoutConnectorInfo, PayoutConnectorParams, PeginP2aAnchorInfo, PeginTxResult, PrePeginParams, PrePeginResult, };
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,144 @@
+const s = "50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
+const y = Uint8Array.from(
+  { length: s.length / 2 },
+  (e, t) => Number.parseInt(
+    s.slice(
+      t * 2,
+      t * 2 + 2
+    ),
+    16
+  )
+);
+let u, o;
+function n() {
+  return u ?? (u = import("@babylonlabs-io/babylon-tbv-rust-wasm").catch(
+    (e) => {
+      throw u = void 0, new Error(
+        "The vault-WASM engine @babylonlabs-io/babylon-tbv-rust-wasm failed to load. The module could not be resolved, or it threw while evaluating, commonly a missing or stale generated WASM build. See the cause for the underlying error.",
+        { cause: e }
+      );
+    }
+  )), u;
+}
+function P() {
+  return o ?? (o = import("@babylonlabs-io/babylon-tbv-rust-wasm/raw").catch((e) => {
+    throw o = void 0, new Error(
+      "The raw vault-WASM entry @babylonlabs-io/babylon-tbv-rust-wasm/raw failed to load. The module could not be resolved, or it threw while evaluating. See the cause for the underlying error.",
+      { cause: e }
+    );
+  }).then(async (e) => {
+    try {
+      await e.initWasm();
+    } catch (t) {
+      throw o = void 0, new Error(
+        "The raw vault-WASM entry resolved but its WebAssembly binary failed to initialize.",
+        { cause: t }
+      );
+    }
+    return e;
+  })), o;
+}
+async function h(e) {
+  return (await n()).createPrePeginTransaction(e);
+}
+async function f(e, t, a, r) {
+  return (await n()).buildPeginTxFromPrePegin(
+    e,
+    t,
+    a,
+    r
+  );
+}
+async function w(e) {
+  return (await n()).getPrePeginHtlcConnectorInfo(e);
+}
+async function g(e, t, a, r, i, c) {
+  return (await n()).computeMinClaimValue(
+    e,
+    t,
+    a,
+    r,
+    i,
+    c
+  );
+}
+async function p(e, t, a, r) {
+  return (await n()).computeMinPeginFee(
+    e,
+    t,
+    a,
+    r
+  );
+}
+async function b(e, t, a, r, i, c, l, d) {
+  return (await n()).computePayoutFeeFloor(
+    e,
+    t,
+    a,
+    r,
+    i,
+    c,
+    l,
+    d
+  );
+}
+async function m() {
+  return (await n()).supportedTxGraphVersions();
+}
+async function A(e) {
+  return (await n()).peginP2aAnchorOutput(e);
+}
+async function S(e, t) {
+  return (await n()).validatePeginP2aAnchor(e, t);
+}
+async function E(e, t) {
+  return (await n()).createPayoutConnector(e, t);
+}
+async function T(e) {
+  return (await n()).getAssertPayoutScriptInfo(e);
+}
+async function v(e, t) {
+  return (await n()).getAssertNoPayoutScriptInfo(
+    e,
+    t
+  );
+}
+async function _(e) {
+  return (await n()).getChallengeAssertScriptInfo(e);
+}
+async function H(e) {
+  return (await n()).expandAuthAnchor(e);
+}
+async function C(e, t) {
+  return (await n()).expandHashlockSecret(e, t);
+}
+async function I(e, t) {
+  return (await n()).expandWotsSeed(e, t);
+}
+async function R(e, t) {
+  return (await n()).deriveVaultId(e, t);
+}
+export {
+  s as TAP_INTERNAL_KEY,
+  f as buildPeginTxFromPrePegin,
+  g as computeMinClaimValue,
+  p as computeMinPeginFee,
+  b as computePayoutFeeFloor,
+  E as createPayoutConnector,
+  h as createPrePeginTransaction,
+  R as deriveVaultId,
+  H as expandAuthAnchor,
+  C as expandHashlockSecret,
+  I as expandWotsSeed,
+  v as getAssertNoPayoutScriptInfo,
+  T as getAssertPayoutScriptInfo,
+  _ as getChallengeAssertScriptInfo,
+  w as getPrePeginHtlcConnectorInfo,
+  P as loadRawTbvWasm,
+  n as loadTbvWasm,
+  A as peginP2aAnchorOutput,
+  m as supportedTxGraphVersions,
+  y as tapInternalPubkey,
+  S as validatePeginP2aAnchor
+};
+//# sourceMappingURL=index.js.map

package/dist/tbv/core/wasm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/tbv/core/wasm/constants.ts","../../../../src/tbv/core/wasm/index.ts"],"sourcesContent":["/**\n * Protocol constants that do not require loading the vault WASM module.\n *\n * Keeping these values local lets Bitcoin builders construct PSBT metadata\n * without resolving or evaluating the WASM engine at module-import\n * time. The hex value is the BIP-341 nothing-up-my-sleeve internal key and is\n * pinned by the vault protocol.\n */\nexport const TAP_INTERNAL_KEY =\n  \"50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0\";\n\nconst HEX_CHARS_PER_BYTE = 2;\n\nexport const tapInternalPubkey = Uint8Array.from(\n  { length: TAP_INTERNAL_KEY.length / HEX_CHARS_PER_BYTE },\n  (_, index) =>\n    Number.parseInt(\n      TAP_INTERNAL_KEY.slice(\n        index * HEX_CHARS_PER_BYTE,\n        index * HEX_CHARS_PER_BYTE + HEX_CHARS_PER_BYTE,\n      ),\n      16,\n    ),\n);\n","/**\n * Explicit lazy boundary around the vault-WASM engine package.\n *\n * Importing the SDK (including its legacy root barrels) does not resolve the\n * WASM package or generated binary. The engine is loaded only when a caller\n * invokes an operation that actually needs the Bitcoin transaction graph.\n * ETH-only entry points never import this module.\n *\n * @module tbv/core/wasm\n */\n\nimport type {\n  AssertNoPayoutScriptInfo,\n  AssertPayoutNoPayoutConnectorParams,\n  AssertPayoutScriptInfo,\n  ChallengeAssertConnectorParams,\n  ChallengeAssertScriptInfo,\n  HtlcConnectorInfo,\n  HtlcConnectorParams,\n  Network,\n  PayoutConnectorInfo,\n  PayoutConnectorParams,\n  PeginP2aAnchorInfo,\n  PeginTxResult,\n  PrePeginParams,\n  PrePeginResult,\n} from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\n\nexport { TAP_INTERNAL_KEY, tapInternalPubkey } from \"./constants\";\n\ntype TbvWasmModule = typeof import(\"@babylonlabs-io/babylon-tbv-rust-wasm\");\n\nlet wasmModulePromise: Promise<TbvWasmModule> | undefined;\ntype RawTbvWasmModule =\n  typeof import(\"@babylonlabs-io/babylon-tbv-rust-wasm/raw\");\nlet rawWasmModulePromise: Promise<RawTbvWasmModule> | undefined;\n\n/** Load the WASM engine on first use and share the in-flight import. */\nexport function loadTbvWasm(): Promise<TbvWasmModule> {\n  wasmModulePromise ??= import(\"@babylonlabs-io/babylon-tbv-rust-wasm\").catch(\n    (error: unknown) => {\n      wasmModulePromise = undefined;\n      throw new Error(\n        \"The vault-WASM engine @babylonlabs-io/babylon-tbv-rust-wasm failed \" +\n          \"to load. The module could not be resolved, or it threw while \" +\n          \"evaluating, commonly a missing or stale generated WASM build. \" +\n          \"See the cause for the underlying error.\",\n        { cause: error },\n      );\n    },\n  );\n  return wasmModulePromise;\n}\n\n/**\n * Load the explicit raw-class entry for the one SDK primitive that must\n * reconstruct a stateful WASM transaction object (refund construction).\n */\nexport function loadRawTbvWasm(): Promise<RawTbvWasmModule> {\n  rawWasmModulePromise ??= import(\"@babylonlabs-io/babylon-tbv-rust-wasm/raw\")\n    .catch((error: unknown) => {\n      rawWasmModulePromise = undefined;\n      throw new Error(\n        \"The raw vault-WASM entry @babylonlabs-io/babylon-tbv-rust-wasm/raw \" +\n          \"failed to load. The module could not be resolved, or it threw \" +\n          \"while evaluating. See the cause for the underlying error.\",\n        { cause: error },\n      );\n    })\n    .then(async (wasm) => {\n      try {\n        await wasm.initWasm();\n      } catch (error: unknown) {\n        rawWasmModulePromise = undefined;\n        throw new Error(\n          \"The raw vault-WASM entry resolved but its WebAssembly \" +\n            \"binary failed to initialize.\",\n          { cause: error },\n        );\n      }\n      return wasm;\n    });\n  return rawWasmModulePromise;\n}\n\n/**\n * Creates an unfunded Pre-PegIn transaction with no inputs and HTLC output(s).\n *\n * The HTLC output value (htlcValue) covers the peg-in amount, depositor claim value,\n * and minimum pegin fee — all computed internally from the provided contract parameters.\n *\n * After building the Pre-PegIn transaction, the caller must:\n * 1. Select UTXOs covering htlcValue + network fees\n * 2. Fund the transaction (add inputs and change output)\n * 3. Call reconstructFromFundedTx() with the funded tx hex\n * 4. Call buildPeginTx() to derive the PegIn transaction\n * 5. Sign the PegIn input using the HTLC hashlock leaf (leaf 0)\n *\n * @param params - Pre-PegIn parameters from contract and depositor wallet\n * @returns Unfunded transaction details with HTLC output information\n */\nexport async function createPrePeginTransaction(\n  params: PrePeginParams,\n): Promise<PrePeginResult> {\n  return (await loadTbvWasm()).createPrePeginTransaction(params);\n}\n\n/**\n * Derives the PegIn transaction from a funded Pre-PegIn transaction.\n *\n * The PegIn transaction has a single input spending the Pre-PegIn HTLC output\n * at `htlcVout` via the hashlock + all-party script (leaf 0).\n *\n * @param params - Same PrePeginParams used to create the Pre-PegIn transaction\n * @param timelockPegin - CSV timelock in blocks for the PegIn vault output\n * @param fundedPrePeginTxHex - Hex-encoded funded Pre-PegIn transaction\n * @param htlcVout - Index of the HTLC output to spend\n * @returns PegIn transaction details including vault output information\n */\nexport async function buildPeginTxFromPrePegin(\n  params: PrePeginParams,\n  timelockPegin: number,\n  fundedPrePeginTxHex: string,\n  htlcVout: number,\n): Promise<PeginTxResult> {\n  return (await loadTbvWasm()).buildPeginTxFromPrePegin(\n    params,\n    timelockPegin,\n    fundedPrePeginTxHex,\n    htlcVout,\n  );\n}\n\n/**\n * Returns HTLC connector script info for signing the PegIn transaction input.\n *\n * The depositor signs PegIn input 0 using the hashlock leaf (leaf 0) of the\n * Pre-PegIn HTLC output. Use getHashlockScript() and getHashlockControlBlock()\n * to construct the tapLeafScript entry in the PSBT.\n *\n * @param params - HTLC connector parameters (subset of PrePeginParams)\n * @returns Hashlock and refund script info for PSBT construction\n */\nexport async function getPrePeginHtlcConnectorInfo(\n  params: HtlcConnectorParams,\n): Promise<HtlcConnectorInfo> {\n  return (await loadTbvWasm()).getPrePeginHtlcConnectorInfo(params);\n}\n\n/**\n * Compute the minimum depositor claim value (PegIn output 1) in satoshis.\n *\n * This covers the full downstream tx graph cost (Claim → Assert → Payout)\n * based on the protocol parameters.\n */\nexport async function computeMinClaimValue(\n  txGraphVersion: number,\n  numLocalChallengers: number,\n  numUniversalChallengers: number,\n  councilQuorum: number,\n  councilSize: number,\n  feeRate: bigint,\n): Promise<bigint> {\n  return (await loadTbvWasm()).computeMinClaimValue(\n    txGraphVersion,\n    numLocalChallengers,\n    numUniversalChallengers,\n    councilQuorum,\n    councilSize,\n    feeRate,\n  );\n}\n\n/**\n * Compute the minimum PegIn (activation) transaction fee in satoshis.\n *\n * `minPeginFee = peginTxVsize(numVks, numUcs) × minPeginFeeRate`. Each HTLC\n * the depositor funds in the Pre-PegIn tx must reserve at least this fee\n * inside its value (`htlcValue = peginAmount + depositorClaimValue +\n * minPeginFee`), otherwise the VP cannot afford to broadcast the PegIn at\n * activation. The vsize comes from a Taproot script-path-spend weight\n * prediction whose witness shape depends on the VK + UC signer count.\n */\nexport async function computeMinPeginFee(\n  txGraphVersion: number,\n  numVks: number,\n  numUcs: number,\n  minPeginFeeRate: bigint,\n): Promise<bigint> {\n  return (await loadTbvWasm()).computeMinPeginFee(\n    txGraphVersion,\n    numVks,\n    numUcs,\n    minPeginFeeRate,\n  );\n}\n\n/**\n * Floor of the Payout transaction fee under `txGraphVersion`: the minimum of\n * `estimatedVsize * feeRate` across every output-sizing model a deployed\n * vault provider is known to have used (fixed-34, intermediate,\n * script-aware). A VP-built payout paying less than this is provably not\n * produced by any known VP build. `out0Len` must be the TRUSTED length of the\n * pinned outs[0] script (1..=128); `out1Len` is the measured, UNTRUSTED\n * commission-script length — safe here because padding cannot raise the floor\n * (the fixed-34 model saturates the minimum) and shortening only lowers it.\n * Pass `undefined` for `out1Len` on 2-output (non-VP-claimer) payouts.\n * `feeRate` is the vault's version-locked `offchainParams.feeRate`.\n */\nexport async function computePayoutFeeFloor(\n  txGraphVersion: number,\n  numVaultKeepers: number,\n  numUniversalChallengers: number,\n  numLocalChallengers: number,\n  councilSize: number,\n  out0Len: number,\n  out1Len: number | null | undefined,\n  feeRate: bigint,\n): Promise<bigint> {\n  return (await loadTbvWasm()).computePayoutFeeFloor(\n    txGraphVersion,\n    numVaultKeepers,\n    numUniversalChallengers,\n    numLocalChallengers,\n    councilSize,\n    out0Len,\n    out1Len,\n    feeRate,\n  );\n}\n\n/**\n * Tx graph versions the shipped vault-wasm binary can build. Callers must\n * preflight the required version (fresh: active; resume: stamped) against\n * this list and fail closed instead of hitting per-call errors mid-flow.\n *\n * Note: the facade constructors themselves fail closed on unsupported\n * versions, and derived objects carry the version they were built with —\n * value-level cross-checks live in `assertWasmPeginSizing` and the golden\n * byte-parity tests, not in a per-call version echo.\n */\nexport async function supportedTxGraphVersions(): Promise<number[]> {\n  return (await loadTbvWasm()).supportedTxGraphVersions();\n}\n\n/**\n * The PegIn transaction's P2A (pay-to-anchor) output for a graph version, or\n * `null` when that version's PegIn carries no anchor (v1). The facade returns\n * one record per version — never a zero-valued placeholder — so an absent\n * anchor can't be mistaken for a real output. For v2/v3: 240 sats at vout 2,\n * script `51024e73`.\n */\nexport async function peginP2aAnchorOutput(\n  txGraphVersion: number,\n): Promise<PeginP2aAnchorInfo | null> {\n  return (await loadTbvWasm()).peginP2aAnchorOutput(txGraphVersion);\n}\n\n/**\n * Validate a PegIn transaction's P2A anchor against a graph version's rules:\n * v2 and v3 require the exact anchor (240 sats, vout 2, P2A script) and v1\n * requires that NO output carries the P2A script. Throws on any mismatch — a\n * v2 PegIn checked as v1 fails closed, and vice versa.\n */\nexport async function validatePeginP2aAnchor(\n  txGraphVersion: number,\n  txHex: string,\n): Promise<void> {\n  return (await loadTbvWasm()).validatePeginP2aAnchor(txGraphVersion, txHex);\n}\n\n/**\n * Creates a payout connector for vault transactions.\n *\n * The payout connector generates the necessary taproot scripts and information\n * required for signing payout transactions (both optimistic and regular payout paths).\n *\n * @param params - Parameters for creating the payout connector\n * @param network - Bitcoin network\n * @returns Payout connector information including scripts, hashes, and address\n */\nexport async function createPayoutConnector(\n  params: PayoutConnectorParams,\n  network: Network,\n): Promise<PayoutConnectorInfo> {\n  return (await loadTbvWasm()).createPayoutConnector(params, network);\n}\n\n/**\n * Get the Payout script and control block for the depositor's Assert output.\n *\n * Used to build the depositor's Payout PSBT (depositor-as-claimer path).\n *\n * @param params - Assert Payout/NoPayout connector parameters\n * @returns Payout script and control block (hex encoded)\n */\nexport async function getAssertPayoutScriptInfo(\n  params: AssertPayoutNoPayoutConnectorParams,\n): Promise<AssertPayoutScriptInfo> {\n  return (await loadTbvWasm()).getAssertPayoutScriptInfo(params);\n}\n\n/**\n * Get the NoPayout script and control block for a specific challenger.\n *\n * Used to build the depositor's NoPayout PSBT (depositor-as-claimer path).\n * Each challenger has a distinct NoPayout script.\n *\n * @param params - Assert Payout/NoPayout connector parameters\n * @param challengerPubkey - The challenger's x-only public key (hex encoded)\n * @returns NoPayout script and control block (hex encoded)\n */\nexport async function getAssertNoPayoutScriptInfo(\n  params: AssertPayoutNoPayoutConnectorParams,\n  challengerPubkey: string,\n): Promise<AssertNoPayoutScriptInfo> {\n  return (await loadTbvWasm()).getAssertNoPayoutScriptInfo(\n    params,\n    challengerPubkey,\n  );\n}\n\n/**\n * Get the ChallengeAssert script and control block.\n *\n * Used to build ChallengeAssert PSBTs for the depositor-as-claimer path.\n * Each challenger has 3 ChallengeAssert transactions, and this connector\n * generates the spending scripts using WOTS public keys from the VP.\n *\n * @param params - ChallengeAssert connector parameters\n * @returns Script and control block (hex encoded)\n */\nexport async function getChallengeAssertScriptInfo(\n  params: ChallengeAssertConnectorParams,\n): Promise<ChallengeAssertScriptInfo> {\n  return (await loadTbvWasm()).getChallengeAssertScriptInfo(params);\n}\n\n/**\n * Derive 32-byte `authAnchor` (OP_RETURN preimage → VP bearer token).\n * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.\n */\n/**\n * Derive 32-byte `authAnchor` (OP_RETURN preimage → VP bearer token).\n * @stability frozen — owned by btc-vault Rust via the vault-wasm pin (`VAULT_WASM_COMMIT`); rotation breaks VP auth for existing deposits.\n */\nexport async function expandAuthAnchor(root: Uint8Array): Promise<Uint8Array> {\n  return (await loadTbvWasm()).expandAuthAnchor(root);\n}\n\n/**\n * Derive 32-byte `hashlockSecret` for HTLC `htlcVout` (preimage → `activateVaultWithSecret`).\n * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.\n */\n/**\n * Derive 32-byte `hashlockSecret` for HTLC `htlcVout` (preimage → `activateVaultWithSecret`).\n * @stability frozen — owned by btc-vault Rust; rotation means affected vaults can never activate.\n */\nexport async function expandHashlockSecret(\n  root: Uint8Array,\n  htlcVout: number,\n): Promise<Uint8Array> {\n  return (await loadTbvWasm()).expandHashlockSecret(root, htlcVout);\n}\n\n/**\n * Derive 64-byte `wotsSeed` for HTLC `htlcVout` (→ WOTS keys, hashed as `depositorWotsPkHash`).\n * @stability frozen — forwards the frozen expander in `@babylonlabs-io/babylon-tbv-rust-wasm`; see CLAUDE.md §4.\n */\n/**\n * Derive 64-byte `wotsSeed` for HTLC `htlcVout` (→ WOTS keys, hashed as `depositorWotsPkHash`).\n * @stability frozen — owned by btc-vault Rust; rotation breaks existing `depositorWotsPkHash` → no claim path.\n */\nexport async function expandWotsSeed(\n  root: Uint8Array,\n  htlcVout: number,\n): Promise<Uint8Array> {\n  return (await loadTbvWasm()).expandWotsSeed(root, htlcVout);\n}\n\n/**\n * Derives the vault ID from a PegIn transaction hash and depositor ETH address.\n *\n * Vault ID = keccak256(abi.encode(peginTxHash, depositor))\n * This matches the Solidity-side derivation in BTCVaultRegistry.\n *\n * @param peginTxHash - 32-byte PegIn tx hash in display order (big-endian), hex encoded\n * @param depositor - 20-byte Ethereum address of the depositor, hex encoded\n * @returns Hex-encoded vault ID (32 bytes)\n */\nexport async function deriveVaultId(\n  peginTxHash: string,\n  depositor: string,\n): Promise<string> {\n  return (await loadTbvWasm()).deriveVaultId(peginTxHash, depositor);\n}\n\nexport type {\n  AssertNoPayoutScriptInfo,\n  AssertPayoutNoPayoutConnectorParams,\n  AssertPayoutScriptInfo,\n  ChallengeAssertConnectorParams,\n  ChallengeAssertScriptInfo,\n  HtlcConnectorInfo,\n  HtlcConnectorParams,\n  Network,\n  PayoutConnectorInfo,\n  PayoutConnectorParams,\n  PeginP2aAnchorInfo,\n  PeginTxResult,\n  PrePeginParams,\n  PrePeginResult,\n};\n"],"names":["TAP_INTERNAL_KEY","tapInternalPubkey","_","index","wasmModulePromise","rawWasmModulePromise","loadTbvWasm","error","loadRawTbvWasm","wasm","createPrePeginTransaction","params","buildPeginTxFromPrePegin","timelockPegin","fundedPrePeginTxHex","htlcVout","getPrePeginHtlcConnectorInfo","computeMinClaimValue","txGraphVersion","numLocalChallengers","numUniversalChallengers","councilQuorum","councilSize","feeRate","computeMinPeginFee","numVks","numUcs","minPeginFeeRate","computePayoutFeeFloor","numVaultKeepers","out0Len","out1Len","supportedTxGraphVersions","peginP2aAnchorOutput","validatePeginP2aAnchor","txHex","createPayoutConnector","network","getAssertPayoutScriptInfo","getAssertNoPayoutScriptInfo","challengerPubkey","getChallengeAssertScriptInfo","expandAuthAnchor","root","expandHashlockSecret","expandWotsSeed","deriveVaultId","peginTxHash","depositor"],"mappings":"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"}

package/dist/tbv/core/wasm/value-guards.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Runtime guard for satoshi amounts crossing into the WASM FFI boundary.
+ *
+ * `new BigUint64Array(values)` is the only way satoshi amounts are handed to
+ * the constructor, and a runtime cast (`as readonly bigint[]`) lets a caller
+ * pass a non-bigint or non-positive element that `BigUint64Array` would either
+ * reject cryptically or, in its length-arg form, silently zero-fill. Values
+ * above the u64 maximum are worse still: `BigUint64Array` wraps them mod 2^64
+ * without complaint, turning an oversized amount into a small one.
+ * {@link assertPositiveBigintArray} validates such inputs before the
+ * typed-array construction.
+ *
+ * Mirrors the `assertPositiveBigintArray` half of `value-guards.ts` in
+ * `@babylonlabs-io/babylon-tbv-rust-wasm`; that one function is pinned to the
+ * engine's source copy by `__tests__/value-guards.test.ts`. The engine's other
+ * guard, `assertWasmBigint`, has no counterpart here: the engine applies it to
+ * its own WASM return values before they reach this package.
+ */
+/**
+ * Assert a value is a non-empty array of strictly-positive `bigint`s and return
+ * it narrowed, ready to feed into `new BigUint64Array(...)`.
+ *
+ * @param values - The candidate array of satoshi amounts.
+ * @param label - Human-readable name used in the thrown error.
+ * @throws If `values` is not an array, is empty, or contains any element that is
+ *   not a `bigint`, is not strictly greater than 0, or exceeds the u64 maximum
+ *   (which `BigUint64Array` would otherwise wrap mod 2^64).
+ */
+export declare function assertPositiveBigintArray(values: unknown, label: string): bigint[];
+//# sourceMappingURL=value-guards.d.ts.map

package/dist/tbv/core/wasm/value-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-guards.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/wasm/value-guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CA2BV"}