@babylonlabs-io/ts-sdk 0.17.1 → 0.19.0

package/dist/tbv/core/contracts/abis/BTCVaultRegistry.abi.d.ts

@@ -283,5 +283,79 @@ export declare const BTCVaultRegistryABI: readonly [{
     readonly type: "error";
     readonly name: "PeginSignaturesIncomplete";
     readonly inputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "getBtcVaultProtocolInfo";
+    readonly inputs: readonly [{
+        readonly name: "vaultId";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "depositorSignedPeginTx";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "universalChallengersVersion";
+        readonly type: "uint32";
+        readonly internalType: "uint32";
+    }, {
+        readonly name: "appVaultKeepersVersion";
+        readonly type: "uint32";
+        readonly internalType: "uint32";
+    }, {
+        readonly name: "offchainParamsVersion";
+        readonly type: "uint32";
+        readonly internalType: "uint32";
+    }, {
+        readonly name: "verifiedAt";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "depositorWotsPkHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "hashlock";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "htlcVout";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "depositorPopSignature";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }, {
+        readonly name: "prePeginTxHash";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "vaultProviderCommissionBps";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "protocolParams";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "contract IProtocolParams";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "applicationRegistry";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "contract IApplicationRegistry";
+    }];
+    readonly stateMutability: "view";
 }];
 //# sourceMappingURL=BTCVaultRegistry.abi.d.ts.map

package/dist/tbv/core/contracts/abis/BTCVaultRegistry.abi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BTCVaultRegistry.abi.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/contracts/abis/BTCVaultRegistry.abi.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoRtB,CAAC"}
+{"version":3,"file":"BTCVaultRegistry.abi.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/contracts/abis/BTCVaultRegistry.abi.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmXtB,CAAC"}

package/dist/tbv/core/contracts/abis/ProtocolParams.abi.d.ts

