@babylonlabs-io/ts-sdk 3.0.2 → 3.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"payoutInputLeaf.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/payoutInputLeaf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,oBAAoB;AACpB,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B;AAED,oBAAoB;AACpB,MAAM,WAAW,6BAA6B;IAC5C,yBAAyB,EAAE,MAAM,CAAC;IAClC,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,6BAA6B,GACpC,MAAM,CAoCR"}

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

@@ -0,0 +1,43 @@
+import { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+import { DelegatedClaimPsbtSet } from './signingRequests';
+import { ClaimerArtifactsSource, DelegatedClaimSigningPlan, DelegatedClaimVaultContext } from './types';
+/** @experimental */
+export interface PlanDelegatedClaimSigningParams {
+    /**
+     * Depositor's BTC public key (compressed or x-only hex). A vault that
+     * registered a P2WPKH payout script needs the compressed key here, as at
+     * registration: the x-only form cannot derive a P2WPKH script.
+     */
+    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;
+    /** See {@link DelegatedClaimSigningPlan.trustedVerifyingKeyHex}. */
+    trustedVerifyingKeyHex: string;
+    vault: DelegatedClaimVaultContext;
+    /** See {@link AssembleWatchtowerArtifactsParams.babeSessionsJson}. */
+    babeSessionsJson?: string;
+}
+/**
+ * Build the five PSBT groups from the graph and run every binding check.
+ * Shared with the assembler, which rebuilds the same set to prove the plan
+ * it is given was not altered.
+ *
+ * @internal
+ * @experimental
+ */
+export declare function buildBoundPsbtSet(txGraphVersion: number, graphJson: string, vault: DelegatedClaimVaultContext, depositorPublicKey: string): Promise<DelegatedClaimPsbtSet>;
+/**
+ * @throws If the vault provider's verifying key is not the trusted one, if
+ *         `depositorPublicKey` is not the vault's registered depositor key,
+ *         the registered payout script is not derived from it,
+ *         the graph version and the vault context's vault core version
+ *         disagree, the graph is not version 3, any binding check fails, or
+ *         the Payout's CSV sequences, declared prevout amounts or implicit fee
+ *         do not match the vault's stamped timelocks, its PegIn and Assert
+ *         outputs, and the fee band.
+ * @experimental
+ */
+export declare function planDelegatedClaimSigning(params: PlanDelegatedClaimSigningParams): Promise<DelegatedClaimSigningPlan>;
+//# sourceMappingURL=planDelegatedClaimSigning.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planDelegatedClaimSigning.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/planDelegatedClaimSigning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAkBrE,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAQjB,oBAAoB;AACpB,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0EAA0E;IAC1E,UAAU,EAAE,OAAO,CAAC;IACpB,mEAAmE;IACnE,MAAM,EAAE,sBAAsB,CAAC;IAC/B,oEAAoE;IACpE,sBAAsB,EAAE,MAAM,CAAC;IAC/B,KAAK,EAAE,0BAA0B,CAAC;IAClC,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,0BAA0B,EACjC,kBAAkB,EAAE,MAAM,GACzB,OAAO,CAAC,qBAAqB,CAAC,CAmHhC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,+BAA+B,GACtC,OAAO,CAAC,yBAAyB,CAAC,CAyBpC"}

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

@@ -0,0 +1,70 @@
+import { Address, Hex } from 'viem';
+import { PeginRegistrationRecord, ProtocolParamsReader, VaultData, VaultRegistryReader, VersionedOffchainParams } from '../../clients/eth/types';
+import { StampedParticipantKeyReaders } from '../participants/readStampedParticipantKeys';
+import { ParticipantKeySet } from '../participants/types';
+import { DelegatedClaimVaultContext } from './types';
+/** @experimental */
+export interface DelegatedClaimVaultReaders extends StampedParticipantKeyReaders {
+    registryReader: Pick<VaultRegistryReader, "getVaultData" | "getVaultKeyEpochs" | "getVaultProviderGenesisBtcPubKey" | "getRegistrationRecordsAtBlock" | "getVaultClaimableBy">;
+    protocolParamsReader: Pick<ProtocolParamsReader, "getOffchainParamsByVersion">;
+}
+/** @experimental */
+export interface ReadDelegatedClaimVaultContextParams {
+    vaultId: Hex;
+    readers: DelegatedClaimVaultReaders;
+}
+/**
+ * The context, plus the sibling facts a claim needs that the context does not
+ * carry: the on-chain WOTS commitment (`deriveClaimerWotsKeypair.expectedWotsPkHash`),
+ * what `buildVaultContextInputForClaim` takes, and every record this read
+ * already fetched that `rebuildDepositTermsForClaim` would otherwise fetch
+ * again — it takes this whole object rather than a vault id.
+ *
+ * @experimental
+ */
+export interface DelegatedClaimVaultRead {
+    context: DelegatedClaimVaultContext;
+    /** The target's registry record, as read here. */
+    vault: VaultData;
+    /** The target's own `PegInSubmittedV2` log. */
+    registrationRecord: PeginRegistrationRecord;
+    /** Every log in the target's registration block, the batch's siblings among them. */
+    registrationRecords: readonly PeginRegistrationRecord[];
+    /** Participant operation keys resolved at the vault's stamped versions and epochs. */
+    participantKeys: ParticipantKeySet;
+    /** The offchain params snapshot at `protocol.offchainParamsVersion`. */
+    offchainParams: VersionedOffchainParams;
+    /** `VaultBasicInfo.depositorBtcPubKey` verbatim, for `buildVaultContextInputForClaim`. */
+    depositorBtcPubKeyBytes32: Hex;
+    depositorWotsPkHash: Hex;
+    prePeginTxHash: Hex;
+    /**
+     * Txid of the vault's depositor-signed PegIn, derived here through the
+     * dependency-free parser and cross-checked against both logs. The vault
+     * provider indexes a deposit's artifacts and auth tokens by it.
+     */
+    peginTxHash: Hex;
+    /** The vault's registered vault provider, which addresses its VP proxy. */
+    vaultProvider: Address;
+    htlcVout: number;
+}
+/**
+ * @throws When the vault's core version is not the delegated-claim graph
+ *         version; when the depositor-signed PegIn carries no output
+ *         {@link PEGIN_VAULT_OUTPUT_INDEX}; when the registration log, the
+ *         redemption log, the vault record and the stamped offchain params
+ *         disagree on a shared field;
+ *         when the PegIn does not derive the vault id asked for; when it does
+ *         not have exactly one input, or that input does not spend the
+ *         record's Pre-PegIn at its `htlcVout`;
+ *         when output {@link PEGIN_VAULT_OUTPUT_INDEX} is not
+ *         worth `basic.amount`; and whatever the readers throw (notably the
+ *         typed `VaultClaimableByNotFoundError`). The
+ *         disagreement checks are inconsistent-node guards only: on an honest
+ *         chain both logs are written from the same contract state as the
+ *         record (`PeginLogic.sol:379-380`, `RedeemLogic.sol:118-124`) and
+ *         cannot differ.
+ * @experimental
+ */
+export declare function readDelegatedClaimVaultContext(params: ReadDelegatedClaimVaultContextParams): Promise<DelegatedClaimVaultRead>;
+//# sourceMappingURL=readDelegatedClaimVaultContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"readDelegatedClaimVaultContext.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/readDelegatedClaimVaultContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAiBzC,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC7B,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAG1D,oBAAoB;AACpB,MAAM,WAAW,0BACf,SAAQ,4BAA4B;IACpC,cAAc,EAAE,IAAI,CAClB,mBAAmB,EACjB,cAAc,GACd,mBAAmB,GACnB,kCAAkC,GAClC,+BAA+B,GAC/B,qBAAqB,CACxB,CAAC;IACF,oBAAoB,EAAE,IAAI,CACxB,oBAAoB,EACpB,4BAA4B,CAC7B,CAAC;CACH;AAED,oBAAoB;AACpB,MAAM,WAAW,oCAAoC;IACnD,OAAO,EAAE,GAAG,CAAC;IACb,OAAO,EAAE,0BAA0B,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,0BAA0B,CAAC;IACpC,kDAAkD;IAClD,KAAK,EAAE,SAAS,CAAC;IACjB,+CAA+C;IAC/C,kBAAkB,EAAE,uBAAuB,CAAC;IAC5C,qFAAqF;IACrF,mBAAmB,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACxD,sFAAsF;IACtF,eAAe,EAAE,iBAAiB,CAAC;IACnC,wEAAwE;IACxE,cAAc,EAAE,uBAAuB,CAAC;IACxC,0FAA0F;IAC1F,yBAAyB,EAAE,GAAG,CAAC;IAC/B,mBAAmB,EAAE,GAAG,CAAC;IACzB,cAAc,EAAE,GAAG,CAAC;IACpB;;;;OAIG;IACH,WAAW,EAAE,GAAG,CAAC;IACjB,2EAA2E;IAC3E,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,oCAAoC,GAC3C,OAAO,CAAC,uBAAuB,CAAC,CA8PlC"}

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

@@ -47,6 +47,30 @@ export interface AssertArtifactsUsableParams {
      * self-declared `vault_id`.
      */
     depositorEthAddress: string;
+    /**
+     * The Groth16 verifying key for the vault's `proverCircuitVersion`, from
+     * the `vault-provers` release or the prover service — never from the vault
+     * provider or anything it serves (btc-vault `delegated_claim.rs:405-414`
+     * @ ac4954e7). A file carrying a different key proves nothing at Assert.
+     */
+    trustedVerifyingKeyHex: string;
+    /**
+     * The vault's stamped `proverCircuitVersion`, from
+     * `DelegatedClaimVaultContext`. btc-vault's verifier never reads the
+     * file's own `prover_circuit_version` — `delegated_claim.rs:864` @ ac4954e7
+     * only writes it — while `vaultd`'s
+     * `crates/vaultd/src/cli/command/watchtower/start_claim.rs:266-278` hands
+     * the file's key and version to the prover together, so a wrong version
+     * fails there, before Assert.
+     */
+    expectedProverCircuitVersion: number;
+    /**
+     * The block of the vault's finalized `VaultClaimableBy` event, from
+     * `DelegatedClaimVaultContext.claimableEventBlockNumber`. Unverified by
+     * btc-vault like the circuit version, and handed to the prover beside it
+     * (`start_claim.rs:270,274` @ ac4954e7), so a wrong block fails there too.
+     */
+    expectedClaimableEventBlockNumber: bigint;
     /**
      * Graph version to verify under. Defaults to the only version the format
      * exists for. A file that records a different `vault_core_version` is
@@ -62,8 +86,13 @@ export interface AssertArtifactsUsableParams {
  *
  * @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.
+ *         belongs to another vault whatever the file says, a plain error when
+ *         its `prover_circuit_version` is not `expectedProverCircuitVersion`,
+ *         its `claimable_event_block_number` is not
+ *         `expectedClaimableEventBlockNumber`,
+ *         its `verifying_key` is not `trustedVerifyingKeyHex` or any BaBe
+ *         session is still the placeholder, or a verification error when any
+ *         bundled signature does not hold against that graph.
  * @experimental
  */
 export declare function assertArtifactsUsableForVault(params: AssertArtifactsUsableParams): Promise<WatchtowerArtifactsSummary>;

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

@@ -1 +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"}
+{"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;AAS1D;;;;;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;AAkDD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,MAAM,GACpB,0BAA0B,CAiD5B;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;;;;;OAKG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAC/B;;;;;;;;OAQG;IACH,4BAA4B,EAAE,MAAM,CAAC;IACrC;;;;;OAKG;IACH,iCAAiC,EAAE,MAAM,CAAC;IAC1C;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,0BAA0B,CAAC,CAoGrC"}

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

@@ -0,0 +1,110 @@
+import { BitcoinWallet, SignPsbtOptions } from '../../../../shared/wallets/interfaces';
+import { DepositTerms } from '../../deposit-terms/depositTerms';
+import { VaultContextInput } from '../../vault-secrets';
+import { DelegatedClaimSignatures, DelegatedClaimSigningPlan, DelegatedClaimVaultContext } from './types';
+/**
+ * The claim-ceremony signing capability an approval wallet must add: its
+ * device signs some claim PSBTs with no loaded intent and needs its own
+ * derivation fields on them, which only the provider can write. Implementers
+ * MUST classify each PSBT themselves from the single requested input and
+ * refuse anything that is not one of the claim ceremony's shapes — this is
+ * not a second `signPsbt`. The SDK cannot enforce that and does not rely on
+ * it: the wallet is proved to be the depositor's before any prompt, and every
+ * returned signature is verified against the PSBT that requested it. The SDK
+ * probes for the method before it prompts.
+ *
+ * @experimental
+ */
+export interface DelegatedClaimPsbtSigner {
+    signDelegatedClaimPsbt(psbtHex: string, options?: SignPsbtOptions): Promise<string>;
+}
+/**
+ * Options for {@link signDelegatedClaimPlan}.
+ *
+ * @experimental
+ */
+export interface SignDelegatedClaimPlanOptions {
+    /**
+     * Required for approval-capable wallets: the terms that load the vault's
+     * intent on the device. Resume flows rebuild them from on-chain state.
+     */
+    depositTerms?: DepositTerms;
+    /**
+     * Required for approval-capable wallets: the context the vault root derives
+     * from; its depositor key must be the vault's registered key, checked before
+     * any device I/O.
+     */
+    vaultContext?: VaultContextInput;
+    /**
+     * Signatures from an earlier, incomplete run of this same plan. Each is
+     * verified against its request before it is reused; only standalone kinds
+     * are reused, intent-bound ones are always re-signed. Applies to approval
+     * wallets only: a software wallet always re-signs everything and ignores
+     * this — one prompt for a wallet with native `signPsbts`, one prompt per
+     * PSBT otherwise (the sequential fallback), and a cancel restarts the set.
+     */
+    resume?: DelegatedClaimSignatures;
+    /**
+     * Checked before every wallet prompt. The check before either path throws
+     * the aborted signal's reason. Inside the approval ceremony, once the map
+     * holds a signature — a verified resumed standalone entry counts — a stop is
+     * reported as {@link DelegatedClaimSigningIncompleteError} with the reason as
+     * `cause`, so the collected signatures survive for `resume`; while the map is
+     * still empty the reason is thrown as is.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Thrown when an approval-wallet run stops before it reaches the end.
+ *
+ * Carries what was collected so a retry can pass it as `resume`. A retry
+ * drops the intent-bound signatures and re-signs only those, so a stop in the
+ * final intent release after every standalone request was resumed re-runs
+ * only the intent-bound part of the ceremony — even though the map it carries
+ * is complete by then. Never persist the map as artifacts: only the assembler
+ * verifies it as a set.
+ *
+ * @experimental
+ */
+export declare class DelegatedClaimSigningIncompleteError extends Error {
+    readonly signatures: DelegatedClaimSignatures;
+    /**
+     * The request the ceremony is to resume from — not necessarily the one
+     * that failed: a stop in the intent release or approval is reported
+     * against the request it was about to reach. The message says which.
+     */
+    readonly failedRequestId: string;
+    constructor(message: string, signatures: DelegatedClaimSignatures, 
+    /**
+     * The request the ceremony is to resume from — not necessarily the one
+     * that failed: a stop in the intent release or approval is reported
+     * against the request it was about to reach. The message says which.
+     */
+    failedRequestId: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * The plan must come from `planDelegatedClaimSigning`: the signer
+ * signs it as given and does not rebuild it. A plan altered in between is
+ * rejected at assembly by `assembleWatchtowerArtifactsFromSignatures`, which
+ * rebuilds every PSBT from the graph, and a hardware wallet displays what it
+ * signs.
+ *
+ * @returns Signatures keyed by request id, one per request in the plan.
+ * @experimental
+ */
+export declare function signDelegatedClaimPlan(plan: DelegatedClaimSigningPlan, wallet: BitcoinWallet, opts?: SignDelegatedClaimPlanOptions): Promise<DelegatedClaimSignatures>;
+/**
+ * Every field the terms and the vault context both carry must agree: the
+ * rosters, the vault core version, the two CSV timelocks, the protocol fee
+ * rate, and the vault provider key of each group the terms describe.
+ * Otherwise the device binds the Assert to another deposit's intent.
+ *
+ * Exported so a claim-time terms builder can be checked against the context
+ * it will be signed with, before any device session.
+ *
+ * @experimental
+ */
+export declare function assertTermsMatchVault(terms: DepositTerms, vault: DelegatedClaimVaultContext): void;
+//# sourceMappingURL=signDelegatedClaimPlan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signDelegatedClaimPlan.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/signDelegatedClaimPlan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EAChB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,kCAAkC,CAAC;AAK1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAI7D,OAAO,KAAK,EACV,wBAAwB,EAExB,yBAAyB,EAEzB,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAQjB;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,wBAAwB;IACvC,sBAAsB,CACpB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC,CAAC;CACpB;AAYD;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;OAIG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAClC;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,oCAAqC,SAAQ,KAAK;IAG3D,QAAQ,CAAC,UAAU,EAAE,wBAAwB;IAC7C;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM;gBAPhC,OAAO,EAAE,MAAM,EACN,UAAU,EAAE,wBAAwB;IAC7C;;;;OAIG;IACM,eAAe,EAAE,MAAM,EAChC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAKhC;AA6BD;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,yBAAyB,EAC/B,MAAM,EAAE,aAAa,EACrB,IAAI,GAAE,6BAAkC,GACvC,OAAO,CAAC,wBAAwB,CAAC,CA8CnC;AAuFD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,0BAA0B,GAChC,IAAI,CAuDN"}

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

@@ -0,0 +1,24 @@
+import { DelegatedClaimSigningRequest } from './types';
+/**
+ * The five PSBT groups the WASM builders produce, all base64.
+ *
+ * @experimental
+ */
+export interface DelegatedClaimPsbtSet {
+    claim: string;
+    assert: string;
+    payoutClaimer: string;
+    payoutDepositor: string;
+    wronglyChallenged: Record<string, string[]>;
+}
+/**
+ * Stable id of a WronglyChallenged request.
+ *
+ * @experimental
+ */
+export declare function wronglyChallengedRequestId(challengerPubkey: string, gcIndex: number): string;
+/**
+ * @experimental
+ */
+export declare function buildDelegatedClaimSigningRequests(psbts: DelegatedClaimPsbtSet): DelegatedClaimSigningRequest[];
+//# sourceMappingURL=signingRequests.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signingRequests.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/signingRequests.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AASH,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC7C;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,MAAM,GACd,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,qBAAqB,GAC3B,4BAA4B,EAAE,CAsChC"}

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

@@ -1,4 +1,6 @@
+import { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
 import { Hex } from 'viem';
+import { OnChainBtcPubkey } from '../../clients/eth/types';
 /**
  * The small, non-opaque fields of an `artifacts.json` file.
  *
@@ -32,9 +34,34 @@ export interface WatchtowerArtifactsSummary {
      * boundary — a block number is a u64 there.
      */
     claimableEventBlockNumber: bigint;
+    /**
+     * Groth16 verifying key the file carries (`verifying_key`, btc-vault
+     * `delegated_claim.rs:514` @ ac4954e7). Compared with the caller's trusted
+     * key by `assertArtifactsUsableForVault`.
+     */
+    verifyingKeyHex: string;
     /** Hex challenger public keys the file carries BaBe sessions for. */
     babeSessionChallengerPubkeys: string[];
+    /**
+     * Challengers whose session is still
+     * {@link BABE_SESSION_PLACEHOLDER_DECRYPTOR_HEX}. Such a file verifies but
+     * cannot answer that challenger, so `assertArtifactsUsableForVault` refuses
+     * it.
+     */
+    babeSessionPlaceholderChallengerPubkeys: string[];
 }
+/**
+ * The `decryptor_artifacts_hex` a browser caller writes per challenger when
+ * the real BaBe sessions are too large to hold in a tab.
+ *
+ * btc-vault only checks that the value is non-empty hex
+ * (`delegated_claim.rs:473-483` @ ac4954e7), so a file built from it verifies
+ * yet cannot answer a challenge — join the real sessions in before using it.
+ * #2598 tracks making an empty map a first-class "not joined yet" state.
+ *
+ * @experimental
+ */
+export declare const BABE_SESSION_PLACEHOLDER_DECRYPTOR_HEX = "00";
 /**
  * Inputs the vault provider supplies for artifact assembly.
  *
@@ -44,16 +71,15 @@ export interface ClaimerArtifactsSource {
     /** `tx_graph_json` from `requestDepositorClaimerArtifacts`. */
     txGraphJson: string;
     /**
-     * `verifying_key_hex` from the same response.
+     * `verifying_key_hex` from the same response — the vault provider's own
+     * copy, never used as-is.
      *
-     * Trusted from the vault provider. This value is written into the
-     * artifacts file and is the key `pinPegoutProof` later verifies the
-     * Groth16 proof against, so a provider that supplies a key of its own
-     * choosing makes that verification prove nothing. No registry read in
-     * this SDK exposes a verifying key, or a hash of one, per
-     * `proverCircuitVersion`, so there is nothing to compare it with yet.
-     * Obtain it over an authenticated channel, and re-check it here once the
-     * chain exposes an anchor.
+     * It is the key `pinPegoutProof` later verifies the Groth16 proof against,
+     * so a provider that supplies a key of its own choosing makes that
+     * verification prove nothing. The planner compares it byte for byte with
+     * {@link DelegatedClaimSigningPlan.trustedVerifyingKeyHex} before any
+     * wallet prompt and refuses on any difference; only the trusted value
+     * reaches the file.
      */
     verifyingKeyHex: string;
 }
@@ -70,6 +96,12 @@ export interface DelegatedClaimVaultContext {
      * which is how a vault-provider-served graph is bound to this vault.
      */
     depositorEthAddress: Hex;
+    /**
+     * The vault's registered depositor BTC key
+     * (`getBtcVaultBasicInfo(...).depositorBtcPubKey`, x-only). The claim scripts
+     * are bound to it, and the plan's `depositorPublicKey` must equal it.
+     */
+    depositorBtcPubkey: OnChainBtcPubkey;
     /**
      * `depositorPayoutScriptPubKey` as the vault registered it on chain, hex.
      * The Payout the vault provider builds is checked against this before the
@@ -101,5 +133,74 @@ export interface DelegatedClaimVaultContext {
      * Pass the real block whenever the event has already finalized.
      */
     claimableEventBlockNumber: bigint;
+    /**
+     * Value of output 0 of the vault's depositor-signed PegIn, in sats, parsed
+     * from `VaultData.protocol.depositorSignedPeginTx`. The Payout's input 0
+     * spends that output (btc-vault `payout.rs:103-112` @ ac4954e7), so it is
+     * one of the two amounts the claim-time fee band is measured over.
+     */
+    peginVaultOutputValueSats: number;
+    /** `feeRate` of the vault's stamped `getOffchainParamsByVersion`, sat/vB. */
+    protocolFeeRate: bigint;
+    /** `securityCouncilKeys.length` of the same stamped offchain params. */
+    councilSize: number;
+    /**
+     * `timelockAssert` of the stamped params, which btc-vault uses as the PegIn
+     * timelock too (vaultd `pegin_babe_setup.rs:794`, `pegin_validation.rs:417`
+     * @ ac4954e7) — the CSV sequence of Payout input 0.
+     */
+    timelockPegin: number;
+    /** `timelockAssert` of the stamped params — the CSV sequence of Payout input 1. */
+    timelockAssert: number;
+}
+/**
+ * Which delegated-claim transaction a signing request is for.
+ *
+ * @experimental
+ */
+export type DelegatedClaimSigningKind = "claim" | "assert" | "payoutClaimer" | "payoutDepositor" | "wronglyChallenged";
+/**
+ * One PSBT the depositor must sign, with the input to sign and a stable id
+ * the signatures are keyed by.
+ *
+ * @experimental
+ */
+export interface DelegatedClaimSigningRequest {
+    /** `kind`, or `wronglyChallenged:<challenger x-only hex>:<gcIndex>`. */
+    readonly id: string;
+    readonly kind: DelegatedClaimSigningKind;
+    readonly psbtBase64: string;
+    readonly inputIndex: number;
+}
+/**
+ * Everything one delegated-claim signing session needs, built once and
+ * signed by whichever wallet path fits. Treat as immutable: the assembler
+ * rebuilds every PSBT from the graph and byte-compares against this.
+ *
+ * @experimental
+ */
+export interface DelegatedClaimSigningPlan {
+    readonly depositorPublicKey: string;
+    readonly btcNetwork: Network;
+    readonly source: ClaimerArtifactsSource;
+    /**
+     * The Groth16 verifying key for {@link DelegatedClaimVaultContext.proverCircuitVersion},
+     * obtained from the `vault-provers` release or the prover service — never
+     * from the vault provider or anything it serves. btc-vault
+     * `delegated_claim.rs:405-414` @ ac4954e7: the builder cannot tell a
+     * substituted key from the real one, and a substituted key would let a
+     * proof the depositor never authorized pass the pre-Assert check. This is
+     * the value written into the file.
+     */
+    readonly trustedVerifyingKeyHex: string;
+    readonly vault: DelegatedClaimVaultContext;
+    readonly babeSessionsJson?: string;
+    readonly requests: readonly DelegatedClaimSigningRequest[];
 }
+/**
+ * 64-byte Schnorr signatures (hex) keyed by {@link DelegatedClaimSigningRequest.id}.
+ *
+ * @experimental
+ */
+export type DelegatedClaimSignatures = ReadonlyMap<string, string>;
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;;;;;OAQG;IACH,yBAAyB,EAAE,MAAM,CAAC;IAClC,qEAAqE;IACrE,4BAA4B,EAAE,MAAM,EAAE,CAAC;CACxC;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;OAWG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,GAAG,CAAC;IACb;;;;OAIG;IACH,mBAAmB,EAAE,GAAG,CAAC;IACzB;;;;OAIG;IACH,4BAA4B,EAAE,MAAM,CAAC;IACrC,2EAA2E;IAC3E,sBAAsB,EAAE,MAAM,CAAC;IAC/B,8EAA8E;IAC9E,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,iDAAiD;IACjD,6BAA6B,EAAE,MAAM,EAAE,CAAC;IACxC,2EAA2E;IAC3E,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;;;OAQG;IACH,yBAAyB,EAAE,MAAM,CAAC;CACnC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/types.ts"],"names":[],"mappings":"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"}

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

@@ -10,10 +10,17 @@ export declare class VaultIdBindingError extends Error {
     readonly peginTxid: string;
     constructor(expectedVaultId: string, derivedVaultId: string, peginTxid: string);
 }
-/** Display-order txid of the PegIn output the Claim PSBT spends. */
+/**
+ * Display-order txid of the PegIn output the Claim PSBT spends.
+ *
+ * @throws Unless the Claim has exactly one input and it spends PegIn output 1
+ *         (CLAUDE.md §3 funding-chain rule).
+ */
 export declare function peginTxidFromClaimPsbt(claimPsbtBase64: string): string;
 /**
  * Display-order txid of the PegIn output a signed Claim transaction spends.
+ *
+ * @throws Unless the Claim has exactly one input and it spends PegIn output 1.
  */
 export declare function peginTxidFromClaimTx(claimTx: Transaction): string;
 /**
@@ -41,4 +48,12 @@ export interface AssertClaimSpendsVaultParams {
 export declare function assertClaimSpendsVault(params: AssertClaimSpendsVaultParams): void;
 /** Lowercase, `0x`-prefixed form of a 32-byte vault id. */
 export declare function normalizeVaultId(vaultId: string): string;
+/**
+ * Bitcoin stores a prevout hash in internal byte order; a txid is the same
+ * bytes reversed. Copies before reversing — the buffer belongs to the parsed
+ * transaction.
+ *
+ * @internal
+ */
+export declare function displayTxid(internalHash: Uint8Array): string;
 //# sourceMappingURL=vaultIdBinding.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vaultIdBinding.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/vaultIdBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAQ,WAAW,EAAE,MAAM,eAAe,CAAC;AAWlD;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAE1C,QAAQ,CAAC,eAAe,EAAE,MAAM;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM;gBAFjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM;CAU7B;AAED,oEAAoE;AACpE,wBAAgB,sBAAsB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAYtE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAQjE;AAED;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mDAAmD;IACnD,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,4BAA4B,GACnC,IAAI,CAQN;AAED,2DAA2D;AAC3D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGxD"}
+{"version":3,"file":"vaultIdBinding.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/vaultIdBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAQ,WAAW,EAAE,MAAM,eAAe,CAAC;AAOlD;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAE1C,QAAQ,CAAC,eAAe,EAAE,MAAM;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM;gBAFjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM;CAU7B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAiBtE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAajE;AAqBD;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mDAAmD;IACnD,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,4BAA4B,GACnC,IAAI,CAQN;AAED,2DAA2D;AAC3D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,UAAU,GAAG,MAAM,CAE5D"}

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

@@ -0,0 +1,19 @@
+import { DelegatedClaimSigningPlan, DelegatedClaimSigningRequest } from './types';
+/**
+ * @throws If `signatureHex` is not a valid script-path signature by the
+ *         plan's depositor over `request`'s PSBT and input.
+ * @internal
+ * @experimental
+ */
+export declare function assertSignatureForRequest(plan: DelegatedClaimSigningPlan, request: DelegatedClaimSigningRequest, signatureHex: string): void;
+/**
+ * @internal
+ * @experimental
+ */
+export declare function psbtBase64ToHex(psbtBase64: string): string;
+/**
+ * @internal
+ * @experimental
+ */
+export declare function psbtHexToBase64(psbtHex: string): string;
+//# sourceMappingURL=verifySignatureForRequest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verifySignatureForRequest.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/verifySignatureForRequest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAGvF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,yBAAyB,EAC/B,OAAO,EAAE,4BAA4B,EACrC,YAAY,EAAE,MAAM,GACnB,IAAI,CAON;AAKD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD"}

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

@@ -0,0 +1,40 @@
+/**
+ * Binding between the Groth16 verifying key a claim runs under and the one
+ * the depositor trusts.
+ *
+ * btc-vault takes the key opaquely and only checks that the bytes parse
+ * (`delegated_claim.rs:405-414` @ ac4954e7): "Must come from a trusted source
+ * … never from the vault provider or any artifact the vault provider serves.
+ * … a substituted key would let a proof the depositor never authorized pass
+ * the pre-Assert check. Compare the VP-served key byte for byte against this
+ * trusted value before signing." That comparison is what lives here.
+ *
+ * @module services/delegated-claim/verifyingKeyBinding
+ */
+/**
+ * The one form two verifying keys can be compared in: lowercase hex, no `0x`.
+ *
+ * @throws If the value is empty or is not even-length hex — an unparseable
+ *         key would otherwise compare equal to another unparseable one.
+ * @internal
+ */
+export declare function normalizeVerifyingKeyHex(value: string, label: string): string;
+/** @internal */
+interface AssertVerifyingKeyIsTrustedParams {
+    /** The key as the vault provider served it. */
+    servedVerifyingKeyHex: string;
+    /** The key for {@link AssertVerifyingKeyIsTrustedParams.proverCircuitVersion}, from the vault-provers release or the prover service. */
+    trustedVerifyingKeyHex: string;
+    proverCircuitVersion: number;
+}
+/**
+ * Throws unless the vault-provider-served verifying key is the trusted one.
+ *
+ * @returns The trusted key in the form btc-vault decodes it: bare lowercase
+ *          hex (`hex::decode`, `delegated_claim.rs:569-571` @ ac4954e7,
+ *          rejects a `0x` prefix).
+ * @internal
+ */
+export declare function assertVerifyingKeyIsTrusted(params: AssertVerifyingKeyIsTrustedParams): string;
+export {};
+//# sourceMappingURL=verifyingKeyBinding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verifyingKeyBinding.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/verifyingKeyBinding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7E;AAED,gBAAgB;AAChB,UAAU,iCAAiC;IACzC,+CAA+C;IAC/C,qBAAqB,EAAE,MAAM,CAAC;IAC9B,wIAAwI;IACxI,sBAAsB,EAAE,MAAM,CAAC;IAC/B,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,iCAAiC,GACxC,MAAM,CAeR"}

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

@@ -0,0 +1,23 @@
+import { Network } from '@babylonlabs-io/babylon-tbv-rust-wasm';
+import { BitcoinWallet } from '../../../../shared/wallets/interfaces';
+/**
+ * The 32-byte x-only form of a compressed or x-only public key, lowercase.
+ *
+ * @experimental
+ */
+export declare function xOnlyHex(publicKeyHex: string): string;
+/**
+ * Returns the wallet's signing address, once both it and the wallet's public
+ * key are proved to be the vault's depositor.
+ *
+ * Both halves matter. The public key is what the graph's scripts commit to;
+ * the address is what the sign options name the signer by, and a wallet whose
+ * reported address and public key belong to different accounts would
+ * otherwise sign the whole batch for the wrong account.
+ *
+ * @throws When the wallet is on a different account than the vault's
+ *         depositor, or reports an address that key does not control.
+ * @experimental
+ */
+export declare function assertWalletMatchesDepositor(btcWallet: BitcoinWallet, depositorPublicKey: string, btcNetwork: Network): Promise<string>;
+//# sourceMappingURL=walletIdentity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"walletIdentity.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/delegated-claim/walletIdentity.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAErE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAW3E;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAQrD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,4BAA4B,CAChD,SAAS,EAAE,aAAa,EACxB,kBAAkB,EAAE,MAAM,EAC1B,UAAU,EAAE,OAAO,GAClB,OAAO,CAAC,MAAM,CAAC,CAqBjB"}