@babylonlabs-io/ts-sdk 0.56.1 → 0.57.0

package/dist/{PayoutManager-BVgmuKuK.js → signPsbtsWithFallback-CzZFZf0I.js}

@@ -1,23 +1,23 @@
-var m = Object.defineProperty;
-var E = (e, t, r) => t in e ? m(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var h = (e, t, r) => E(e, typeof t != "symbol" ? t + "" : t, r);
-import * as T from "bitcoinjs-lib";
-import { s as v, v as p } from "./bitcoin-B5aNKtsk.js";
+var B = Object.defineProperty;
+var E = (e, t, r) => t in e ? B(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var p = (e, t, r) => E(e, typeof t != "symbol" ? t + "" : t, r);
+import * as w from "bitcoinjs-lib";
+import { s as S, v as h } from "./bitcoin-B5aNKtsk.js";
 import { s as R } from "./sha2-BYVxyZzX.js";
 import "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { c as b, d as y, e as x, f } from "./verifyScriptPathSchnorrSignature-CgrnAjMW.js";
+import { c as b, d as y, e as x, f } from "./verifyScriptPathSchnorrSignature-Xoo9DOHW.js";
 import { c as d } from "./signing-DaLvGwQe.js";
-const H = 106, B = 32, g = 34;
-function C(e, t, r) {
-  const s = v(e), o = T.Transaction.fromHex(s);
-  if (o.outs.length <= t)
+const m = 106, T = 32, l = 34;
+function A(e, t, r) {
+  const o = S(e), n = w.Transaction.fromHex(o);
+  if (n.outs.length <= t)
     throw new Error(
-      `Pre-PegIn auth-anchor OP_RETURN missing: tx has ${o.outs.length} outputs, expected at least ${t + 1} (vault outputs + OP_RETURN)`
+      `Pre-PegIn auth-anchor OP_RETURN missing: tx has ${n.outs.length} outputs, expected at least ${t + 1} (vault outputs + OP_RETURN)`
     );
-  const c = o.outs[t], i = c.script;
-  if (i.length !== g || i[0] !== H || i[1] !== B)
+  const c = n.outs[t], i = c.script;
+  if (i.length !== l || i[0] !== m || i[1] !== T)
     throw new Error(
-      `Pre-PegIn auth-anchor OP_RETURN at vout ${t} has unexpected script encoding (got ${i.length}-byte script with prefix 0x${i.slice(0, Math.min(2, i.length)).toString("hex")}; expected ${g}-byte OP_RETURN + PUSH32 layout)`
+      `Pre-PegIn auth-anchor OP_RETURN at vout ${t} has unexpected script encoding (got ${i.length}-byte script with prefix 0x${i.slice(0, Math.min(2, i.length)).toString("hex")}; expected ${l}-byte OP_RETURN + PUSH32 layout)`
     );
   const a = i.slice(2).toString("hex").toLowerCase();
   if (a !== r.toLowerCase())
@@ -32,22 +32,22 @@ function C(e, t, r) {
 function D(e) {
   let t;
   try {
-    t = T.Transaction.fromHex(v(e));
+    t = w.Transaction.fromHex(S(e));
   } catch {
     return;
   }
   const r = [];
-  for (let s = 0; s < t.outs.length; s++) {
-    const o = t.outs[s], c = o.script;
-    c.length === g && c[0] === H && c[1] === B && o.value === 0 && r.push({
-      vout: s,
+  for (let o = 0; o < t.outs.length; o++) {
+    const n = t.outs[o], c = n.script;
+    c.length === l && c[0] === m && c[1] === T && n.value === 0 && r.push({
+      vout: o,
       hash: c.slice(2).toString("hex").toLowerCase()
     });
   }
   return r.length === 1 ? r[0] : void 0;
 }
-const w = 66;
-function S(e) {
+const k = 66;
+function H(e) {
   if (!e.startsWith("0x") && !e.startsWith("0X"))
     throw new Error("Expected 0x-prefixed hex string");
   const t = e.slice(2);
@@ -56,58 +56,42 @@ function S(e) {
   if (!/^[0-9a-fA-F]*$/.test(t))
     throw new Error("Hex string contains non-hex characters");
   const r = new Uint8Array(t.length / 2);
-  for (let s = 0; s < r.length; s++)
-    r[s] = parseInt(t.slice(s * 2, s * 2 + 2), 16);
+  for (let o = 0; o < r.length; o++)
+    r[o] = parseInt(t.slice(o * 2, o * 2 + 2), 16);
   return r;
 }
 function $(e) {
   return `0x${Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("")}`;
 }
-function P(e, t) {
-  if (e.length !== w)
+function g(e, t) {
+  if (e.length !== k)
     throw new Error(
-      `${t} must be exactly 32 bytes (${w} hex chars with 0x prefix), got ${e.length}`
+      `${t} must be exactly 32 bytes (${k} hex chars with 0x prefix), got ${e.length}`
     );
 }
-function O(e) {
-  P(e, "Secret");
-  const t = S(e), r = R(t);
+function K(e) {
+  g(e, "Secret");
+  const t = H(e), r = R(t);
   return $(r);
 }
 function L(e, t) {
-  return P(e, "Secret"), P(t, "Hashlock"), S(t), O(e).toLowerCase() === t.toLowerCase();
-}
-async function F(e, t, r) {
-  if (t.length === 1)
-    return [await e.signPsbt(t[0], r == null ? void 0 : r[0])];
-  if (typeof e.signPsbts == "function") {
-    const o = await e.signPsbts(t, r);
-    if (o.length !== t.length)
-      throw new Error(
-        `Expected ${t.length} signed PSBTs but received ${o.length}`
-      );
-    return o;
-  }
-  const s = [];
-  for (let o = 0; o < t.length; o++)
-    s.push(await e.signPsbt(t[o], r == null ? void 0 : r[o]));
-  return s;
+  return g(e, "Secret"), g(t, "Hashlock"), H(t), K(e).toLowerCase() === t.toLowerCase();
 }
-function _(e) {
+function O(e) {
   return typeof e.approveDepositTerms == "function";
 }
-function z(e) {
-  return _(e) ? { approveDepositTerms: (t) => e.approveDepositTerms(t) } : {};
+function F(e) {
+  return O(e) ? { approveDepositTerms: (t) => e.approveDepositTerms(t) } : {};
 }
-const k = 0;
-class X {
+const v = 0;
+class z {
   /**
    * Creates a new PayoutManager instance.
    *
    * @param config - Manager configuration including wallet
    */
   constructor(t) {
-    h(this, "config");
+    p(this, "config");
     this.config = t;
   }
   /**
@@ -133,15 +117,15 @@ class X {
    * @throws Error if wallet operations fail or signature extraction fails
    */
   async signPayoutTransaction(t) {
-    const r = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: s } = p(
+    const r = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: o } = h(
       r,
       t.depositorBtcPubkey
-    ), o = await b({
+    ), n = await b({
       vaultCoreVersion: t.vaultCoreVersion,
       payoutTxHex: t.payoutTxHex,
       peginTxHex: t.peginTxHex,
       assertTxHex: t.assertTxHex,
-      depositorBtcPubkey: s,
+      depositorBtcPubkey: o,
       vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
       vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
       universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
@@ -151,24 +135,26 @@ class X {
       registeredPayoutScriptPubKey: t.registeredPayoutScriptPubKey,
       commissionBps: t.commissionBps,
       protocolFeeRate: t.protocolFeeRate,
-      councilSize: t.councilSize
+      councilSize: t.councilSize,
+      vkClaimerPayoutScriptPubKeys: t.vkClaimerPayoutScriptPubKeys,
+      vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
     }), c = await this.config.btcWallet.signPsbt(
-      o.psbtHex,
+      n.psbtHex,
       d(r, 1)
     );
     y({
-      requestedPsbtHex: o.psbtHex,
+      requestedPsbtHex: n.psbtHex,
       returnedPsbtHex: c
     });
-    const i = x(c, s);
+    const i = x(c, o);
     return f({
-      requestedPsbtHex: o.psbtHex,
+      requestedPsbtHex: n.psbtHex,
       signatureHex: i,
-      signerXOnlyPubkeyHex: s,
-      inputIndex: k
+      signerXOnlyPubkeyHex: o,
+      inputIndex: v
     }), {
       signature: i,
-      depositorBtcPubkey: s
+      depositorBtcPubkey: o
     };
   }
   /**
@@ -201,72 +187,90 @@ class X {
       throw new Error(
         "Wallet does not support batch signing (signPsbts method not available)"
       );
-    const r = await this.config.btcWallet.getPublicKeyHex(), s = [], o = [], c = [];
-    for (const n of t) {
-      const { depositorPubkey: u } = p(
+    const r = await this.config.btcWallet.getPublicKeyHex(), o = [], n = [], c = [];
+    for (const s of t) {
+      const { depositorPubkey: u } = h(
         r,
-        n.depositorBtcPubkey
+        s.depositorBtcPubkey
       );
       c.push(u);
-      const l = await b({
-        vaultCoreVersion: n.vaultCoreVersion,
-        payoutTxHex: n.payoutTxHex,
-        peginTxHex: n.peginTxHex,
-        assertTxHex: n.assertTxHex,
+      const P = await b({
+        vaultCoreVersion: s.vaultCoreVersion,
+        payoutTxHex: s.payoutTxHex,
+        peginTxHex: s.peginTxHex,
+        assertTxHex: s.assertTxHex,
         depositorBtcPubkey: u,
-        vaultProviderBtcPubkey: n.vaultProviderBtcPubkey,
-        vaultKeeperBtcPubkeys: n.vaultKeeperBtcPubkeys,
-        universalChallengerBtcPubkeys: n.universalChallengerBtcPubkeys,
-        timelockPegin: n.timelockPegin,
+        vaultProviderBtcPubkey: s.vaultProviderBtcPubkey,
+        vaultKeeperBtcPubkeys: s.vaultKeeperBtcPubkeys,
+        universalChallengerBtcPubkeys: s.universalChallengerBtcPubkeys,
+        timelockPegin: s.timelockPegin,
         network: this.config.network,
-        claimerBtcPubkey: n.claimerBtcPubkey,
-        registeredPayoutScriptPubKey: n.registeredPayoutScriptPubKey,
-        commissionBps: n.commissionBps,
-        protocolFeeRate: n.protocolFeeRate,
-        councilSize: n.councilSize
+        claimerBtcPubkey: s.claimerBtcPubkey,
+        registeredPayoutScriptPubKey: s.registeredPayoutScriptPubKey,
+        commissionBps: s.commissionBps,
+        protocolFeeRate: s.protocolFeeRate,
+        councilSize: s.councilSize,
+        vkClaimerPayoutScriptPubKeys: s.vkClaimerPayoutScriptPubKeys,
+        vpCommissionScriptPubKey: s.vpCommissionScriptPubKey
       });
-      s.push(l.psbtHex), o.push(d(r, 1));
+      o.push(P.psbtHex), n.push(d(r, 1));
     }
     const i = await this.config.btcWallet.signPsbts(
-      s,
-      o
+      o,
+      n
     );
     if (i.length !== t.length)
       throw new Error(
         `Expected ${t.length} signed PSBTs but received ${i.length}`
       );
     const a = [];
-    for (let n = 0; n < t.length; n++) {
-      const u = c[n];
+    for (let s = 0; s < t.length; s++) {
+      const u = c[s];
       y({
-        requestedPsbtHex: s[n],
-        returnedPsbtHex: i[n]
+        requestedPsbtHex: o[s],
+        returnedPsbtHex: i[s]
       });
-      const l = x(
-        i[n],
+      const P = x(
+        i[s],
         u
       );
       f({
-        requestedPsbtHex: s[n],
-        signatureHex: l,
+        requestedPsbtHex: o[s],
+        signatureHex: P,
         signerXOnlyPubkeyHex: u,
-        inputIndex: k
+        inputIndex: v
       }), a.push({
-        payoutSignature: l,
+        payoutSignature: P,
         depositorBtcPubkey: u
       });
     }
     return a;
   }
 }
+async function X(e, t, r) {
+  if (t.length === 1)
+    return [await e.signPsbt(t[0], r == null ? void 0 : r[0])];
+  if (typeof e.signPsbts == "function") {
+    const n = await e.signPsbts(t, r);
+    if (n.length !== t.length)
+      throw new Error(
+        `Expected ${t.length} signed PSBTs but received ${n.length}`
+      );
+    return n;
+  }
+  const o = [];
+  for (let n = 0; n < t.length; n++)
+    o.push(await e.signPsbt(t[n], r == null ? void 0 : r[n]));
+  return o;
+}
 export {
-  X as P,
-  C as a,
-  F as b,
-  O as c,
+  z as P,
+  A as a,
+  X as b,
+  K as c,
   D as d,
-  z as f,
-  _ as s,
+  F as f,
+  O as s,
   L as v
 };
-//# sourceMappingURL=PayoutManager-BVgmuKuK.js.map
+//# sourceMappingURL=signPsbtsWithFallback-CzZFZf0I.js.map

package/dist/signPsbtsWithFallback-CzZFZf0I.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signPsbtsWithFallback-CzZFZf0I.js","sources":["../src/tbv/core/managers/pegin/assertAuthAnchorOpReturn.ts","../src/tbv/core/services/htlc/index.ts","../src/tbv/core/deposit-terms/depositTerms.ts","../src/tbv/core/managers/PayoutManager.ts","../src/tbv/core/managers/pegin/signPsbtsWithFallback.ts"],"sourcesContent":["/**\n * Structural verifier for the auth-anchor OP_RETURN in a funded\n * Pre-PegIn transaction.\n *\n * @module managers/pegin/assertAuthAnchorOpReturn\n */\n\nimport * as bitcoin from \"bitcoinjs-lib\";\n\nimport { stripHexPrefix } from \"../../primitives/utils/bitcoin\";\n\n/** OP_RETURN opcode. */\nconst OP_RETURN = 0x6a;\n/** Push-32-bytes opcode (raw push, not OP_PUSHDATA1). */\nconst OP_PUSH32 = 0x20;\n/** Encoded length of a standard OP_RETURN script with a 32-byte payload. */\nconst OP_RETURN_PUSH32_SCRIPT_LEN = 1 + 1 + 32;\n\n/**\n * Verify the broadcast Pre-PegIn carries the expected OP_RETURN\n * commitment to the auth anchor.\n *\n * The OP_RETURN sits at `vout = vaultCount` (right after the per-vault\n * HTLC outputs and before the depositor-claim/change outputs) and\n * pushes the 32-byte `SHA256(authAnchor)`. The script encoding is\n * exactly `OP_RETURN || PUSH32 || <32 bytes>` (34 bytes). A\n * non-conformant WASM build that omitted the OP_RETURN, swapped its\n * position, or changed its push payload would let the depositor\n * obtain a valid bearer token for a Pre-PegIn whose on-chain\n * commitment doesn't actually bind the anchor — degrading the auth\n * from on-chain-bound to a shared secret. Fail closed.\n *\n * @throws If the OP_RETURN is missing, mis-located, mis-encoded, or\n *         pushes a payload other than `expectedAuthAnchorHashHex`.\n */\nexport function assertAuthAnchorOpReturn(\n  fundedPrePeginTxHex: string,\n  vaultCount: number,\n  expectedAuthAnchorHashHex: string,\n): void {\n  const cleanHex = stripHexPrefix(fundedPrePeginTxHex);\n  const tx = bitcoin.Transaction.fromHex(cleanHex);\n\n  if (tx.outs.length <= vaultCount) {\n    throw new Error(\n      `Pre-PegIn auth-anchor OP_RETURN missing: tx has ${tx.outs.length} ` +\n        `outputs, expected at least ${vaultCount + 1} (vault outputs + OP_RETURN)`,\n    );\n  }\n\n  const opReturnOutput = tx.outs[vaultCount];\n  const script = opReturnOutput.script;\n  if (\n    script.length !== OP_RETURN_PUSH32_SCRIPT_LEN ||\n    script[0] !== OP_RETURN ||\n    script[1] !== OP_PUSH32\n  ) {\n    throw new Error(\n      `Pre-PegIn auth-anchor OP_RETURN at vout ${vaultCount} has unexpected ` +\n        `script encoding (got ${script.length}-byte script with prefix ` +\n        `0x${script.slice(0, Math.min(2, script.length)).toString(\"hex\")}; ` +\n        `expected ${OP_RETURN_PUSH32_SCRIPT_LEN}-byte OP_RETURN + PUSH32 layout)`,\n    );\n  }\n\n  const pushedHex = script.slice(2).toString(\"hex\").toLowerCase();\n  if (pushedHex !== expectedAuthAnchorHashHex.toLowerCase()) {\n    throw new Error(\n      `Pre-PegIn auth-anchor OP_RETURN payload mismatch at vout ${vaultCount}: ` +\n        `tx pushes ${pushedHex}, expected ${expectedAuthAnchorHashHex}`,\n    );\n  }\n\n  if (opReturnOutput.value !== 0) {\n    throw new Error(\n      `Pre-PegIn auth-anchor OP_RETURN at vout ${vaultCount} has non-zero ` +\n        `value ${opReturnOutput.value}; OP_RETURN outputs must be 0-value`,\n    );\n  }\n}\n\n/**\n * Scan a funded Pre-PegIn transaction for its auth-anchor commitment\n * (an `OP_RETURN || PUSH32 || <32 bytes>` output with value 0).\n *\n * Returns `{ vout, hash }` when exactly one such output is found.\n * Returns `undefined` when:\n *   - the hex is unparseable,\n *   - no matching output exists (legacy non-auth-anchored Pre-PegIn),\n *   - more than one matching output exists (ambiguous / malformed).\n *\n * Used by the refund orchestrator to (a) locate the on-chain anchor\n * regardless of how many HTLCs preceded it and (b) detect multi-vault\n * funded transactions structurally: the single-vault refund path\n * reconstructs only one hashlock and expects the anchor at vout 1, so\n * any other vout signals a layout this call cannot safely refund.\n */\nexport function findAuthAnchorOpReturn(\n  fundedPrePeginTxHex: string,\n): { vout: number; hash: string } | undefined {\n  let tx: bitcoin.Transaction;\n  try {\n    tx = bitcoin.Transaction.fromHex(stripHexPrefix(fundedPrePeginTxHex));\n  } catch {\n    return undefined;\n  }\n\n  const hits: { vout: number; hash: string }[] = [];\n  for (let i = 0; i < tx.outs.length; i++) {\n    const output = tx.outs[i];\n    const script = output.script;\n    if (\n      script.length === OP_RETURN_PUSH32_SCRIPT_LEN &&\n      script[0] === OP_RETURN &&\n      script[1] === OP_PUSH32 &&\n      output.value === 0\n    ) {\n      hits.push({\n        vout: i,\n        hash: script.slice(2).toString(\"hex\").toLowerCase(),\n      });\n    }\n  }\n\n  return hits.length === 1 ? hits[0] : undefined;\n}\n","/**\n * HTLC Secret / Hashlock Utilities\n *\n * Pure functions for computing and validating SHA-256 hashlocks used in the\n * vault deposit protocol's HTLC (Hash Time Lock Contract).\n *\n * The SDK does NOT generate secrets — that is the caller's responsibility.\n * Today callers use `crypto.getRandomValues(32)`; when the `deriveContextHash`\n * wallet API ships, callers will use `wallet.deriveContextHash(\"babylon-btc-vault\", ctx)`.\n * These utilities work identically regardless of how the secret was produced.\n *\n * On-chain contract validation (BTCVaultRegistry.activateVaultWithSecret):\n *   if (sha256(abi.encodePacked(s)) != hashlock) revert InvalidSecret();\n *\n * @module htlc\n */\n\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport type { Hex } from \"viem\";\n\n/** Expected hex length for a 0x-prefixed bytes32 value. */\nconst HEX_BYTES32_LENGTH = 66; // \"0x\" + 64 hex chars\n\n/**\n * Decode a 0x-prefixed hex string to bytes, with strict validation.\n * @throws if the input is not a valid 0x-prefixed hex string\n */\nfunction hexToBytes(hex: Hex): Uint8Array {\n  if (!hex.startsWith(\"0x\") && !hex.startsWith(\"0X\")) {\n    throw new Error(\"Expected 0x-prefixed hex string\");\n  }\n  const clean = hex.slice(2);\n  if (clean.length % 2 !== 0) {\n    throw new Error(`Hex string has odd length: ${clean.length}`);\n  }\n  if (!/^[0-9a-fA-F]*$/.test(clean)) {\n    throw new Error(\"Hex string contains non-hex characters\");\n  }\n  const bytes = new Uint8Array(clean.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);\n  }\n  return bytes;\n}\n\n/**\n * Encode a Uint8Array as a 0x-prefixed lowercase hex string.\n */\nfunction bytesToHex(bytes: Uint8Array): Hex {\n  return `0x${Array.from(bytes)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\")}`;\n}\n\n/**\n * Validate that a value is a 0x-prefixed bytes32 (exactly 32 bytes).\n * @throws if the value is not exactly 32 bytes\n */\nfunction assertBytes32(value: Hex, label: string): void {\n  if (value.length !== HEX_BYTES32_LENGTH) {\n    throw new Error(\n      `${label} must be exactly 32 bytes (${HEX_BYTES32_LENGTH} hex chars with 0x prefix), got ${value.length}`,\n    );\n  }\n}\n\n/**\n * Compute the SHA-256 hashlock from a secret preimage.\n *\n * Matches the on-chain validation: `sha256(abi.encodePacked(s))` where `s` is a `bytes32`.\n * `abi.encodePacked(bytes32)` is just the raw 32 bytes — no ABI padding.\n *\n * @param secret - 0x-prefixed bytes32 secret (66 hex chars)\n * @returns 0x-prefixed bytes32 SHA-256 hash\n * @throws if secret is not exactly 32 bytes\n */\nexport function computeHashlock(secret: Hex): Hex {\n  assertBytes32(secret, \"Secret\");\n  const secretBytes = hexToBytes(secret);\n  const hash = sha256(secretBytes);\n  return bytesToHex(hash);\n}\n\n/**\n * Validate that a secret's SHA-256 hash matches the expected hashlock.\n *\n * Use this for client-side pre-validation before sending the activation\n * transaction to avoid wasting gas on a contract revert.\n *\n * @param secret - 0x-prefixed bytes32 secret (66 hex chars)\n * @param hashlock - 0x-prefixed bytes32 expected hashlock from the vault\n * @returns true if SHA-256(secret) matches the hashlock\n * @throws if secret or hashlock is not exactly 32 bytes\n */\nexport function validateSecretAgainstHashlock(\n  secret: Hex,\n  hashlock: Hex,\n): boolean {\n  assertBytes32(secret, \"Secret\");\n  assertBytes32(hashlock, \"Hashlock\");\n  // Validate hashlock is valid hex (secret is validated inside computeHashlock)\n  hexToBytes(hashlock);\n\n  const computed = computeHashlock(secret);\n  return computed.toLowerCase() === hashlock.toLowerCase();\n}\n","import type { BitcoinWallet } from \"../../../shared/wallets/interfaces\";\n\n// Field docs use /** */ so they survive into the emitted .d.ts — the published\n// package is the only contract the external provider author (#2109) sees.\n\nexport interface DepositTermsVaultGroup {\n  /** 0-based; equals the group's position (groups are ascending by vout). */\n  readonly htlcVout: number;\n  /** x-only hex (64 chars), as validated on-chain upstream. */\n  readonly vaultProviderPk: string;\n  /** sats */\n  readonly vaultAmount: bigint;\n  /** sats; floor(vaultAmount * commissionBps / 10_000). */\n  readonly commissionFee: bigint;\n  /** sats; the same value for every vault. */\n  readonly depositorClaimValue: bigint;\n  /** sats; the minimum PegIn fee for this graph version. */\n  readonly peginMaxFee: bigint;\n}\n\nexport interface DepositTerms {\n  /**\n   * sat/vB; the tx-graph fee rate (protocolFeeRate), NOT the mempool funding\n   * rate. An approving wallet bounds each payout's fee at baseFeeRate x a\n   * conservative vsize estimate (v22 §4.9.7.1) — pass the exact graph rate,\n   * not an inflated ceiling.\n   */\n  baseFeeRate: bigint;\n  /** Vault-UTXO CSV timelock (blocks). */\n  peginCsvTimelock: number;\n  /**\n   * Payout timelock on the Assert transaction's output 0; comes from the same\n   * protocol param (timelockAssert) as peginCsvTimelock.\n   */\n  payoutTimelock: number;\n  /** HTLC refund CSV timelock (blocks). */\n  htlcRefundTimelock: number;\n  /**\n   * 64-char hex in display order. A device-wire encoder must byte-reverse it to\n   * the little-endian form the device recomputes and compares against.\n   */\n  prepeginTxid: string;\n  /** sats; the funded Pre-PegIn fee (an approving wallet caps the signed fee at this). */\n  prepeginMaxFee: bigint;\n  /**\n   * x-only hex. Sorted ascending by the upstream on-chain validation\n   * (validateOnChainParticipantKeys); the builder passes them through\n   * unasserted — the device rejects unsorted lists at intent load.\n   */\n  keeperPks: readonly string[];\n  /**\n   * x-only hex, sorted ascending upstream independently of keeperPks (same\n   * pass-through contract). Universal challengers only — the full graph\n   * challenger set is keeperPks ∪ challengerPks (vault keepers are the local\n   * challengers).\n   */\n  challengerPks: readonly string[];\n  /** Per-vault groups, ordered by ascending htlcVout. */\n  vaults: readonly DepositTermsVaultGroup[];\n}\n\n/**\n * Implemented only by depositor-approval wallets (e.g. a Ledger vault provider).\n * Either a class field or a prototype method works — the deposit flow spreads\n * the wallet object but forwards this method explicitly at every wrapper site.\n *\n * Seam invariant: never call deriveContextHash between approveDepositTerms and\n * the last terms-bound signature of a connection — deriving while an intent is\n * loaded nullifies it on-device. Design: the SDK owns approval (mirrors its\n * deriveContextHash/signPsbts orchestration); provider-internal and app-driven\n * placements were rejected.\n */\nexport interface DepositTermsApprover {\n  approveDepositTerms(terms: DepositTerms): Promise<void>;\n}\n\n/** True when the wallet implements {@link DepositTermsApprover.approveDepositTerms}. */\nexport function supportsDepositApproval(\n  wallet: BitcoinWallet,\n): wallet is BitcoinWallet & DepositTermsApprover {\n  return typeof (wallet as Partial<DepositTermsApprover>).approveDepositTerms === \"function\";\n}\n\n/**\n * Spreadable forward of `approveDepositTerms` for wallet-wrapper objects.\n * Object spread drops prototype methods, so every `{...wallet}` wrapper site\n * must re-attach the capability explicitly: `...forwardDepositApproval(wallet)`.\n */\nexport function forwardDepositApproval(\n  wallet: BitcoinWallet,\n): Partial<DepositTermsApprover> {\n  return supportsDepositApproval(wallet)\n    ? { approveDepositTerms: (terms) => wallet.approveDepositTerms(terms) }\n    : {};\n}\n\nexport interface BuildDepositTermsInputs {\n  protocolFeeRate: bigint;\n  timelockPegin: number;\n  timelockRefund: number;\n  prepeginTxid: string;\n  prepeginMaxFee: bigint;\n  vaultProviderPk: string;\n  keeperPks: readonly string[];\n  challengerPks: readonly string[];\n  commissionBps: number;\n  vaultAmounts: readonly bigint[];\n  depositorClaimValue: bigint;\n  peginMaxFee: bigint;\n}\n","/**\n * Payout Manager\n *\n * High-level manager that orchestrates the payout signing flow by coordinating\n * SDK primitives ({@link buildPayoutPsbt}, {@link extractPayoutSignature})\n * with a user-provided Bitcoin wallet.\n *\n * The Payout transaction references the Assert transaction (input 1).\n *\n * @see {@link PeginManager} - For Steps 1–4 of the peg-in flow\n * @see {@link buildPayoutPsbt} - Lower-level primitive for custom implementations\n * @see {@link extractPayoutSignature} - Extract signatures from signed PSBTs\n *\n * @module managers/PayoutManager\n */\n\nimport type { BitcoinWallet, SignPsbtOptions } from \"../../../shared/wallets\";\nimport {\n  assertPsbtUnsignedTxMatches,\n  assertScriptPathSchnorrSignature,\n  buildPayoutPsbt,\n  extractPayoutSignature,\n  validateWalletPubkey,\n  type Network,\n} from \"../primitives\";\nimport { createTaprootScriptPathSignOptions } from \"../utils/signing\";\n\n/** Payout PSBTs are signed by the depositor on input 0 (Taproot script-path). */\nconst PAYOUT_SIGNED_INPUT_INDEX = 0;\n\n/**\n * Configuration for the PayoutManager.\n */\nexport interface PayoutManagerConfig {\n  /**\n   * Bitcoin network to use for transactions.\n   */\n  network: Network;\n\n  /**\n   * Bitcoin wallet for signing payout transactions.\n   */\n  btcWallet: BitcoinWallet;\n}\n\n/**\n * Base parameters shared by both payout transaction types.\n */\ninterface SignPayoutBaseParams {\n  /**\n   * Vault core (tx-graph) version the vault was registered under — the\n   * vault's stamped on-chain `vaultCoreVersion`. Forwarded to\n   * {@link buildPayoutPsbt} to derive the matching graph's payout scripts.\n   */\n  vaultCoreVersion: number;\n\n  /**\n   * Peg-in transaction hex.\n   * The original transaction that created the vault output being spent.\n   */\n  peginTxHex: string;\n\n  /**\n   * Vault provider's BTC public key (x-only, 64-char hex).\n   */\n  vaultProviderBtcPubkey: string;\n\n  /**\n   * Vault keeper BTC public keys (x-only, 64-char hex).\n   */\n  vaultKeeperBtcPubkeys: string[];\n\n  /**\n   * Universal challenger BTC public keys (x-only, 64-char hex).\n   */\n  universalChallengerBtcPubkeys: string[];\n\n  /**\n   * CSV timelock in blocks for the PegIn output.\n   */\n  timelockPegin: number;\n\n  /**\n   * Depositor's BTC public key (x-only, 64-char hex). This MUST be the\n   * key registered on-chain for the vault — typically read from\n   * `BTCVaultRegistry.getBtcVaultBasicInfo(...).depositorBtcPubKey`.\n   *\n   * Required: omitting it would degrade `validateWalletPubkey` to a\n   * self-comparison, allowing the wrong wallet to produce a signature\n   * over a script tree that doesn't match the on-chain UTXO.\n   */\n  depositorBtcPubkey: string;\n\n  /**\n   * The on-chain registered depositor payout scriptPubKey (hex, with or without 0x prefix).\n   * Used to validate that the VP-provided payout transaction actually pays to the\n   * correct depositor payout address before signing.\n   */\n  registeredPayoutScriptPubKey: string;\n\n  /**\n   * The claimer's x-only BTC public key for this payout (64-char hex, no prefix).\n   * Forwarded to {@link buildPayoutPsbt} for per-role output validation.\n   */\n  claimerBtcPubkey: string;\n\n  /**\n   * VP commission in basis points (`1..=9999`). Forwarded to {@link buildPayoutPsbt}.\n   */\n  commissionBps: number;\n\n  /**\n   * Version-locked tx-graph fee rate (sat/vB) the graph was built with.\n   * Forwarded to {@link buildPayoutPsbt} for the fee band.\n   */\n  protocolFeeRate: bigint;\n\n  /** Security council member count; forwarded to the fee floor (see PayoutParams). */\n  councilSize: number;\n\n  /**\n   * RFC-006 resolved payout destinations, keyed by lowercased x-only operation\n   * pubkey. Forwarded verbatim to {@link buildPayoutPsbt}; every VK claimer\n   * must be present.\n   */\n  vkClaimerPayoutScriptPubKeys: Readonly<Record<string, string>>;\n  /** RFC-006 VP commission destination. Forwarded to {@link buildPayoutPsbt}. */\n  vpCommissionScriptPubKey: string;\n}\n\n/**\n * Parameters for signing a Payout transaction.\n *\n * Payout is used in the challenge path after Assert, when the claimer proves validity.\n * Input 1 references the Assert transaction.\n */\nexport interface SignPayoutParams extends SignPayoutBaseParams {\n  /**\n   * Payout transaction hex (unsigned).\n   * This is the transaction from the vault provider that needs depositor signature.\n   */\n  payoutTxHex: string;\n\n  /**\n   * Assert transaction hex.\n   * Payout input 1 references Assert output 0.\n   */\n  assertTxHex: string;\n}\n\n/**\n * Result of signing a payout transaction.\n */\nexport interface PayoutSignatureResult {\n  /**\n   * 64-byte Schnorr signature (128 hex characters).\n   */\n  signature: string;\n\n  /**\n   * Depositor's BTC public key used for signing.\n   */\n  depositorBtcPubkey: string;\n}\n\n/**\n * High-level manager for payout transaction signing.\n *\n * @remarks\n * After registering your peg-in on Ethereum (Step 3), the vault provider prepares\n * claim/payout transaction pairs. You must sign each payout transaction using this\n * manager and submit the signatures to the vault provider's RPC API.\n *\n * **What happens internally:**\n * 1. Validates your wallet's public key matches the vault's depositor\n * 2. Builds an unsigned PSBT with taproot script path spend info\n * 3. Signs input 0 (the vault UTXO) with your wallet\n * 4. Extracts the 64-byte Schnorr signature\n *\n * **Note:** The payout transaction has 2 inputs. PayoutManager only signs input 0\n * (from the peg-in tx). Input 1 (from the assert tx) is signed by the vault provider.\n *\n * @see {@link PeginManager} - For the complete peg-in flow context\n * @see {@link buildPayoutPsbt} - Lower-level primitive used internally\n * @see {@link extractPayoutSignature} - Signature extraction primitive\n */\nexport class PayoutManager {\n  private readonly config: PayoutManagerConfig;\n\n  /**\n   * Creates a new PayoutManager instance.\n   *\n   * @param config - Manager configuration including wallet\n   */\n  constructor(config: PayoutManagerConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Signs a Payout transaction and extracts the Schnorr signature.\n   *\n   * Flow:\n   * 1. Vault provider submits Claim transaction\n   * 2. Claimer submits Assert transaction to prove validity\n   * 3. Payout can be executed (references Assert tx)\n   *\n   * This method orchestrates the following steps:\n   * 1. Get wallet's public key and convert to x-only format\n   * 2. Validate wallet pubkey matches on-chain depositor pubkey (if provided)\n   * 3. Build unsigned PSBT using primitives\n   * 4. Sign PSBT via btcWallet.signPsbt()\n   * 5. Extract 64-byte Schnorr signature using primitives\n   *\n   * The returned signature can be submitted to the vault provider API.\n   *\n   * @param params - Payout signing parameters\n   * @returns Signature result with 64-byte Schnorr signature and depositor pubkey\n   * @throws Error if wallet pubkey doesn't match depositor pubkey\n   * @throws Error if wallet operations fail or signature extraction fails\n   */\n  async signPayoutTransaction(\n    params: SignPayoutParams,\n  ): Promise<PayoutSignatureResult> {\n    // Validate wallet pubkey matches depositor and get both formats\n    const walletPubkeyRaw = await this.config.btcWallet.getPublicKeyHex();\n    const { depositorPubkey } = validateWalletPubkey(\n      walletPubkeyRaw,\n      params.depositorBtcPubkey,\n    );\n\n    // Build unsigned PSBT for Payout (uses Assert tx). Per-role output\n    // validation happens inside buildPayoutPsbt against the resolved input\n    // values.\n    const payoutPsbt = await buildPayoutPsbt({\n      vaultCoreVersion: params.vaultCoreVersion,\n      payoutTxHex: params.payoutTxHex,\n      peginTxHex: params.peginTxHex,\n      assertTxHex: params.assertTxHex,\n      depositorBtcPubkey: depositorPubkey,\n      vaultProviderBtcPubkey: params.vaultProviderBtcPubkey,\n      vaultKeeperBtcPubkeys: params.vaultKeeperBtcPubkeys,\n      universalChallengerBtcPubkeys: params.universalChallengerBtcPubkeys,\n      timelockPegin: params.timelockPegin,\n      network: this.config.network,\n      claimerBtcPubkey: params.claimerBtcPubkey,\n      registeredPayoutScriptPubKey: params.registeredPayoutScriptPubKey,\n      commissionBps: params.commissionBps,\n      protocolFeeRate: params.protocolFeeRate,\n      councilSize: params.councilSize,\n      vkClaimerPayoutScriptPubKeys: params.vkClaimerPayoutScriptPubKeys,\n      vpCommissionScriptPubKey: params.vpCommissionScriptPubKey,\n    });\n\n    // Sign PSBT via wallet (Taproot script-path spend, input 0 only)\n    const signedPsbtHex = await this.config.btcWallet.signPsbt(\n      payoutPsbt.psbtHex,\n      createTaprootScriptPathSignOptions(walletPubkeyRaw, 1),\n    );\n\n    assertPsbtUnsignedTxMatches({\n      requestedPsbtHex: payoutPsbt.psbtHex,\n      returnedPsbtHex: signedPsbtHex,\n    });\n\n    // Extract Schnorr signature\n    const signature = extractPayoutSignature(signedPsbtHex, depositorPubkey);\n    // Critical Path #7: verify the signature against a sighash recomputed from\n    // the PSBT we built, not the wallet-returned one.\n    assertScriptPathSchnorrSignature({\n      requestedPsbtHex: payoutPsbt.psbtHex,\n      signatureHex: signature,\n      signerXOnlyPubkeyHex: depositorPubkey,\n      inputIndex: PAYOUT_SIGNED_INPUT_INDEX,\n    });\n\n    return {\n      signature,\n      depositorBtcPubkey: depositorPubkey,\n    };\n  }\n\n  /**\n   * Gets the configured Bitcoin network.\n   *\n   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)\n   */\n  getNetwork(): Network {\n    return this.config.network;\n  }\n\n  /**\n   * Checks if the wallet supports batch signing (signPsbts).\n   *\n   * @returns true if batch signing is supported\n   */\n  supportsBatchSigning(): boolean {\n    return typeof this.config.btcWallet.signPsbts === \"function\";\n  }\n\n  /**\n   * Batch signs multiple payout transactions (1 per claimer).\n   * This allows signing all transactions with a single wallet interaction.\n   *\n   * @param transactions - Array of payout params to sign\n   * @returns Array of signature results matching input order\n   * @throws Error if wallet doesn't support batch signing\n   * @throws Error if any signing operation fails\n   */\n  async signPayoutTransactionsBatch(transactions: SignPayoutParams[]): Promise<\n    Array<{\n      payoutSignature: string;\n      depositorBtcPubkey: string;\n    }>\n  > {\n    if (!this.supportsBatchSigning()) {\n      throw new Error(\n        \"Wallet does not support batch signing (signPsbts method not available)\",\n      );\n    }\n\n    // Get wallet pubkey once\n    const walletPubkeyRaw = await this.config.btcWallet.getPublicKeyHex();\n\n    // Build all PSBTs (1 per claimer)\n    const psbtsToSign: string[] = [];\n    const signOptions: SignPsbtOptions[] = [];\n    const depositorPubkeys: string[] = [];\n\n    for (const tx of transactions) {\n      // Validate wallet pubkey matches depositor\n      const { depositorPubkey } = validateWalletPubkey(\n        walletPubkeyRaw,\n        tx.depositorBtcPubkey,\n      );\n      depositorPubkeys.push(depositorPubkey);\n\n      // Build Payout PSBT (output validation runs inside buildPayoutPsbt\n      // against resolved input values).\n      const payoutPsbt = await buildPayoutPsbt({\n        vaultCoreVersion: tx.vaultCoreVersion,\n        payoutTxHex: tx.payoutTxHex,\n        peginTxHex: tx.peginTxHex,\n        assertTxHex: tx.assertTxHex,\n        depositorBtcPubkey: depositorPubkey,\n        vaultProviderBtcPubkey: tx.vaultProviderBtcPubkey,\n        vaultKeeperBtcPubkeys: tx.vaultKeeperBtcPubkeys,\n        universalChallengerBtcPubkeys: tx.universalChallengerBtcPubkeys,\n        timelockPegin: tx.timelockPegin,\n        network: this.config.network,\n        claimerBtcPubkey: tx.claimerBtcPubkey,\n        registeredPayoutScriptPubKey: tx.registeredPayoutScriptPubKey,\n        commissionBps: tx.commissionBps,\n        protocolFeeRate: tx.protocolFeeRate,\n        councilSize: tx.councilSize,\n        vkClaimerPayoutScriptPubKeys: tx.vkClaimerPayoutScriptPubKeys,\n        vpCommissionScriptPubKey: tx.vpCommissionScriptPubKey,\n      });\n      psbtsToSign.push(payoutPsbt.psbtHex);\n      signOptions.push(createTaprootScriptPathSignOptions(walletPubkeyRaw, 1));\n    }\n\n    // Batch sign all PSBTs with single wallet interaction\n    const signedPsbts = await this.config.btcWallet.signPsbts!(\n      psbtsToSign,\n      signOptions,\n    );\n\n    // Validate that wallet returned the expected number of signed PSBTs\n    if (signedPsbts.length !== transactions.length) {\n      throw new Error(\n        `Expected ${transactions.length} signed PSBTs but received ${signedPsbts.length}`,\n      );\n    }\n\n    // Extract signatures from signed PSBTs\n    const results: Array<{\n      payoutSignature: string;\n      depositorBtcPubkey: string;\n    }> = [];\n\n    for (let i = 0; i < transactions.length; i++) {\n      const depositorPubkey = depositorPubkeys[i];\n      assertPsbtUnsignedTxMatches({\n        requestedPsbtHex: psbtsToSign[i],\n        returnedPsbtHex: signedPsbts[i],\n      });\n      const payoutSignature = extractPayoutSignature(\n        signedPsbts[i],\n        depositorPubkey,\n      );\n      assertScriptPathSchnorrSignature({\n        requestedPsbtHex: psbtsToSign[i],\n        signatureHex: payoutSignature,\n        signerXOnlyPubkeyHex: depositorPubkey,\n        inputIndex: PAYOUT_SIGNED_INPUT_INDEX,\n      });\n\n      results.push({\n        payoutSignature,\n        depositorBtcPubkey: depositorPubkey,\n      });\n    }\n\n    return results;\n  }\n}\n","/**\n * Wallet-signing helper that routes a lone PSBT to `signPsbt`, prefers native\n * `signPsbts` for real batches, and falls back to sequential `signPsbt` for\n * wallets that don't implement batch signing.\n *\n * @module managers/pegin/signPsbtsWithFallback\n */\n\nimport type {\n  BitcoinWallet,\n  SignPsbtOptions,\n} from \"../../../../shared/wallets\";\n\n/**\n * Sign one or more PSBTs against a wallet.\n *\n * A single PSBT is always signed via `signPsbt`, never the batch endpoint: it's\n * one wallet interaction either way, and `signPsbt` is the universally-required\n * wallet method (batch `signPsbts` is optional), so single-sign is the portable\n * choice — some integrations (notably MPC / institutional wallets) prefer it.\n * For a real batch (>1), wallets exposing native `signPsbts` (e.g. UniSat) sign\n * in one interaction; others loop `signPsbt`.\n *\n * @throws If native `signPsbts` returns a different number of signed PSBTs\n *         than were submitted.\n */\nexport async function signPsbtsWithFallback(\n  wallet: BitcoinWallet,\n  psbtsHexes: string[],\n  options?: SignPsbtOptions[],\n): Promise<string[]> {\n  if (psbtsHexes.length === 1) {\n    return [await wallet.signPsbt(psbtsHexes[0], options?.[0])];\n  }\n\n  if (typeof wallet.signPsbts === \"function\") {\n    const signedPsbts = await wallet.signPsbts(psbtsHexes, options);\n    if (signedPsbts.length !== psbtsHexes.length) {\n      throw new Error(\n        `Expected ${psbtsHexes.length} signed PSBTs but received ${signedPsbts.length}`,\n      );\n    }\n    return signedPsbts;\n  }\n\n  const signedPsbts: string[] = [];\n  for (let i = 0; i < psbtsHexes.length; i++) {\n    signedPsbts.push(await wallet.signPsbt(psbtsHexes[i], options?.[i]));\n  }\n  return signedPsbts;\n}\n"],"names":["OP_RETURN","OP_PUSH32","OP_RETURN_PUSH32_SCRIPT_LEN","assertAuthAnchorOpReturn","fundedPrePeginTxHex","vaultCount","expectedAuthAnchorHashHex","cleanHex","stripHexPrefix","tx","bitcoin","opReturnOutput","script","pushedHex","findAuthAnchorOpReturn","hits","i","output","HEX_BYTES32_LENGTH","hexToBytes","hex","clean","bytes","bytesToHex","b","assertBytes32","value","label","computeHashlock","secret","secretBytes","hash","sha256","validateSecretAgainstHashlock","hashlock","supportsDepositApproval","wallet","forwardDepositApproval","terms","PAYOUT_SIGNED_INPUT_INDEX","PayoutManager","config","__publicField","params","walletPubkeyRaw","depositorPubkey","validateWalletPubkey","payoutPsbt","buildPayoutPsbt","signedPsbtHex","createTaprootScriptPathSignOptions","assertPsbtUnsignedTxMatches","signature","extractPayoutSignature","assertScriptPathSchnorrSignature","transactions","psbtsToSign","signOptions","depositorPubkeys","signedPsbts","results","payoutSignature","signPsbtsWithFallback","psbtsHexes","options"],"mappings":"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"}

package/dist/tbv/core/clients/eth/index.d.ts

@@ -1,8 +1,10 @@
 export { resolveProtocolAddresses, type ProtocolAddresses, } from './contract-address-resolver';
-export { validateOffchainParams, validatePegInConfiguration, validateTBVProtocolParams, } from './protocol-params-validation';
+export { assertOnChainBtcPubkey } from './onChainBtcPubkey';
+export { ViemOperationKeyReader, type OperationKeyContracts, } from './operation-key-reader';
 export { ViemProtocolParamsReader } from './protocol-params-reader';
+export { validateOffchainParams, validatePegInConfiguration, validateTBVProtocolParams, } from './protocol-params-validation';
 export { ViemUniversalChallengerReader, ViemVaultKeeperReader, } from './signer-set-reader';
-export { ViemVaultRegistryReader } from './vault-registry-reader';
 export { OnChainBtcVaultStatus } from './types';
-export type { AddressBTCKeyPair, AllOffchainParamsData, OnChainBtcPubkey, OnSkippedOffchainParamsVersion, PegInConfiguration, ProtocolParamsReader, TBVProtocolParams, UniversalChallengerReader, VaultBasicInfo, VaultData, VaultKeeperReader, VaultProtocolInfo, VaultRegistryReader, VersionedOffchainParams, } from './types';
+export type { AddressBTCKeyPair, AllOffchainParamsData, KeyEpochs, OnChainBtcPubkey, OnSkippedOffchainParamsVersion, OperationKeyQuery, OperationKeyReader, PegInConfiguration, ProtocolParamsReader, RawOperationKeys, RawPayoutScripts, TBVProtocolParams, UniversalChallengerReader, VaultBasicInfo, VaultData, VaultKeeperReader, VaultProtocolInfo, VaultRegistryReader, VersionedOffchainParams, } from './types';
+export { ViemVaultRegistryReader } from './vault-registry-reader';
 //# sourceMappingURL=index.d.ts.map

package/dist/tbv/core/clients/eth/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/clients/eth/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,KAAK,iBAAiB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,sBAAsB,EACtB,0BAA0B,EAC1B,yBAAyB,GAC1B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EACL,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChD,YAAY,EACV,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,8BAA8B,EAC9B,kBAAkB,EAClB,oBAAoB,EACpB,iBAAiB,EACjB,yBAAyB,EACzB,cAAc,EACd,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/clients/eth/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,KAAK,iBAAiB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EACL,sBAAsB,EACtB,KAAK,qBAAqB,GAC3B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EACL,sBAAsB,EACtB,0BAA0B,EAC1B,yBAAyB,GAC1B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAChD,YAAY,EACV,iBAAiB,EACjB,qBAAqB,EACrB,SAAS,EACT,gBAAgB,EAChB,8BAA8B,EAC9B,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,yBAAyB,EACzB,cAAc,EACd,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/tbv/core/clients/eth/onChainBtcPubkey.d.ts

@@ -0,0 +1,16 @@
+import { Hex } from 'viem';
+import { OnChainBtcPubkey } from './types';
+/**
+ * Validate a registry-returned `bytes32` as an x-only BTC pubkey and mint the
+ * brand. Checks length, hex form, and secp256k1 curve membership. Returns
+ * 64-char lowercase hex without the `0x` prefix.
+ *
+ * `label` identifies the read site in error messages (e.g.
+ * `getVaultProviderBTCKey (vp=0x…)`), so a failure names which participant and
+ * which getter produced it.
+ *
+ * A zero hash fails the curve check, so an unregistered operator or an epoch
+ * with no bonded key surfaces as an error rather than a silent all-zero key.
+ */
+export declare function assertOnChainBtcPubkey(value: Hex, label: string): OnChainBtcPubkey;
+//# sourceMappingURL=onChainBtcPubkey.d.ts.map

package/dist/tbv/core/clients/eth/onChainBtcPubkey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onChainBtcPubkey.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/clients/eth/onChainBtcPubkey.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAGhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,gBAAgB,CAclB"}

package/dist/tbv/core/clients/eth/operation-key-reader.d.ts

@@ -0,0 +1,33 @@
+import { Address, PublicClient } from 'viem';
+import { KeyEpochs, OperationKeyQuery, OperationKeyReader, RawOperationKeys, RawPayoutScripts } from './types';
+/** Addresses of the three registries an operation-key resolution spans. */
+export interface OperationKeyContracts {
+    btcVaultRegistry: Address;
+    applicationRegistry: Address;
+    protocolParams: Address;
+}
+/**
+ * Reads RFC-006 operation keys and payout scripts.
+ *
+ * Usage:
+ * ```ts
+ * const reader = new ViemOperationKeyReader(publicClient, contracts);
+ * const keys = await reader.getCurrentOperationKeys(query);
+ * ```
+ */
+export declare class ViemOperationKeyReader implements OperationKeyReader {
+    private publicClient;
+    private contracts;
+    constructor(publicClient: PublicClient, contracts: OperationKeyContracts);
+    /**
+     * One multicall, `allowFailure: false`, so every key in the set is read at
+     * the same block. A rotation landing between two separate `eth_call`s would
+     * otherwise produce a mixed-epoch key set and a lock no counterparty agrees
+     * with.
+     */
+    private readAll;
+    getCurrentOperationKeys(query: OperationKeyQuery): Promise<RawOperationKeys>;
+    getOperationKeysAtEpochs(query: OperationKeyQuery, epochs: KeyEpochs): Promise<RawOperationKeys>;
+    getPayoutScriptsAtEpochs(query: OperationKeyQuery, epochs: KeyEpochs): Promise<RawPayoutScripts>;
+}
+//# sourceMappingURL=operation-key-reader.d.ts.map

package/dist/tbv/core/clients/eth/operation-key-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-key-reader.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/clients/eth/operation-key-reader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAO,OAAO,EAAO,YAAY,EAAE,MAAM,MAAM,CAAC;AAK5D,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB,2EAA2E;AAC3E,MAAM,WAAW,qBAAqB;IACpC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC;CACzB;AA+BD;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IAE7D,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,SAAS;gBADT,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,qBAAqB;IAG1C;;;;;OAKG;YACW,OAAO;IASf,uBAAuB,CAC3B,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,gBAAgB,CAAC;IAyBtB,wBAAwB,CAC5B,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,gBAAgB,CAAC;IAsCtB,wBAAwB,CAC5B,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,gBAAgB,CAAC;CA8B7B"}

package/dist/tbv/core/clients/eth/types.d.ts

@@ -1,9 +1,12 @@
 import { Address, Hex } from 'viem';
 declare const onChainBtcPubkeyBrand: unique symbol;
 /**
- * 64-char lowercase hex (no `0x`) x-only BTC pubkey sourced from the
- * on-chain BTCVaultRegistry. The only legitimate producer is
- * {@link VaultRegistryReader.getVaultProviderBtcPubKey}.
+ * 64-char lowercase hex (no `0x`) x-only BTC pubkey sourced from an on-chain
+ * registry. Minted only by `assertOnChainBtcPubkey`, which is the shared
+ * validator behind both producers:
+ * {@link VaultRegistryReader.getVaultProviderBtcPubKey} (the fixed
+ * registration key) and {@link OperationKeyReader} (RFC-006 operation keys,
+ * resolved current or at a vault's frozen epoch).
  *
  * @stability frozen
  */
@@ -61,6 +64,27 @@ export interface VaultData {
     basic: VaultBasicInfo;
     protocol: VaultProtocolInfo;
 }
+/**
+ * RFC-006 operation-key epochs a vault froze at `submitPeginRequest`.
+ *
+ * Each registry keeps a monotonic epoch counter that every key/payout setter
+ * pre-increments. A vault stamps the counters live at its creation, and every
+ * participant resolves "which key did this vault bond?" by asking the registry
+ * for the key whose appended version is the latest stamped `<=` this epoch. A
+ * rotation after the vault was created therefore never moves its keys.
+ *
+ * `uint64` — kept as `bigint` end-to-end and passed straight back to the
+ * `...AtEpoch` getters, never narrowed through `Number`.
+ *
+ * Only ever read through {@link VaultRegistryReader.getVaultKeyEpochs}, which
+ * uses the extended ABI. See `BTCVaultRegistryKeyEpochs.abi.ts` for why that
+ * read is quarantined to its own ABI.
+ */
+export interface KeyEpochs {
+    vpKeyEpoch: bigint;
+    appKeeperKeyEpoch: bigint;
+    ucKeyEpoch: bigint;
+}
 /** Interface for reading vault data from the BTCVaultRegistry contract. */
 export interface VaultRegistryReader {
     getVaultBasicInfo(vaultId: Hex): Promise<VaultBasicInfo>;
@@ -83,6 +107,24 @@ export interface VaultRegistryReader {
      * is missing on-chain.
      */
     getOffchainParamsVersionsByVaultIds(vaultIds: readonly Hex[]): Promise<number[]>;
+    /**
+     * Read a vault's frozen RFC-006 key epochs.
+     *
+     * Uses the extended `getBtcVaultProtocolInfo` ABI. Against a registry that
+     * predates RFC-006 this returns silent garbage for a populated vault rather
+     * than throwing, so it must only be called against an RFC-006 registry —
+     * a deployment invariant, not something this call can detect. See
+     * `BTCVaultRegistryKeyEpochs.abi.ts`.
+     */
+    getVaultKeyEpochs(vaultId: Hex): Promise<KeyEpochs>;
+    /** {@link getVaultKeyEpochs} for many vaults in one multicall. */
+    getVaultKeyEpochsBatch(vaultIds: readonly Hex[]): Promise<KeyEpochs[]>;
+    /**
+     * Read a vault provider's *current* RFC-006 operation BTC key — the key its
+     * server signs auth tokens with. Falls back to the registration key when the
+     * provider has never rotated.
+     */
+    getCurrentVaultProviderOperationBtcKey(vpAddress: Address): Promise<OnChainBtcPubkey>;
 }
 /**
  * TBV protocol parameters from the ProtocolParams contract.
@@ -203,5 +245,82 @@ export interface UniversalChallengerReader {
     getCurrentUniversalChallengers(): Promise<AddressBTCKeyPair[]>;
     getLatestUniversalChallengersVersion(): Promise<number>;
 }
+/**
+ * The participants whose operation keys are being resolved, and the roster
+ * they are resolved against.
+ *
+ * A roster entry's `ethAddress` is the operator's **admin** address — the
+ * lookup key for its key history — and its `btcPubKey` is the operator's
+ * **genesis** key. Both are needed: the `...AtEpochOrGenesis` getters take the
+ * roster key explicitly because the correct genesis for a keeper/challenger is
+ * its key in the vault's *frozen membership version*, which an operator that
+ * was later dropped from the roster no longer has a current entry for.
+ */
+export interface OperationKeyQuery {
+    vaultProviderEthAddress: Address;
+    /**
+     * The VP's genesis (registration) key, from `getVaultProviderBTCKey`.
+     *
+     * The VP has no roster entry to carry a genesis key the way keepers and
+     * challengers do, so it is supplied here. Every call site already reads it:
+     * it is what the indexer hint is compared against, and what makes the VP's
+     * `rotated` flag mean the same thing as everyone else's.
+     */
+    vaultProviderGenesisBtcPubkey: Hex;
+    applicationEntryPoint: Address;
+    /** Keeper roster at the membership version being resolved against. */
+    vaultKeepers: readonly AddressBTCKeyPair[];
+    /** Challenger roster at the membership version being resolved against. */
+    universalChallengers: readonly AddressBTCKeyPair[];
+}
+/** Raw registry-returned operation keys, index-aligned with the query rosters. */
+export interface RawOperationKeys {
+    vaultProvider: Hex;
+    vaultKeepers: Hex[];
+    universalChallengers: Hex[];
+}
+/**
+ * Registry-returned payout scriptPubKeys, index-aligned with the query
+ * rosters. `universalChallengers` has no counterpart: a UC is never a claimer,
+ * so it has no payout script.
+ */
+export interface RawPayoutScripts {
+    vaultProvider: Hex;
+    vaultKeepers: Hex[];
+}
+/**
+ * Reads RFC-006 operation keys and payout scripts across all three registries
+ * (BTCVaultRegistry, ApplicationRegistry, ProtocolParams).
+ *
+ * Every method resolves the whole participant set in a **single** multicall so
+ * the keys are pinned to one block. That atomicity is load-bearing: a rotation
+ * landing between two `eth_call`s would yield a self-inconsistent key set that
+ * builds a lock no counterparty agrees with.
+ */
+export interface OperationKeyReader {
+    /**
+     * Resolve every participant's *current* operation key.
+     *
+     * Used for new peg-ins and for the VP auth pin. Needs no epoch read at all —
+     * each registry's `getCurrentOperationBtcKey` resolves its own genesis
+     * fallback, so an operator that never rotated yields its registration key.
+     */
+    getCurrentOperationKeys(query: OperationKeyQuery): Promise<RawOperationKeys>;
+    /**
+     * Resolve every participant's operation key bonded at a vault's frozen
+     * epochs. Used for every existing-vault path (resume, payout, refund).
+     */
+    getOperationKeysAtEpochs(query: OperationKeyQuery, epochs: KeyEpochs): Promise<RawOperationKeys>;
+    /**
+     * Resolve the VP's commission payout script and each keeper's payout script
+     * at a vault's frozen epochs.
+     *
+     * The registry backfills BIP-86 P2TR of the epoch's operation key for any
+     * operator that never called `setPayoutScript`, so this returns byte-identical
+     * results to local BIP-86 derivation until an operator registers a custom
+     * script.
+     */
+    getPayoutScriptsAtEpochs(query: OperationKeyQuery, epochs: KeyEpochs): Promise<RawPayoutScripts>;
+}
 export {};
 //# sourceMappingURL=types.d.ts.map