@@ -0,0 +1,233 @@
+/**
+ * ProtocolParams Contract ABI
+ *
+ * Minimal ABI containing only the read functions needed by the SDK.
+ * Generated from vault-contracts-aave-v4 IProtocolParams.sol interface.
+ *
+ * @module contracts/abis/ProtocolParams
+ */
+export declare const ProtocolParamsABI: readonly [{
+    readonly type: "function";
+    readonly name: "getTBVProtocolParams";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct IProtocolParams.TBVProtocolParams";
+        readonly components: readonly [{
+            readonly name: "minimumPegInAmount";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "maxPegInAmount";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "pegInAckTimeout";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "pegInActivationTimeout";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "maxHtlcOutputCount";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getLatestOffchainParams";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct IProtocolParams.VersionedOffchainParams";
+        readonly components: readonly [{
+            readonly name: "timelockAssert";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "timelockChallengeAssert";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "securityCouncilKeys";
+            readonly type: "bytes32[]";
+            readonly internalType: "bytes32[]";
+        }, {
+            readonly name: "councilQuorum";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "feeRate";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "babeTotalInstances";
+            readonly type: "uint16";
+            readonly internalType: "uint16";
+        }, {
+            readonly name: "babeInstancesToFinalize";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "minVpCommissionBps";
+            readonly type: "uint16";
+            readonly internalType: "uint16";
+        }, {
+            readonly name: "tRefund";
+            readonly type: "uint32";
+            readonly internalType: "uint32";
+        }, {
+            readonly name: "tStale";
+            readonly type: "uint32";
+            readonly internalType: "uint32";
+        }, {
+            readonly name: "minPeginFeeRate";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "proverProgramVersion";
+            readonly type: "uint16";
+            readonly internalType: "uint16";
+        }, {
+            readonly name: "minPrepeginDepth";
+            readonly type: "uint32";
+            readonly internalType: "uint32";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getOffchainParamsByVersion";
+    readonly inputs: readonly [{
+        readonly name: "versionNumber";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct IProtocolParams.VersionedOffchainParams";
+        readonly components: readonly [{
+            readonly name: "timelockAssert";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "timelockChallengeAssert";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "securityCouncilKeys";
+            readonly type: "bytes32[]";
+            readonly internalType: "bytes32[]";
+        }, {
+            readonly name: "councilQuorum";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "feeRate";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "babeTotalInstances";
+            readonly type: "uint16";
+            readonly internalType: "uint16";
+        }, {
+            readonly name: "babeInstancesToFinalize";
+            readonly type: "uint8";
+            readonly internalType: "uint8";
+        }, {
+            readonly name: "minVpCommissionBps";
+            readonly type: "uint16";
+            readonly internalType: "uint16";
+        }, {
+            readonly name: "tRefund";
+            readonly type: "uint32";
+            readonly internalType: "uint32";
+        }, {
+            readonly name: "tStale";
+            readonly type: "uint32";
+            readonly internalType: "uint32";
+        }, {
+            readonly name: "minPeginFeeRate";
+            readonly type: "uint64";
+            readonly internalType: "uint64";
+        }, {
+            readonly name: "proverProgramVersion";
+            readonly type: "uint16";
+            readonly internalType: "uint16";
+        }, {
+            readonly name: "minPrepeginDepth";
+            readonly type: "uint32";
+            readonly internalType: "uint32";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "latestOffchainParamsVersion";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getUniversalChallengersByVersion";
+    readonly inputs: readonly [{
+        readonly name: "versionNumber";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct BTCVaultTypes.AddressBTCKeyPair[]";
+        readonly components: readonly [{
+            readonly name: "ethAddress";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "btcPubKey";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getCurrentUniversalChallengers";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct BTCVaultTypes.AddressBTCKeyPair[]";
+        readonly components: readonly [{
+            readonly name: "ethAddress";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "btcPubKey";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "latestUniversalChallengersVersion";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }];
+    readonly stateMutability: "view";
+}];
+//# sourceMappingURL=ProtocolParams.abi.d.ts.map

package/dist/tbv/core/contracts/abis/ProtocolParams.abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolParams.abi.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/contracts/abis/ProtocolParams.abi.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiSpB,CAAC"}

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

@@ -6,6 +6,8 @@
  *
  * @module contracts
  */
+export { ApplicationRegistryABI } from './abis/ApplicationRegistry.abi';
 export { BTCVaultRegistryABI } from './abis/BTCVaultRegistry.abi';
+export { ProtocolParamsABI } from './abis/ProtocolParams.abi';
 export { CONTRACT_ERRORS, extractErrorData, getContractErrorMessage, isKnownContractError, handleContractError, } from './errors';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/contracts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/contracts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,UAAU,CAAC"}

package/dist/tbv/core/index.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("../../challengeAssert-D_k_ADgP.cjs"),u=require("@babylonlabs-io/babylon-tbv-rust-wasm"),a=require("../../payout-CfsDnjKI.cjs"),e=require("../../constants-EiyZkXce.cjs"),s=require("../../psbtInputFields-C0nKn_GD.cjs"),T=require("../../fundPeginTransaction-EbrZzlrh.cjs"),P=require("../../signing-Deg5lCoC.cjs"),r=require("../../errors-DKLboMnq.cjs"),n=require("../../signAndSubmitPayouts-CSJmcPQN.cjs"),t=require("../../index-D3z3SZAj.cjs"),o=require("../../types-DEWiqXYp.cjs");exports.buildChallengeAssertPsbt=i.buildChallengeAssertPsbt;exports.buildDepositorPayoutPsbt=i.buildDepositorPayoutPsbt;exports.buildNoPayoutPsbt=i.buildNoPayoutPsbt;exports.buildPeginInputPsbt=i.buildPeginInputPsbt;exports.buildPeginTxFromFundedPrePegin=i.buildPeginTxFromFundedPrePegin;exports.buildPrePeginPsbt=i.buildPrePeginPsbt;exports.buildRefundPsbt=i.buildRefundPsbt;exports.computeNumLocalChallengers=i.computeNumLocalChallengers;exports.extractPeginInputSignature=i.extractPeginInputSignature;exports.finalizePeginInputPsbt=i.finalizePeginInputPsbt;Object.defineProperty(exports,"computeMinClaimValue",{enumerable:!0,get:()=>u.computeMinClaimValue});Object.defineProperty(exports,"deriveVaultId",{enumerable:!0,get:()=>u.deriveVaultId});exports.buildPayoutPsbt=a.buildPayoutPsbt;exports.createPayoutScript=a.createPayoutScript;exports.extractPayoutSignature=a.extractPayoutSignature;exports.BTC_DUST_SAT=e.BTC_DUST_SAT;exports.DUST_THRESHOLD=e.DUST_THRESHOLD;exports.FEE_SAFETY_MARGIN=e.FEE_SAFETY_MARGIN;exports.LOW_RATE_ESTIMATION_ACCURACY_BUFFER=e.LOW_RATE_ESTIMATION_ACCURACY_BUFFER;exports.MAX_NON_LEGACY_OUTPUT_SIZE=e.MAX_NON_LEGACY_OUTPUT_SIZE;exports.P2TR_INPUT_SIZE=e.P2TR_INPUT_SIZE;exports.PEGIN_FIXED_OUTPUTS=e.PEGIN_FIXED_OUTPUTS;exports.SPLIT_TX_FEE_SAFETY_MULTIPLIER=e.SPLIT_TX_FEE_SAFETY_MULTIPLIER;exports.TX_BUFFER_SIZE_OVERHEAD=e.TX_BUFFER_SIZE_OVERHEAD;exports.WALLET_RELAY_FEE_RATE_THRESHOLD=e.WALLET_RELAY_FEE_RATE_THRESHOLD;exports.deriveNativeSegwitAddress=e.deriveNativeSegwitAddress;exports.deriveTaprootAddress=e.deriveTaprootAddress;exports.ensureHexPrefix=e.ensureHexPrefix;exports.getNetwork=e.getNetwork;exports.hexToUint8Array=e.hexToUint8Array;exports.isAddressFromPublicKey=e.isAddressFromPublicKey;exports.isValidHex=e.isValidHex;exports.peginOutputCount=e.peginOutputCount;exports.processPublicKeyToXOnly=e.processPublicKeyToXOnly;exports.rateBasedTxBufferFee=e.rateBasedTxBufferFee;exports.stripHexPrefix=e.stripHexPrefix;exports.toXOnly=e.toXOnly;exports.uint8ArrayToHex=e.uint8ArrayToHex;exports.validateWalletPubkey=e.validateWalletPubkey;exports.BitcoinScriptType=s.BitcoinScriptType;exports.calculateBtcTxHash=s.calculateBtcTxHash;exports.getDustThreshold=s.getDustThreshold;exports.getPsbtInputFields=s.getPsbtInputFields;exports.getScriptType=s.getScriptType;exports.selectUtxosForPegin=s.selectUtxosForPegin;exports.shouldAddChangeOutput=s.shouldAddChangeOutput;exports.fundPeginTransaction=T.fundPeginTransaction;exports.parseUnfundedWasmTransaction=T.parseUnfundedWasmTransaction;exports.createTaprootScriptPathSignOptions=P.createTaprootScriptPathSignOptions;exports.CONTRACT_ERRORS=r.CONTRACT_ERRORS;exports.PeginManager=r.PeginManager;exports.computeWotsPkHash=r.computeWotsPkHash;exports.deriveWotsKeypair=r.deriveWotsKeypair;exports.deriveWotsPkHash=r.deriveWotsPkHash;exports.extractErrorData=r.extractErrorData;exports.getContractErrorMessage=r.getContractErrorMessage;exports.handleContractError=r.handleContractError;exports.isKnownContractError=r.isKnownContractError;exports.isWotsMismatchError=r.isWotsMismatchError;exports.keypairToPublicKey=r.keypairToPublicKey;exports.mnemonicToWotsSeed=r.mnemonicToWotsSeed;exports.PayoutManager=n.PayoutManager;exports.pollAndSignPayouts=n.pollAndSignPayouts;exports.signDepositorGraph=n.signDepositorGraph;exports.submitWotsPublicKey=n.submitWotsPublicKey;exports.waitForPeginStatus=n.waitForPeginStatus;exports.BTCVaultRegistryABI=t.BTCVaultRegistryABI;exports.MEMPOOL_API_URLS=t.MEMPOOL_API_URLS;exports.VaultProviderRpcClient=t.VaultProviderRpcClient;exports.ViemVaultRegistryReader=t.ViemVaultRegistryReader;exports.VpResponseValidationError=t.VpResponseValidationError;exports.getAddressTxs=t.getAddressTxs;exports.getAddressUtxos=t.getAddressUtxos;exports.getMempoolApiUrl=t.getMempoolApiUrl;exports.getNetworkFees=t.getNetworkFees;exports.getTxHex=t.getTxHex;exports.getTxInfo=t.getTxInfo;exports.getUtxoInfo=t.getUtxoInfo;exports.pushTx=t.pushTx;exports.DaemonStatus=o.DaemonStatus;exports.JSON_RPC_ERROR_CODES=o.JSON_RPC_ERROR_CODES;exports.JsonRpcClient=o.JsonRpcClient;exports.JsonRpcError=o.JsonRpcError;exports.POST_WOTS_STATUSES=o.POST_WOTS_STATUSES;exports.PRE_DEPOSITOR_SIGNATURES_STATES=o.PRE_DEPOSITOR_SIGNATURES_STATES;exports.RpcErrorCode=o.RpcErrorCode;exports.VP_TERMINAL_STATUSES=o.VP_TERMINAL_STATUSES;exports.VP_TRANSIENT_STATUSES=o.VP_TRANSIENT_STATUSES;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../../challengeAssert-D_k_ADgP.cjs"),u=require("@babylonlabs-io/babylon-tbv-rust-wasm"),n=require("../../payout-CfsDnjKI.cjs"),e=require("../../constants-EiyZkXce.cjs"),s=require("../../psbtInputFields-C0nKn_GD.cjs"),l=require("../../fundPeginTransaction-EbrZzlrh.cjs"),P=require("../../signing-Deg5lCoC.cjs"),r=require("../../errors-DVNYib5y.cjs"),a=require("../../index-BgnxXV5G.cjs"),t=require("../../index-DpKhuCta.cjs"),i=require("../../types-DEWiqXYp.cjs");exports.buildChallengeAssertPsbt=o.buildChallengeAssertPsbt;exports.buildDepositorPayoutPsbt=o.buildDepositorPayoutPsbt;exports.buildNoPayoutPsbt=o.buildNoPayoutPsbt;exports.buildPeginInputPsbt=o.buildPeginInputPsbt;exports.buildPeginTxFromFundedPrePegin=o.buildPeginTxFromFundedPrePegin;exports.buildPrePeginPsbt=o.buildPrePeginPsbt;exports.buildRefundPsbt=o.buildRefundPsbt;exports.computeNumLocalChallengers=o.computeNumLocalChallengers;exports.extractPeginInputSignature=o.extractPeginInputSignature;exports.finalizePeginInputPsbt=o.finalizePeginInputPsbt;Object.defineProperty(exports,"computeMinClaimValue",{enumerable:!0,get:()=>u.computeMinClaimValue});Object.defineProperty(exports,"deriveVaultId",{enumerable:!0,get:()=>u.deriveVaultId});exports.buildPayoutPsbt=n.buildPayoutPsbt;exports.createPayoutScript=n.createPayoutScript;exports.extractPayoutSignature=n.extractPayoutSignature;exports.BTC_DUST_SAT=e.BTC_DUST_SAT;exports.DUST_THRESHOLD=e.DUST_THRESHOLD;exports.FEE_SAFETY_MARGIN=e.FEE_SAFETY_MARGIN;exports.LOW_RATE_ESTIMATION_ACCURACY_BUFFER=e.LOW_RATE_ESTIMATION_ACCURACY_BUFFER;exports.MAX_NON_LEGACY_OUTPUT_SIZE=e.MAX_NON_LEGACY_OUTPUT_SIZE;exports.P2TR_INPUT_SIZE=e.P2TR_INPUT_SIZE;exports.PEGIN_FIXED_OUTPUTS=e.PEGIN_FIXED_OUTPUTS;exports.SPLIT_TX_FEE_SAFETY_MULTIPLIER=e.SPLIT_TX_FEE_SAFETY_MULTIPLIER;exports.TX_BUFFER_SIZE_OVERHEAD=e.TX_BUFFER_SIZE_OVERHEAD;exports.WALLET_RELAY_FEE_RATE_THRESHOLD=e.WALLET_RELAY_FEE_RATE_THRESHOLD;exports.deriveNativeSegwitAddress=e.deriveNativeSegwitAddress;exports.deriveTaprootAddress=e.deriveTaprootAddress;exports.ensureHexPrefix=e.ensureHexPrefix;exports.getNetwork=e.getNetwork;exports.hexToUint8Array=e.hexToUint8Array;exports.isAddressFromPublicKey=e.isAddressFromPublicKey;exports.isValidHex=e.isValidHex;exports.peginOutputCount=e.peginOutputCount;exports.processPublicKeyToXOnly=e.processPublicKeyToXOnly;exports.rateBasedTxBufferFee=e.rateBasedTxBufferFee;exports.stripHexPrefix=e.stripHexPrefix;exports.toXOnly=e.toXOnly;exports.uint8ArrayToHex=e.uint8ArrayToHex;exports.validateWalletPubkey=e.validateWalletPubkey;exports.BitcoinScriptType=s.BitcoinScriptType;exports.calculateBtcTxHash=s.calculateBtcTxHash;exports.getDustThreshold=s.getDustThreshold;exports.getPsbtInputFields=s.getPsbtInputFields;exports.getScriptType=s.getScriptType;exports.selectUtxosForPegin=s.selectUtxosForPegin;exports.shouldAddChangeOutput=s.shouldAddChangeOutput;exports.fundPeginTransaction=l.fundPeginTransaction;exports.parseUnfundedWasmTransaction=l.parseUnfundedWasmTransaction;exports.createTaprootScriptPathSignOptions=P.createTaprootScriptPathSignOptions;exports.CONTRACT_ERRORS=r.CONTRACT_ERRORS;exports.PeginManager=r.PeginManager;exports.computeWotsBlockPublicKeysHash=r.computeWotsBlockPublicKeysHash;exports.computeWotsPkHash=r.computeWotsPkHash;exports.deriveWotsBlockPublicKeys=r.deriveWotsBlockPublicKeys;exports.deriveWotsKeypair=r.deriveWotsKeypair;exports.deriveWotsPkHash=r.deriveWotsPkHash;exports.extractErrorData=r.extractErrorData;exports.getContractErrorMessage=r.getContractErrorMessage;exports.handleContractError=r.handleContractError;exports.isKnownContractError=r.isKnownContractError;exports.isWotsMismatchError=r.isWotsMismatchError;exports.keypairToPublicKey=r.keypairToPublicKey;exports.mnemonicToWotsSeed=r.mnemonicToWotsSeed;exports.PayoutManager=a.PayoutManager;exports.computeHashlock=a.computeHashlock;exports.pollAndSignPayouts=a.pollAndSignPayouts;exports.signDepositorGraph=a.signDepositorGraph;exports.submitWotsPublicKey=a.submitWotsPublicKey;exports.validateSecretAgainstHashlock=a.validateSecretAgainstHashlock;exports.waitForPeginStatus=a.waitForPeginStatus;exports.ApplicationRegistryABI=t.ApplicationRegistryABI;exports.BTCVaultRegistryABI=t.BTCVaultRegistryABI;exports.MEMPOOL_API_URLS=t.MEMPOOL_API_URLS;exports.ProtocolParamsABI=t.ProtocolParamsABI;exports.VaultProviderRpcClient=t.VaultProviderRpcClient;exports.ViemProtocolParamsReader=t.ViemProtocolParamsReader;exports.ViemUniversalChallengerReader=t.ViemUniversalChallengerReader;exports.ViemVaultKeeperReader=t.ViemVaultKeeperReader;exports.ViemVaultRegistryReader=t.ViemVaultRegistryReader;exports.VpResponseValidationError=t.VpResponseValidationError;exports.getAddressTxs=t.getAddressTxs;exports.getAddressUtxos=t.getAddressUtxos;exports.getMempoolApiUrl=t.getMempoolApiUrl;exports.getNetworkFees=t.getNetworkFees;exports.getTxHex=t.getTxHex;exports.getTxInfo=t.getTxInfo;exports.getUtxoInfo=t.getUtxoInfo;exports.pushTx=t.pushTx;exports.resolveProtocolAddresses=t.resolveProtocolAddresses;exports.DaemonStatus=i.DaemonStatus;exports.JSON_RPC_ERROR_CODES=i.JSON_RPC_ERROR_CODES;exports.JsonRpcClient=i.JsonRpcClient;exports.JsonRpcError=i.JsonRpcError;exports.POST_WOTS_STATUSES=i.POST_WOTS_STATUSES;exports.PRE_DEPOSITOR_SIGNATURES_STATES=i.PRE_DEPOSITOR_SIGNATURES_STATES;exports.RpcErrorCode=i.RpcErrorCode;exports.VP_TERMINAL_STATUSES=i.VP_TERMINAL_STATUSES;exports.VP_TRANSIENT_STATUSES=i.VP_TRANSIENT_STATUSES;
 //# sourceMappingURL=index.cjs.map

package/dist/tbv/core/index.js

@@ -1,102 +1,112 @@
-import { j as e, h as t, i as r, d as o, a as i, b as n, g as T, c as P, e as u, f as p } from "../../challengeAssert-k5_LWUtO.js";
-import { computeMinClaimValue as E, deriveVaultId as S } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { b as _, c, e as g } from "../../payout-Ce9vSs9e.js";
-import { B as A, D as x, F as b, L as m, M as f, P as I, c as O, S as y, T as C, W as U, d as h, a as F, e as N, g as D, h as L, i as M, b as V, f as H, p as B, r as W, s as v, t as k, u as w, v as K } from "../../constants-Q7v2O7Ps.js";
-import { B as G, c as Y, g as J, d as Z, b as j, s as z, a as q } from "../../psbtInputFields-DO0ELwiv.js";
+import { j as e, h as t, i as r, d as o, a as i, b as n, g as P, c as l, e as T, f as u } from "../../challengeAssert-k5_LWUtO.js";
+import { computeMinClaimValue as p, deriveVaultId as c } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { b as E, c as g, e as _ } from "../../payout-Ce9vSs9e.js";
+import { B as R, D as m, F as b, L as x, M as I, P as f, c as y, S as O, T as h, W as C, d as U, a as F, e as V, g as N, h as B, i as H, b as D, f as L, p as M, r as v, s as W, t as k, u as K, v as w } from "../../constants-Q7v2O7Ps.js";
+import { B as G, c as Y, g as J, d as j, b as Z, s as z, a as q } from "../../psbtInputFields-DO0ELwiv.js";
 import { f as $, p as aa } from "../../fundPeginTransaction-DpwnDslW.js";
 import { c as ea } from "../../signing-Drwr3bXB.js";
-import { C as ra, P as oa, c as ia, d as na, a as Ta, e as Pa, g as ua, h as pa, i as da, b as Ea, k as Sa, m as la } from "../../errors-KY63mgWT.js";
-import { P as ca, p as ga, a as Ra, s as Aa, w as xa } from "../../signAndSubmitPayouts-CAOEAQp9.js";
-import { B as ma, M as fa, V as Ia, i as Oa, h as ya, g as Ca, a as Ua, b as ha, c as Fa, d as Na, e as Da, f as La, p as Ma } from "../../index-Dw7FAwne.js";
-import { D as Ha, b as Ba, J as Wa, a as va, d as ka, P as wa, R as Ka, c as Xa, V as Ga } from "../../types-D1rYwwCu.js";
+import { C as ra, P as oa, b as ia, c as na, a as Pa, d as la, f as Ta, e as ua, g as da, h as pa, i as ca, j as Sa, k as Ea, m as ga } from "../../errors-aMocmFr-.js";
+import { P as Aa, c as Ra, p as ma, a as ba, s as xa, v as Ia, w as fa } from "../../index-BX-V3C9t.js";
+import { A as Oa, B as ha, M as Ca, P as Ua, V as Fa, i as Va, j as Na, k as Ba, l as Ha, h as Da, g as La, a as Ma, b as va, c as Wa, d as ka, e as Ka, f as wa, p as Xa, r as Ga } from "../../index-BvFLf3vm.js";
+import { D as Ja, b as ja, J as Za, a as za, d as qa, P as Qa, R as $a, c as as, V as ss } from "../../types-D1rYwwCu.js";
 export {
-  ma as BTCVaultRegistryABI,
-  A as BTC_DUST_SAT,
+  Oa as ApplicationRegistryABI,
+  ha as BTCVaultRegistryABI,
+  R as BTC_DUST_SAT,
   G as BitcoinScriptType,
   ra as CONTRACT_ERRORS,
-  x as DUST_THRESHOLD,
-  Ha as DaemonStatus,
+  m as DUST_THRESHOLD,
+  Ja as DaemonStatus,
   b as FEE_SAFETY_MARGIN,
-  Ba as JSON_RPC_ERROR_CODES,
-  Wa as JsonRpcClient,
-  va as JsonRpcError,
-  m as LOW_RATE_ESTIMATION_ACCURACY_BUFFER,
-  f as MAX_NON_LEGACY_OUTPUT_SIZE,
-  fa as MEMPOOL_API_URLS,
-  I as P2TR_INPUT_SIZE,
-  O as PEGIN_FIXED_OUTPUTS,
-  ka as POST_WOTS_STATUSES,
-  wa as PRE_DEPOSITOR_SIGNATURES_STATES,
-  ca as PayoutManager,
+  ja as JSON_RPC_ERROR_CODES,
+  Za as JsonRpcClient,
+  za as JsonRpcError,
+  x as LOW_RATE_ESTIMATION_ACCURACY_BUFFER,
+  I as MAX_NON_LEGACY_OUTPUT_SIZE,
+  Ca as MEMPOOL_API_URLS,
+  f as P2TR_INPUT_SIZE,
+  y as PEGIN_FIXED_OUTPUTS,
+  qa as POST_WOTS_STATUSES,
+  Qa as PRE_DEPOSITOR_SIGNATURES_STATES,
+  Aa as PayoutManager,
   oa as PeginManager,
-  Ka as RpcErrorCode,
-  y as SPLIT_TX_FEE_SAFETY_MULTIPLIER,
-  C as TX_BUFFER_SIZE_OVERHEAD,
-  Xa as VP_TERMINAL_STATUSES,
-  Ga as VP_TRANSIENT_STATUSES,
-  Ia as VaultProviderRpcClient,
-  Oa as ViemVaultRegistryReader,
-  ya as VpResponseValidationError,
-  U as WALLET_RELAY_FEE_RATE_THRESHOLD,
+  Ua as ProtocolParamsABI,
+  $a as RpcErrorCode,
+  O as SPLIT_TX_FEE_SAFETY_MULTIPLIER,
+  h as TX_BUFFER_SIZE_OVERHEAD,
+  as as VP_TERMINAL_STATUSES,
+  ss as VP_TRANSIENT_STATUSES,
+  Fa as VaultProviderRpcClient,
+  Va as ViemProtocolParamsReader,
+  Na as ViemUniversalChallengerReader,
+  Ba as ViemVaultKeeperReader,
+  Ha as ViemVaultRegistryReader,
+  Da as VpResponseValidationError,
+  C as WALLET_RELAY_FEE_RATE_THRESHOLD,
   e as buildChallengeAssertPsbt,
   t as buildDepositorPayoutPsbt,
   r as buildNoPayoutPsbt,
-  _ as buildPayoutPsbt,
+  E as buildPayoutPsbt,
   o as buildPeginInputPsbt,
   i as buildPeginTxFromFundedPrePegin,
   n as buildPrePeginPsbt,
-  T as buildRefundPsbt,
+  P as buildRefundPsbt,
   Y as calculateBtcTxHash,
-  E as computeMinClaimValue,
-  P as computeNumLocalChallengers,
-  ia as computeWotsPkHash,
-  c as createPayoutScript,
+  Ra as computeHashlock,
+  p as computeMinClaimValue,
+  l as computeNumLocalChallengers,
+  ia as computeWotsBlockPublicKeysHash,
+  na as computeWotsPkHash,
+  g as createPayoutScript,
   ea as createTaprootScriptPathSignOptions,
-  h as deriveNativeSegwitAddress,
+  U as deriveNativeSegwitAddress,
   F as deriveTaprootAddress,
-  S as deriveVaultId,
-  na as deriveWotsKeypair,
+  c as deriveVaultId,
+  Pa as deriveWotsBlockPublicKeys,
+  la as deriveWotsKeypair,
   Ta as deriveWotsPkHash,
-  N as ensureHexPrefix,
-  Pa as extractErrorData,
-  g as extractPayoutSignature,
-  u as extractPeginInputSignature,
-  p as finalizePeginInputPsbt,
+  V as ensureHexPrefix,
+  ua as extractErrorData,
+  _ as extractPayoutSignature,
+  T as extractPeginInputSignature,
+  u as finalizePeginInputPsbt,
   $ as fundPeginTransaction,
-  Ca as getAddressTxs,
-  Ua as getAddressUtxos,
-  ua as getContractErrorMessage,
+  La as getAddressTxs,
+  Ma as getAddressUtxos,
+  da as getContractErrorMessage,
   J as getDustThreshold,
-  ha as getMempoolApiUrl,
-  D as getNetwork,
-  Fa as getNetworkFees,
-  Z as getPsbtInputFields,
-  j as getScriptType,
-  Na as getTxHex,
-  Da as getTxInfo,
-  La as getUtxoInfo,
+  va as getMempoolApiUrl,
+  N as getNetwork,
+  Wa as getNetworkFees,
+  j as getPsbtInputFields,
+  Z as getScriptType,
+  ka as getTxHex,
+  Ka as getTxInfo,
+  wa as getUtxoInfo,
   pa as handleContractError,
-  L as hexToUint8Array,
-  M as isAddressFromPublicKey,
-  da as isKnownContractError,
-  V as isValidHex,
-  Ea as isWotsMismatchError,
-  Sa as keypairToPublicKey,
-  la as mnemonicToWotsSeed,
+  B as hexToUint8Array,
+  H as isAddressFromPublicKey,
+  ca as isKnownContractError,
+  D as isValidHex,
+  Sa as isWotsMismatchError,
+  Ea as keypairToPublicKey,
+  ga as mnemonicToWotsSeed,
   aa as parseUnfundedWasmTransaction,
-  H as peginOutputCount,
-  ga as pollAndSignPayouts,
-  B as processPublicKeyToXOnly,
-  Ma as pushTx,
-  W as rateBasedTxBufferFee,
+  L as peginOutputCount,
+  ma as pollAndSignPayouts,
+  M as processPublicKeyToXOnly,
+  Xa as pushTx,
+  v as rateBasedTxBufferFee,
+  Ga as resolveProtocolAddresses,
   z as selectUtxosForPegin,
   q as shouldAddChangeOutput,
-  Ra as signDepositorGraph,
-  v as stripHexPrefix,
-  Aa as submitWotsPublicKey,
+  ba as signDepositorGraph,
+  W as stripHexPrefix,
+  xa as submitWotsPublicKey,
   k as toXOnly,
-  w as uint8ArrayToHex,
-  K as validateWalletPubkey,
-  xa as waitForPeginStatus
+  K as uint8ArrayToHex,
+  Ia as validateSecretAgainstHashlock,
+  w as validateWalletPubkey,
+  fa as waitForPeginStatus
 };
 //# sourceMappingURL=index.js.map

package/dist/tbv/core/services/htlc/__tests__/htlc.test.d.ts

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

package/dist/tbv/core/services/htlc/__tests__/htlc.test.d.ts.map

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

package/dist/tbv/core/services/htlc/index.d.ts

@@ -0,0 +1,25 @@
+import { Hex } from 'viem';
+/**
+ * Compute the SHA-256 hashlock from a secret preimage.
+ *
+ * Matches the on-chain validation: `sha256(abi.encodePacked(s))` where `s` is a `bytes32`.
+ * `abi.encodePacked(bytes32)` is just the raw 32 bytes — no ABI padding.
+ *
+ * @param secret - 0x-prefixed bytes32 secret (66 hex chars)
+ * @returns 0x-prefixed bytes32 SHA-256 hash
+ * @throws if secret is not exactly 32 bytes
+ */
+export declare function computeHashlock(secret: Hex): Hex;
+/**
+ * Validate that a secret's SHA-256 hash matches the expected hashlock.
+ *
+ * Use this for client-side pre-validation before sending the activation
+ * transaction to avoid wasting gas on a contract revert.
+ *
+ * @param secret - 0x-prefixed bytes32 secret (66 hex chars)
+ * @param hashlock - 0x-prefixed bytes32 expected hashlock from the vault
+ * @returns true if SHA-256(secret) matches the hashlock
+ * @throws if secret or hashlock is not exactly 32 bytes
+ */
+export declare function validateSecretAgainstHashlock(secret: Hex, hashlock: Hex): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/tbv/core/services/htlc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tbv/core/services/htlc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAgDhC;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAKhD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,GAAG,EACX,QAAQ,EAAE,GAAG,GACZ,OAAO,CAQT"}

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

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../../../signAndSubmitPayouts-CSJmcPQN.cjs");exports.pollAndSignPayouts=t.pollAndSignPayouts;exports.signDepositorGraph=t.signDepositorGraph;exports.submitWotsPublicKey=t.submitWotsPublicKey;exports.waitForPeginStatus=t.waitForPeginStatus;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../../../index-BgnxXV5G.cjs");exports.computeHashlock=t.computeHashlock;exports.pollAndSignPayouts=t.pollAndSignPayouts;exports.signDepositorGraph=t.signDepositorGraph;exports.submitWotsPublicKey=t.submitWotsPublicKey;exports.validateSecretAgainstHashlock=t.validateSecretAgainstHashlock;exports.waitForPeginStatus=t.waitForPeginStatus;
 //# sourceMappingURL=index.cjs.map

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

@@ -7,4 +7,5 @@
  * @module services
  */
 export * from './deposit';
+export * from './htlc';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/services/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tbv/core/services/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC"}

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

@@ -1,8 +1,10 @@
-import { p as o, a as t, s as i, w as p } from "../../../signAndSubmitPayouts-CAOEAQp9.js";
+import { c as t, p as o, a as i, s as e, v as c, w as l } from "../../../index-BX-V3C9t.js";
 export {
+  t as computeHashlock,
   o as pollAndSignPayouts,
-  t as signDepositorGraph,
-  i as submitWotsPublicKey,
-  p as waitForPeginStatus
+  i as signDepositorGraph,
+  e as submitWotsPublicKey,
+  c as validateSecretAgainstHashlock,
+  l as waitForPeginStatus
 };
 //# sourceMappingURL=index.js.map

package/dist/tbv/core/wots/__tests__/blockDerivation.test.d.ts

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

package/dist/tbv/core/wots/__tests__/blockDerivation.test.d.ts.map

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