@babylonlabs-io/ts-sdk 1.0.0 → 1.1.0

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

@@ -14,8 +14,8 @@ export interface ChallengeAssertParams {
  * Build unsigned ChallengeAssert PSBT.
  *
  * Each input has its own taproot script derived from its connector params; the
- * number of connector params must match the transaction's input count. The
- * depositor signs all inputs. Every prevout is derived from the authoritative
+ * number of connector params must match the transaction's input count.
+ * Every prevout is derived from the authoritative
  * Assert transaction, never trusted from external input.
  *
  * @param params - ChallengeAssert parameters

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

@@ -1 +1 @@
-{"version":3,"file":"challengeAssert.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/challengeAssert.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,KAAK,8BAA8B,EAGpC,MAAM,YAAY,CAAC;AAWpB;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,iDAAiD;IACjD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qFAAqF;IACrF,WAAW,EAAE,MAAM,CAAC;IACpB,wFAAwF;IACxF,uBAAuB,EAAE,8BAA8B,EAAE,CAAC;CAC3D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,CAAC,CA+EjB"}
+{"version":3,"file":"challengeAssert.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/challengeAssert.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,8BAA8B,EAGpC,MAAM,YAAY,CAAC;AAWpB;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,iDAAiD;IACjD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qFAAqF;IACrF,WAAW,EAAE,MAAM,CAAC;IACpB,wFAAwF;IACxF,uBAAuB,EAAE,8BAA8B,EAAE,CAAC;CAC3D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,CAAC,CA+EjB"}

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

@@ -7,7 +7,7 @@ export interface NoPayoutParams {
     noPayoutTxHex: string;
     /** Challenger's x-only public key (hex encoded) */
     challengerPubkey: string;
-    /** Prevouts for all inputs [{script_pubkey, value}] from VP */
+    /** Prevouts for all inputs [{script_pubkey, value}], used verbatim — derive them from the parent txs */
     prevouts: Array<{
         script_pubkey: string;
         value: number;

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

@@ -1 +1 @@
-{"version":3,"file":"noPayout.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/noPayout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,KAAK,mCAAmC,EACxC,KAAK,OAAO,EAGb,MAAM,YAAY,CAAC;AAYpB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,gBAAgB,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,QAAQ,EAAE,KAAK,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,0DAA0D;IAC1D,eAAe,EAAE,mCAAmC,CAAC;CACtD;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,MAAM,CAAC,CA6DjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qCAAqC,CACnD,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,OAAO,GACf,IAAI,CAyBN"}
+{"version":3,"file":"noPayout.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/noPayout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,KAAK,mCAAmC,EACxC,KAAK,OAAO,EAGb,MAAM,YAAY,CAAC;AAYpB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,gBAAgB,EAAE,MAAM,CAAC;IACzB,wGAAwG;IACxG,QAAQ,EAAE,KAAK,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,0DAA0D;IAC1D,eAAe,EAAE,mCAAmC,CAAC;CACtD;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,MAAM,CAAC,CA6DjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qCAAqC,CACnD,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,OAAO,GACf,IAAI,CAyBN"}

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

@@ -2,8 +2,8 @@ import { Network } from '../../wasm';
 /**
  * Parameters for building an unsigned Payout PSBT
  *
- * Payout is used in the challenge path after Assert, when the claimer proves validity.
- * Input 1 references the Assert transaction.
+ * Payout ends two of the peg-out paths; see {@link buildPayoutPsbt} for all of
+ * them. Input 1 references the Assert transaction.
  */
 export interface PayoutParams {
     /**
@@ -131,11 +131,17 @@ export interface PayoutPsbtResult {
 /**
  * Build unsigned Payout PSBT for depositor to sign.
  *
- * Payout is used in the **challenge path** when the claimer proves validity:
- * 1. Vault provider submits Claim transaction
- * 2. Challenge is raised during challenge period
- * 3. Claimer submits Assert transaction to prove validity
- * 4. Payout can be executed (references Assert tx)
+ * Payout ends two of the peg-out paths (btc-vault
+ * `crates/vault/docs/btc-transactions-spec.md`):
+ * - Happy path: Claim -> Assert -> Payout.
+ * - Challenge path, claimer wins: Claim -> Assert -> ChallengeAssert ->
+ *   WronglyChallenged -> Payout.
+ * - Challenge path, challenger wins: Claim -> Assert -> ChallengeAssert -> NoPayout.
+ * - Emergency path: the Security Council spends Assert:0 via CouncilNoPayout.
+ *
+ * So a raised challenge does not remove Payout; only NoPayout (challenger wins)
+ * or CouncilNoPayout (council emergency) blocks it.
+ * Payout references the Assert tx and needs its timelock matured.
  *
  * Payout transactions have the following structure:
  * - Input 0: from PeginTx output0 (signed by depositor)

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

@@ -1 +1 @@
-{"version":3,"file":"payout.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/payout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAGL,KAAK,OAAO,EACb,MAAM,YAAY,CAAC;AA4CpB;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAE/B;;OAEG;IACH,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAEhC;;OAEG;IACH,6BAA6B,EAAE,MAAM,EAAE,CAAC;IAExC;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;;OAIG;IACH,4BAA4B,EAAE,MAAM,CAAC;IAErC;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;;;;;;OAOG;IACH,cAAc,EAAE,MAAM,EAAE,CAAC;IAEzB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;;;;;;;;;;OAcG;IACH,4BAA4B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAE/D;;;;;OAKG;IACH,wBAAwB,EAAE,MAAM,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAoH3B;AA4bD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,MAAM,EACvB,UAAU,SAAI,GACb,MAAM,CA+CR"}
+{"version":3,"file":"payout.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/primitives/psbt/payout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAGL,KAAK,OAAO,EACb,MAAM,YAAY,CAAC;AA0CpB;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAE/B;;OAEG;IACH,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAEhC;;OAEG;IACH,6BAA6B,EAAE,MAAM,EAAE,CAAC;IAExC;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;;OAIG;IACH,4BAA4B,EAAE,MAAM,CAAC;IAErC;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;;;;;;OAOG;IACH,cAAc,EAAE,MAAM,EAAE,CAAC;IAEzB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;;;;;;;;;;OAcG;IACH,4BAA4B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAE/D;;;;;OAKG;IACH,wBAAwB,EAAE,MAAM,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAoH3B;AA4bD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,MAAM,EACvB,UAAU,SAAI,GACb,MAAM,CA+CR"}

package/dist/tbv/core/services/delegated-claim/__tests__/assembleWatchtowerArtifacts.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Orchestration of the one signing session that authorizes a delegated claim.
+ *
+ * The signatures are collected months before they are used and cannot be
+ * re-collected, so what matters here is that every signature ends up attached
+ * to the transaction, challenger, and garbled-circuit index it was computed
+ * for, and that the batch is a single wallet interaction.
+ *
+ * Every wasm call is mocked, so nothing here says anything about the bytes
+ * the file ends up carrying. That guarantee lives in btc-vault#2655's
+ * `crates/vault/src/delegated_claim/artifacts.rs` round-trip test, which is
+ * where an `artifacts.json` format change has to be caught.
+ */
+export {};
+//# sourceMappingURL=assembleWatchtowerArtifacts.test.d.ts.map

package/dist/tbv/core/services/delegated-claim/__tests__/assembleWatchtowerArtifacts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembleWatchtowerArtifacts.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/services/delegated-claim/__tests__/assembleWatchtowerArtifacts.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/tbv/core/services/delegated-claim/__tests__/deriveClaimerWotsKeypair.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Re-derivation of the WOTS keypair a delegated claim needs.
+ *
+ * The keypair is never stored, so the only thing standing between a wallet
+ * that derives the wrong one and an Assert nobody can verify is the pair of
+ * checks here: against the vault's on-chain commitment, and against the
+ * graph. Both must run before the keypair is handed back, and the secrets
+ * they run on must not outlive the call.
+ */
+export {};
+//# sourceMappingURL=deriveClaimerWotsKeypair.test.d.ts.map

package/dist/tbv/core/services/delegated-claim/__tests__/deriveClaimerWotsKeypair.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveClaimerWotsKeypair.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/services/delegated-claim/__tests__/deriveClaimerWotsKeypair.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/tbv/core/services/delegated-claim/__tests__/readWatchtowerArtifacts.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks on an artifacts file that arrives from disk.
+ *
+ * Nothing verifies an artifacts file between the day it is written and the
+ * day it is claimed against, and by then the vault provider may be gone. A
+ * file for the wrong vault, or one whose signatures no longer hold, has to
+ * fail at selection — after the Claim is broadcast the PegIn UTXO is spent.
+ */
+export {};
+//# sourceMappingURL=readWatchtowerArtifacts.test.d.ts.map

package/dist/tbv/core/services/delegated-claim/__tests__/readWatchtowerArtifacts.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readWatchtowerArtifacts.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/services/delegated-claim/__tests__/readWatchtowerArtifacts.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/tbv/core/services/delegated-claim/__tests__/vaultIdBinding.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The one check that ties a vault-provider-served graph to a vault.
+ *
+ * Every other field is self-declared: the graph JSON names no vault, and the
+ * artifacts file's `vault_id` is copied in by whoever wrote it. Only the
+ * PegIn output the Claim spends is a fact about the chain, and getting its
+ * byte order wrong would silently reject correct graphs and accept nothing.
+ */
+export {};
+//# sourceMappingURL=vaultIdBinding.test.d.ts.map

package/dist/tbv/core/services/delegated-claim/__tests__/vaultIdBinding.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vaultIdBinding.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/services/delegated-claim/__tests__/vaultIdBinding.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/tbv/core/services/delegated-claim/__tests__/wotsKeypair.golden.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Golden-vector gate for the WOTS keypair derivation the delegated claim
+ * depends on. The derivation binds on-chain through `depositorWotsPkHash`:
+ * if these bytes drift, every existing depositor loses the ability to prove
+ * the keypair the graph's Claim commits to, and with it their claim path.
+ *
+ * The same vector is pinned Rust-side in vault-wasm `lib.rs` and in btc-vault
+ * `crates/crypto`. A vault-wasm re-pin that changes it must not ship.
+ */
+export {};
+//# sourceMappingURL=wotsKeypair.golden.test.d.ts.map

package/dist/tbv/core/services/delegated-claim/__tests__/wotsKeypair.golden.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wotsKeypair.golden.test.d.ts","sourceRoot":"","sources":["../../../../../../src/tbv/core/services/delegated-claim/__tests__/wotsKeypair.golden.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/tbv/core/services/delegated-claim/assembleWatchtowerArtifacts.d.ts

@@ -0,0 +1,46 @@
+import { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+import { BitcoinWallet } from '../../../../shared/wallets/interfaces';
+import { ClaimerArtifactsSource, DelegatedClaimVaultContext } from './types';
+/**
+ * Everything one delegated-claim signing session needs.
+ *
+ * @experimental
+ */
+export interface AssembleWatchtowerArtifactsParams {
+    /** Wallet holding the depositor key the graph was built with. */
+    btcWallet: BitcoinWallet;
+    /** Depositor's BTC public key (compressed or x-only hex). */
+    depositorPublicKey: string;
+    /** Network the depositor's address is derived on, to check the signer. */
+    btcNetwork: Network;
+    /** Graph and verifying key as the vault provider returned them. */
+    source: ClaimerArtifactsSource;
+    vault: DelegatedClaimVaultContext;
+    /**
+     * Per-challenger BaBe sessions as `{"<pk>": {"decryptor_artifacts_hex":
+     * "..."}}`, passed through into the file unchanged.
+     *
+     * Omit it for anything but a fixture. Real sessions run to hundreds of
+     * megabytes per challenger, and this argument crosses the WASM boundary as
+     * one string — join them into the file downstream instead.
+     */
+    babeSessionsJson?: string;
+}
+/**
+ * Signs the delegated-claim set and returns the `artifacts.json` content,
+ * ready to write verbatim.
+ *
+ * Every signature is verified against the graph before the file is produced,
+ * so a wallet that signed under the wrong key fails here rather than at claim
+ * time, when nothing can be re-signed.
+ *
+ * Experimental: this API can change in a minor release. Pin the SDK
+ * version if you build on it.
+ *
+ * @throws If the graph is not version 3, if the wallet returns a signature
+ *         that does not verify, or if the graph's own presignatures are
+ *         incomplete.
+ * @experimental
+ */
+export declare function assembleWatchtowerArtifacts(params: AssembleWatchtowerArtifactsParams): Promise<string>;
+//# sourceMappingURL=assembleWatchtowerArtifacts.d.ts.map

package/dist/tbv/core/services/delegated-claim/assembleWatchtowerArtifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembleWatchtowerArtifacts.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/assembleWatchtowerArtifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAGrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAgB3E,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AA8BjB;;;;GAIG;AACH,MAAM,WAAW,iCAAiC;IAChD,iEAAiE;IACjE,SAAS,EAAE,aAAa,CAAC;IACzB,6DAA6D;IAC7D,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0EAA0E;IAC1E,UAAU,EAAE,OAAO,CAAC;IACpB,mEAAmE;IACnE,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,EAAE,0BAA0B,CAAC;IAClC;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,iCAAiC,GACxC,OAAO,CAAC,MAAM,CAAC,CAkHjB"}

package/dist/tbv/core/services/delegated-claim/challengerBinding.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Binding between the challenger set a delegated claim signs for and the set
+ * the vault actually has on chain.
+ *
+ * The WronglyChallenged PSBTs arrive keyed by challenger public key, and the
+ * vault provider chooses those keys. Nothing downstream notices a short map:
+ * the artifacts file verifies against its own graph, so a missing challenger
+ * produces a file that looks complete and fails only months later, when that
+ * challenger's ChallengeAssert has to be answered inside
+ * `timelock_challenge_assert` and the material is not there.
+ *
+ * The failure is asymmetric, which is why both directions are checked.
+ * Missing entries leave the depositor unable to defend the claim; extra
+ * entries hand out signatures for keys the protocol does not recognize.
+ *
+ * This mirrors `assertChallengerSetMatchesExpected` in
+ * `services/deposit/signDepositorGraph.ts`, which does the same job at
+ * deposit time against the same on-chain sets.
+ *
+ * @module services/delegated-claim/challengerBinding
+ */
+/**
+ * Thrown when the graph's challengers are not the vault's challengers.
+ *
+ * @experimental
+ */
+export declare class ChallengerSetMismatchError extends Error {
+    /** Challengers the vault has that the graph left out. */
+    readonly missing: string[];
+    /** Challengers the graph lists that the vault does not have. */
+    readonly unexpected: string[];
+    constructor(
+    /** Challengers the vault has that the graph left out. */
+    missing: string[], 
+    /** Challengers the graph lists that the vault does not have. */
+    unexpected: string[]);
+}
+/**
+ * The graph's challenger keys, and the on-chain sets they must equal.
+ *
+ * @experimental
+ */
+export interface AssertChallengerSetMatchesVaultParams {
+    /** Challenger keys the graph produced WronglyChallenged PSBTs for. */
+    graphChallengerPubkeys: string[];
+    /** Depositor's BTC public key, registered on chain for this vault. */
+    depositorBtcPubkey: string;
+    /**
+     * Vault provider's BTC public key, registered on chain for this vault.
+     * The depositor-as-claimer branch does not use it, but the shared
+     * derivation takes it, and passing a stand-in would be a lie that the
+     * next change to that function could turn into a wrong set.
+     */
+    vaultProviderBtcPubkey: string;
+    /** Vault keepers registered on chain for this vault. */
+    vaultKeeperBtcPubkeys: string[];
+    /** Universal challengers registered on chain. */
+    universalChallengerBtcPubkeys: string[];
+}
+/**
+ * Throws unless the graph's challenger set equals `local ∪ universal`.
+ *
+ * The depositor is the claimer here, so the local set is the vault keepers,
+ * derived by the same function the deposit path uses rather than restated.
+ *
+ * @throws {@link ChallengerSetMismatchError} on any missing or extra key, or
+ *         a plain error when the on-chain sets themselves are unusable.
+ *
+ * @experimental
+ */
+export declare function assertChallengerSetMatchesVault(params: AssertChallengerSetMatchesVaultParams): void;
+//# sourceMappingURL=challengerBinding.d.ts.map

package/dist/tbv/core/services/delegated-claim/challengerBinding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"challengerBinding.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/challengerBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAKH;;;;GAIG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;IAEjD,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE;;IAH7B,yDAAyD;IAChD,OAAO,EAAE,MAAM,EAAE;IAC1B,gEAAgE;IACvD,UAAU,EAAE,MAAM,EAAE;CAahC;AAED;;;;GAIG;AACH,MAAM,WAAW,qCAAqC;IACpD,sEAAsE;IACtE,sBAAsB,EAAE,MAAM,EAAE,CAAC;IACjC,sEAAsE;IACtE,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAC/B,wDAAwD;IACxD,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,iDAAiD;IACjD,6BAA6B,EAAE,MAAM,EAAE,CAAC;CACzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,qCAAqC,GAC5C,IAAI,CAkCN"}

package/dist/tbv/core/services/delegated-claim/deriveClaimerWotsKeypair.d.ts

@@ -0,0 +1,63 @@
+import { BitcoinWallet } from '../../../../shared/wallets/interfaces';
+import { VaultContextInput } from '../../vault-secrets';
+/**
+ * Inputs for re-deriving the depositor's WOTS keypair at claim time.
+ *
+ * @experimental
+ */
+export interface DeriveClaimerWotsKeypairParams {
+    /** Must implement `deriveContextHash` — the only wallet prompt in the claim. */
+    btcWallet: BitcoinWallet;
+    /** Same context that produced this vault's secrets at deposit time. */
+    vaultContext: VaultContextInput;
+    /** HTLC output index of this vault within the Pre-PegIn transaction. */
+    htlcVout: number;
+    /** JSON-serialized TxGraph the keypair must match. */
+    txGraphJson: string;
+    /** Graph version. Delegated claim requires 3. */
+    txGraphVersion: number;
+    /**
+     * `depositorWotsPkHash` as the vault records it on chain, `0x`-prefixed.
+     *
+     * This is the only anchor here the vault provider does not supply. The
+     * graph check below compares against VP-served bytes, so it cannot tell a
+     * wrong `htlcVout`, a wrong wallet account, or expander drift after a
+     * WASM re-pin from a correct derivation.
+     */
+    expectedWotsPkHash: string;
+}
+/**
+ * The `wots_keypair.json` content and the hash it commits to.
+ *
+ * @experimental
+ */
+export interface ClaimerWotsKeypair {
+    /**
+     * Content of `wots_keypair.json`, ready to write verbatim. Secret and
+     * single-use: never log it, never persist it beyond the claim, and never
+     * reuse it — reuse across claims leaks the WOTS key.
+     */
+    wotsKeypairJson: string;
+    /** `0x`-prefixed hash of the public keys, matching `depositorWotsPkHash`. */
+    pkHash: string;
+}
+/**
+ * Re-derives the depositor's WOTS keypair and checks it against the vault's
+ * on-chain commitment and against the graph.
+ *
+ * The validation is the point of this function, not a formality: an unbound
+ * keypair produces an Assert witness no verifier accepts, and that failure
+ * would otherwise surface only after the Claim has been broadcast and the
+ * PegIn UTXO is already spent. The on-chain hash is checked first, because
+ * it is the one value here the vault provider cannot choose.
+ *
+ * Experimental: this API can change in a minor release. Pin the SDK
+ * version if you build on it.
+ *
+ * @throws If the derivation does not match the vault's on-chain
+ *         `depositorWotsPkHash`, or the WOTS public keys the graph's Claim
+ *         commits to.
+ * @experimental
+ */
+export declare function deriveClaimerWotsKeypair(params: DeriveClaimerWotsKeypairParams): Promise<ClaimerWotsKeypair>;
+//# sourceMappingURL=deriveClaimerWotsKeypair.d.ts.map

package/dist/tbv/core/services/delegated-claim/deriveClaimerWotsKeypair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveClaimerWotsKeypair.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/deriveClaimerWotsKeypair.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAE3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAM7D;;;;GAIG;AACH,MAAM,WAAW,8BAA8B;IAC7C,gFAAgF;IAChF,SAAS,EAAE,aAAa,CAAC;IACzB,uEAAuE;IACvE,YAAY,EAAE,iBAAiB,CAAC;IAChC,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,8BAA8B,GACrC,OAAO,CAAC,kBAAkB,CAAC,CA4B7B"}

package/dist/tbv/core/services/delegated-claim/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Delegated claim (depositor-as-claimer) — artifact assembly and claim-time
+ * execution.
+ *
+ * EXPERIMENTAL. This surface is still under test. It has been exercised end
+ * to end on signet, not on mainnet, and no caller ships in this repo yet.
+ * Treat the shape of every export here as provisional: names, parameters and
+ * return types can change in a minor release. Pin the SDK version if you
+ * build on it. The on-chain and file formats are not provisional — those are
+ * owned by btc-vault and by the `VAULT_WASM_COMMIT` pin.
+ *
+ * Produces and checks the two files a claim runs from: `artifacts.json` and
+ * `wots_keypair.json`. `vaultd vp wt` reads the same pair, so either can drive
+ * the claim.
+ *
+ * Claim time is here as well. From an assembled `artifacts.json` this module
+ * pins the Groth16 proof, finalizes the Assert, and produces the Payout and
+ * WronglyChallenged transactions, so a depositor whose vault provider is gone
+ * completes a claim without running the CLI.
+ *
+ * Two things stay outside: the proof itself comes from the prover service,
+ * and nothing here watches the chain — a ChallengeAssert must be answered
+ * inside `timelock_challenge_assert`, and noticing one is the caller's job.
+ *
+ * @see btc-vault docs/delegated_claim.md
+ * @module services/delegated-claim
+ */
+export { assembleWatchtowerArtifacts, type AssembleWatchtowerArtifactsParams, } from './assembleWatchtowerArtifacts';
+export { deriveClaimerWotsKeypair, type ClaimerWotsKeypair, type DeriveClaimerWotsKeypairParams, } from './deriveClaimerWotsKeypair';
+export { ArtifactsVaultMismatchError, DELEGATED_CLAIM_TX_GRAPH_VERSION, assertArtifactsUsableForVault, summarizeWatchtowerArtifacts, type AssertArtifactsUsableParams, } from './readWatchtowerArtifacts';
+export { ChallengerSetMismatchError, assertChallengerSetMatchesVault, type AssertChallengerSetMatchesVaultParams, } from './challengerBinding';
+export { PayoutDestinationError, assertPayoutPaysRegisteredScript, type AssertPayoutPaysRegisteredScriptParams, } from './payoutBinding';
+export { VaultIdBindingError, assertClaimSpendsVault, type AssertClaimSpendsVaultParams, } from './vaultIdBinding';
+export type { ClaimerArtifactsSource, DelegatedClaimVaultContext, WatchtowerArtifactsSummary, } from './types';
+/**
+ * Claim-time execution, artifacts in and artifacts out.
+ *
+ * The least settled part of an already experimental module: these four are
+ * re-exports of the WASM surface and have no caller in this repo. They were
+ * run end to end on signet from a browser page that is not part of this
+ * package. Expect them to be reshaped, renamed, or wrapped before they are
+ * stable.
+ *
+ * `pinPegoutProof` verifies the prover's Groth16 proof and writes it into the
+ * artifacts; `attachFinalizedAssert` then finalizes the Assert from that
+ * pinned proof and the depositor's WOTS keypair, so the keypair never leaves
+ * the caller. `finalizePayout` and `finalizeWronglyChallenged` return
+ * broadcastable transaction hex from the signatures the file already carries.
+ *
+ * Persist the JSON `pinPegoutProof` returns before the Assert is broadcast: a
+ * one-time WOTS keypair signs exactly one proof, and a second, different one
+ * is refused.
+ */
+export { pinPegoutProof, attachFinalizedAssert, finalizePayout, finalizeWronglyChallenged, } from '../../wasm';
+//# sourceMappingURL=index.d.ts.map

package/dist/tbv/core/services/delegated-claim/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACL,2BAA2B,EAC3B,KAAK,iCAAiC,GACvC,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,8BAA8B,GACpC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,2BAA2B,EAC3B,gCAAgC,EAChC,6BAA6B,EAC7B,4BAA4B,EAC5B,KAAK,2BAA2B,GACjC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,0BAA0B,EAC1B,+BAA+B,EAC/B,KAAK,qCAAqC,GAC3C,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,sBAAsB,EACtB,gCAAgC,EAChC,KAAK,sCAAsC,GAC5C,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,KAAK,4BAA4B,GAClC,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,cAAc,EACd,yBAAyB,GAC1B,MAAM,YAAY,CAAC"}

package/dist/tbv/core/services/delegated-claim/payoutBinding.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Binding between a delegated-claim Payout and the destination the vault
+ * registered on chain.
+ *
+ * The Payout transaction is built by the vault provider and moves the whole
+ * recovered peg-in. Its outputs are the one thing in this flow that decides
+ * where the money lands, and nothing in the artifacts file constrains them:
+ * the Rust verification proves the bundled signatures are self-consistent
+ * with the same graph that named the outputs. So a graph correctly bound to
+ * this vault can still carry a Payout that pays somebody else, and the
+ * depositor would sign it in the same prompt as everything else.
+ *
+ * This is the claim-side counterpart of `assertPayoutOutputLayout` in
+ * `primitives/psbt/payout.ts`, which the deposit-time path already runs for
+ * the same `depositor-as-claimer` role. It pins the same four things: the
+ * output count, the payout script, the CPFP anchor value, and the version
+ * and locktime the depositor's signature commits to.
+ *
+ * @module services/delegated-claim/payoutBinding
+ */
+/**
+ * Thrown when a Payout does not pay the vault's registered destination.
+ *
+ * @experimental
+ */
+export declare class PayoutDestinationError extends Error {
+    /** The vault's registered payout scriptPubKey, hex. */
+    readonly expectedScriptHex: string;
+    /** The scriptPubKey the Payout actually pays, hex. */
+    readonly actualScriptHex: string;
+    constructor(
+    /** The vault's registered payout scriptPubKey, hex. */
+    expectedScriptHex: string, 
+    /** The scriptPubKey the Payout actually pays, hex. */
+    actualScriptHex: string);
+}
+/**
+ * The Payout to check, and the destination it must pay.
+ *
+ * @experimental
+ */
+export interface AssertPayoutPaysRegisteredScriptParams {
+    /** A Payout signing PSBT, base64, as the graph produced it. */
+    payoutPsbtBase64: string;
+    /**
+     * `depositorPayoutScriptPubKey` as the vault registered it on chain, hex.
+     * The vault provider does not choose this value, which is the whole point
+     * of comparing against it.
+     */
+    registeredPayoutScriptPubKey: string;
+}
+/**
+ * Throws unless the Payout pays the vault's registered payout script.
+ *
+ * Run this on every Payout PSBT before the wallet is prompted. Both the
+ * depositor and the claimer PSBT describe the same transaction, so both must
+ * pass; checking only one would leave the other free to differ.
+ *
+ * @throws {@link PayoutDestinationError} when output 0 pays elsewhere, or a
+ *         plain error when the layout is not the canonical claimer layout.
+ *
+ * @experimental
+ */
+export declare function assertPayoutPaysRegisteredScript(params: AssertPayoutPaysRegisteredScriptParams): void;
+//# sourceMappingURL=payoutBinding.d.ts.map

package/dist/tbv/core/services/delegated-claim/payoutBinding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payoutBinding.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/payoutBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAgBH;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;IAE7C,uDAAuD;IACvD,QAAQ,CAAC,iBAAiB,EAAE,MAAM;IAClC,sDAAsD;IACtD,QAAQ,CAAC,eAAe,EAAE,MAAM;;IAHhC,uDAAuD;IAC9C,iBAAiB,EAAE,MAAM;IAClC,sDAAsD;IAC7C,eAAe,EAAE,MAAM;CAUnC;AAED;;;;GAIG;AACH,MAAM,WAAW,sCAAsC;IACrD,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,4BAA4B,EAAE,MAAM,CAAC;CACtC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,sCAAsC,GAC7C,IAAI,CAmDN"}

package/dist/tbv/core/services/delegated-claim/readWatchtowerArtifacts.d.ts

@@ -0,0 +1,70 @@
+import { WatchtowerArtifactsSummary } from './types';
+/**
+ * Graph version the delegated-claim artifacts format exists for. Vaults on
+ * graph v1 and v2 predate it and have no artifacts path at all.
+ *
+ * @experimental
+ */
+export declare const DELEGATED_CLAIM_TX_GRAPH_VERSION = 3;
+/**
+ * Thrown when an artifacts file does not describe the vault being claimed.
+ *
+ * @experimental
+ */
+export declare class ArtifactsVaultMismatchError extends Error {
+    readonly expectedVaultId: string;
+    readonly actualVaultId: string;
+    constructor(expectedVaultId: string, actualVaultId: string);
+}
+/**
+ * Reads the small, self-describing fields of an artifacts file.
+ *
+ * This parses the whole JSON, so it is bounded by whatever the file carries
+ * in `babe_sessions`. Keep those sessions in their own file: a bundle with
+ * real sessions runs to hundreds of megabytes per challenger and cannot be
+ * parsed in a browser tab.
+ *
+ * Experimental: this API can change in a minor release. Pin the SDK
+ * version if you build on it.
+ *
+ * @throws If the file is not JSON, or lacks the fields every artifacts file
+ *         has.
+ * @experimental
+ */
+export declare function summarizeWatchtowerArtifacts(artifactsJson: string): WatchtowerArtifactsSummary;
+/**
+ * The file to check, and the vault it must belong to.
+ *
+ * @experimental
+ */
+export interface AssertArtifactsUsableParams {
+    artifactsJson: string;
+    /** Vault the caller intends to claim, `0x`-prefixed or bare hex. */
+    expectedVaultId: string;
+    /**
+     * Depositor's Ethereum address, used with the file's PegIn txid to
+     * re-derive the vault id. Without it the only check would be the file's
+     * self-declared `vault_id`.
+     */
+    depositorEthAddress: string;
+    /**
+     * Graph version to verify under. Defaults to the only version the format
+     * exists for. A file that records a different `vault_core_version` is
+     * rejected rather than verified under this one.
+     */
+    txGraphVersion?: number;
+}
+/**
+ * Verifies an artifacts file and confirms it is the one for this vault.
+ *
+ * Experimental: this API can change in a minor release. Pin the SDK
+ * version if you build on it.
+ *
+ * @throws {@link ArtifactsVaultMismatchError} when the file names a different
+ *         vault, {@link VaultIdBindingError} when the graph it carries
+ *         belongs to another vault whatever the file says, or a verification
+ *         error when any bundled signature does not hold against that graph.
+ * @experimental
+ */
+export declare function assertArtifactsUsableForVault(params: AssertArtifactsUsableParams): Promise<WatchtowerArtifactsSummary>;
+//# sourceMappingURL=readWatchtowerArtifacts.d.ts.map

package/dist/tbv/core/services/delegated-claim/readWatchtowerArtifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readWatchtowerArtifacts.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/readWatchtowerArtifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAO1D;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,IAAI,CAAC;AAElD;;;;GAIG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IAElD,QAAQ,CAAC,eAAe,EAAE,MAAM;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM;gBADrB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM;CAQjC;AAYD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,MAAM,GACpB,0BAA0B,CA2C5B;AAED;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,0BAA0B,CAAC,CA+CrC"}