@buildonspark/spark-sdk 0.3.8 → 0.4.0

package/dist/bare/index.d.cts

@@ -8,10 +8,10 @@ import * as _scure_base from '@scure/base';
 import { Channel } from 'nice-grpc';
 import { Channel as Channel$1, createChannel } from 'nice-grpc-web';
 import { RetryOptions as RetryOptions$1 } from 'nice-grpc-client-middleware-retry';
+import { TransactionOutput, TransactionInput } from '@scure/btc-signer/psbt';
 import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { EventEmitter } from 'eventemitter3';
 import * as nice_grpc_web_lib_client_Transport_js from 'nice-grpc-web/lib/client/Transport.js';
-import { TransactionOutput, TransactionInput } from '@scure/btc-signer/psbt';
 
 declare class SparkSDKError extends Error {
     readonly context: Record<string, unknown>;
@@ -1088,6 +1088,17 @@ interface RenewLeafRequest {
     {
         $case: "renewRefundTimelockSigningJob";
         renewRefundTimelockSigningJob: RenewRefundTimelockSigningJob;
+    } | //
+    /**
+     * A special case of refresh for when the node transaction is at 0 and
+     * cannot be decremented further. This operation resets the refund
+     * transaction's timelock and, similar to renew node, adds an additional
+     * node transaction to the transaction chain with zero timelock as well.
+     * This case is mostly used for user-created trees from L1 deposits.
+     */
+    {
+        $case: "renewNodeZeroTimelockSigningJob";
+        renewNodeZeroTimelockSigningJob: RenewNodeZeroTimelockSigningJob;
     } | undefined;
 }
 declare const RenewLeafRequest: MessageFns$2<RenewLeafRequest>;
@@ -1126,6 +1137,22 @@ interface RenewRefundTimelockSigningJob {
     directFromCpfpRefundTxSigningJob: UserSignedTxSigningJob | undefined;
 }
 declare const RenewRefundTimelockSigningJob: MessageFns$2<RenewRefundTimelockSigningJob>;
+interface RenewNodeZeroTimelockSigningJob {
+    /**
+     * Signing job with the new node transaction. The updated transaction is
+     * expected to have a timelock of 0.
+     */
+    nodeTxSigningJob: UserSignedTxSigningJob | undefined;
+    /**
+     * Signing job with the updated refund transaction. This updated transaction
+     * must have a timelock of 2000.
+     */
+    refundTxSigningJob: UserSignedTxSigningJob | undefined;
+    directNodeTxSigningJob: UserSignedTxSigningJob | undefined;
+    directRefundTxSigningJob: UserSignedTxSigningJob | undefined;
+    directFromCpfpRefundTxSigningJob: UserSignedTxSigningJob | undefined;
+}
+declare const RenewNodeZeroTimelockSigningJob: MessageFns$2<RenewNodeZeroTimelockSigningJob>;
 interface RenewLeafResponse {
     renewResult?: {
         $case: "renewNodeTimelockResult";
@@ -1133,6 +1160,9 @@ interface RenewLeafResponse {
     } | {
         $case: "renewRefundTimelockResult";
         renewRefundTimelockResult: RenewRefundTimelockResult;
+    } | {
+        $case: "renewNodeZeroTimelockResult";
+        renewNodeZeroTimelockResult: RenewNodeZeroTimelockResult;
     } | undefined;
 }
 declare const RenewLeafResponse: MessageFns$2<RenewLeafResponse>;
@@ -1145,6 +1175,11 @@ interface RenewRefundTimelockResult {
     node: TreeNode | undefined;
 }
 declare const RenewRefundTimelockResult: MessageFns$2<RenewRefundTimelockResult>;
+interface RenewNodeZeroTimelockResult {
+    splitNode: TreeNode | undefined;
+    node: TreeNode | undefined;
+}
+declare const RenewNodeZeroTimelockResult: MessageFns$2<RenewNodeZeroTimelockResult>;
 /**
  * NodeSignatureShares is the signature shares for a node on the tree.
  * For each tree node, the verifying key stays the same for both transactions.
@@ -3491,15 +3526,6 @@ declare function getNetworkFromAddress(address: string): BitcoinNetwork.MAINNET
  */
 declare function getNetworkFromString(network?: string): Network;
 
-type Bech32mTokenIdentifier = `btkn1${string}` | `btknrt1${string}` | `btknt1${string}` | `btkns1${string}` | `btknl1${string}`;
-interface Bech32mTokenIdentifierData {
-    tokenIdentifier: Uint8Array;
-    network: NetworkType;
-}
-declare function encodeBech32mTokenIdentifier(payload: Bech32mTokenIdentifierData): Bech32mTokenIdentifier;
-declare function decodeBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier, network?: NetworkType): Bech32mTokenIdentifierData;
-declare function getNetworkFromBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier): NetworkType;
-
 declare const AddressNetwork: Record<NetworkType, string>;
 declare const LegacyAddressNetwork: Record<NetworkType, string>;
 type Bech32String = `${string}1${string}`;
@@ -3547,6 +3573,15 @@ declare function assertBech32(s: string): asserts s is Bech32String;
 declare function bech32mDecode(address: string): _scure_base.Bech32Decoded<string>;
 declare function isSafeForNumber(bi: bigint): boolean;
 
+type Bech32mTokenIdentifier = `btkn1${string}` | `btknrt1${string}` | `btknt1${string}` | `btkns1${string}` | `btknl1${string}`;
+interface Bech32mTokenIdentifierData {
+    tokenIdentifier: Uint8Array;
+    network: NetworkType;
+}
+declare function encodeBech32mTokenIdentifier(payload: Bech32mTokenIdentifierData): Bech32mTokenIdentifier;
+declare function decodeBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier, network?: NetworkType): Bech32mTokenIdentifierData;
+declare function getNetworkFromBech32mTokenIdentifier(bech32mTokenIdentifier: Bech32mTokenIdentifier): NetworkType;
+
 type CreateLightningInvoiceParams = {
     amountSats: number;
     memo?: string;
@@ -3668,6 +3703,10 @@ type SigningOperator = {
 type ConsoleOptions = {
     otel?: boolean;
 };
+type OptimizationOptions = {
+    readonly auto?: boolean;
+    readonly multiplicity?: number;
+};
 type ConfigOptions = MayHaveSspClientOptions & {
     readonly network?: NetworkType;
     readonly signingOperators?: Readonly<Record<string, SigningOperator>>;
@@ -3683,6 +3722,7 @@ type ConfigOptions = MayHaveSspClientOptions & {
     readonly signerWithPreExistingKeys?: boolean;
     readonly console?: ConsoleOptions;
     readonly events?: Partial<SparkWalletEvents>;
+    readonly optimizationOptions?: OptimizationOptions;
 };
 
 declare class WalletConfigService implements HasSspClientOptions {
@@ -3708,6 +3748,7 @@ declare class WalletConfigService implements HasSspClientOptions {
     getSspIdentityPublicKey(): string;
     getConsoleOptions(): ConsoleOptions;
     getEvents(): Partial<SparkWalletEvents>;
+    getOptimizationOptions(): OptimizationOptions;
 }
 
 /** Challenge represents the core challenge data */
@@ -3876,6 +3917,7 @@ declare class SigningService {
         directLeafSigningJobs: UserSignedTxSigningJob[];
         directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[];
     }>;
+    signSigningJobs(signingJobs: (SigningJobWithOptionalNonce & RequestedSigningCommitments)[]): Promise<Map<SigningJobType, UserSignedTxSigningJob>>;
 }
 
 type LeafKeyTweak = {
@@ -3896,6 +3938,17 @@ type LeafRefundSigningData = {
     directFromCpfpRefundSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
     vout: number;
 };
+type SigningJobType = "split" | "directSplit" | "node" | "directNode" | "cpfp" | "direct" | "directFromCpfp";
+type SigningJobWithOptionalNonce = {
+    signingPublicKey: Uint8Array;
+    rawTx: Uint8Array;
+    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
+    type: SigningJobType;
+    parentTxOut: TransactionOutput;
+    leafId: string;
+    keyDerivation: KeyDerivation;
+    verifyingKey: Uint8Array;
+};
 declare class BaseTransferService {
     protected readonly config: WalletConfigService;
     protected readonly connectionManager: ConnectionManager;
@@ -3948,11 +4001,12 @@ declare class TransferService extends BaseTransferService {
     claimTransferSignRefunds(transfer: Transfer, leafKeys: LeafKeyTweak[], proofMap?: Map<string, Uint8Array[]>): Promise<NodeSignatures[]>;
     private finalizeNodeSignatures;
     queryPendingTransfersBySender(operatorAddress: string): Promise<QueryTransfersResponse>;
-    private refreshTimelockNodesInternal;
-    refreshTimelockNodes(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    extendTimelock(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    testonly_expireTimeLockNodeTx(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    testonly_expireTimeLockRefundtx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    renewRefundTxn(node: TreeNode, parentNode: TreeNode): Promise<TreeNode>;
+    renewNodeTxn(node: TreeNode, parentNode: TreeNode): Promise<TreeNode>;
+    private createRenewRefundSigningJobs;
+    private createRenewNodeSigningJobs;
+    renewZeroTimelockNodeTxn(node: TreeNode): Promise<TreeNode>;
+    private createRenewZeroTimelockNodeSigningJobs;
 }
 
 /**
@@ -3992,13 +4046,15 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private handleStreamEvent;
     protected setupBackgroundStream(): Promise<void>;
     getLeaves(isBalanceCheck?: boolean): Promise<TreeNode[]>;
-    private checkExtendLeaves;
     private verifyKey;
     private popOrThrow;
     private selectLeaves;
     private selectLeavesForSwap;
-    private areLeavesInefficient;
-    private optimizeLeaves;
+    optimizeLeaves(multiplicity?: number | undefined): AsyncGenerator<{
+        step: number;
+        total: number;
+        controller: AbortController;
+    }, void, void>;
     private syncWallet;
     private withLeaves;
     /**
@@ -4303,15 +4359,7 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
     private transferWithInvoice;
     private buildTweaksByAmount;
     private toSendTweak;
-    private checkExtendTimeLockNodes;
-    /**
-     * Internal method to refresh timelock nodes.
-     *
-     * @param {string} nodeId - The optional ID of the node to refresh. If not provided, all nodes will be checked.
-     * @returns {Promise<void>}
-     * @private
-     */
-    private checkRefreshTimelockNodes;
+    private checkRenewLeaves;
     private claimTransferCore;
     private processClaimedTransferResults;
     /**
@@ -4550,13 +4598,6 @@ declare abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
         nodeTimelock: number;
         refundTimelock: number;
     }>;
-    /**
-     * Refresh the timelock of a specific node.
-     *
-     * @param {string} nodeId - The ID of the node to refresh
-     * @returns {Promise<void>} Promise that resolves when the timelock is refreshed
-     */
-    testOnly_expireTimelock(nodeId: string): Promise<void>;
     private cleanup;
     cleanupConnections(): Promise<void>;
     private startPeriodicClaimTransfers;
@@ -4658,7 +4699,6 @@ declare const DIRECT_TIMELOCK_OFFSET = 50;
 declare const HTLC_TIMELOCK_OFFSET = 70;
 declare const DIRECT_HTLC_TIMELOCK_OFFSET = 85;
 declare const INITIAL_SEQUENCE: number;
-declare const INITIAL_DIRECT_SEQUENCE: number;
 declare const TEST_UNILATERAL_SEQUENCE: number;
 declare const TEST_UNILATERAL_DIRECT_SEQUENCE: number;
 declare const DEFAULT_FEE_SATS: number;
@@ -4667,55 +4707,60 @@ declare const DEFAULT_FEE_SATS: number;
  * Returns the original amount if it's less than or equal to the fee.
  */
 declare function maybeApplyFee(amount: bigint): bigint;
-declare function createRootTx(depositOutPoint: TransactionInput, depositTxOut: TransactionOutput): [Transaction, Transaction];
-declare function createSplitTx(parentOutPoint: TransactionInput, childTxOuts: TransactionOutput[]): [Transaction, Transaction];
-interface CreateNodeTxInput {
-    txOut: TransactionOutput;
-    parentOutPoint: TransactionInput;
-    applyFee?: boolean;
-    includeAnchor?: boolean;
-}
-declare function createNodeTx({ txOut, parentOutPoint, applyFee, includeAnchor, }: CreateNodeTxInput): Transaction;
-declare function createNodeTxs(txOut: TransactionOutput, txIn: TransactionInput, directTxIn?: TransactionInput): {
-    cpfpNodeTx: Transaction;
-    directNodeTx?: Transaction;
+declare function createRootNodeTx(parentTx: Transaction, vout: number): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
+};
+declare function createZeroTimelockNodeTx(parentTx: Transaction): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
+};
+declare function createInitialTimelockNodeTx(parentTx: Transaction): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
+};
+declare function createDecrementedTimelockNodeTx(parentTx: Transaction, currentTx: Transaction): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
+};
+declare function createTestUnilateralTimelockNodeTx(parentTx: Transaction, nodeTx: Transaction): {
+    nodeTx: Transaction;
+    directNodeTx: Transaction;
 };
-declare function createLeafNodeTx(sequence: number, directSequence: number, parentOutPoint: TransactionInput, txOut: TransactionOutput, shouldCalculateFee: boolean): [Transaction, Transaction];
-interface CreateRefundTxInput {
-    sequence: number;
-    input: TransactionInput;
-    amountSats: bigint;
-    receivingPubkey: Uint8Array;
-    network: Network;
-    shouldCalculateFee: boolean;
-    includeAnchor: boolean;
-}
-declare function createRefundTx({ sequence, input, amountSats, receivingPubkey, network, shouldCalculateFee, includeAnchor, }: CreateRefundTxInput): Transaction;
 declare function getNextHTLCTransactionSequence(currSequence: number, isNodeTx?: boolean): {
     nextSequence: number;
     nextDirectSequence: number;
 };
-interface CreateRefundTxsInput {
-    sequence: number;
-    directSequence?: number;
-    input: TransactionInput;
-    directInput?: TransactionInput;
-    amountSats: bigint;
+interface RefundTxParams {
+    nodeTx: Transaction;
+    directNodeTx?: Transaction;
     receivingPubkey: Uint8Array;
     network: Network;
 }
-declare function createRefundTxs({ sequence, directSequence, input, directInput, amountSats, receivingPubkey, network, }: CreateRefundTxsInput): {
+interface RefundTxWithSequenceParams extends RefundTxParams {
+    sequence: number;
+}
+interface RefundTxWithSequenceAndConnectorOutputParams extends RefundTxWithSequenceParams {
+    connectorOutput: TransactionInput;
+}
+interface RefundTxs {
     cpfpRefundTx: Transaction;
     directRefundTx?: Transaction;
     directFromCpfpRefundTx?: Transaction;
-};
-declare function createConnectorRefundTransactions(sequence: number, cpfpNodeOutPoint: TransactionInput, directNodeOutPoint: TransactionInput, connectorOutput: TransactionInput, amountSats: bigint, receiverPubKey: Uint8Array, network: Network, shouldCalculateFee: boolean): [Transaction, Transaction, Transaction];
+}
+declare function createInitialTimelockRefundTxs(params: RefundTxParams): RefundTxs;
+declare function createDecrementedTimelockRefundTxs(params: RefundTxWithSequenceParams): RefundTxs;
+declare function createCurrentTimelockRefundTxs(params: RefundTxWithSequenceParams): RefundTxs;
+declare function createTestUnilateralRefundTxs(params: RefundTxParams): RefundTxs;
+declare function createConnectorRefundTxs(params: RefundTxWithSequenceAndConnectorOutputParams): RefundTxs;
 declare function getCurrentTimelock(currSequence?: number): number;
 declare function getTransactionSequence(currSequence?: number): {
     nextSequence: number;
     nextDirectSequence: number;
 };
 declare function checkIfValidSequence(currSequence?: number): void;
+declare function isZeroTimelock(currSequence: number): boolean;
+declare function doesTxnNeedRenewed(currSequence: number): boolean;
 declare function doesLeafNeedRefresh(currSequence: number, isNodeTx?: boolean): boolean;
 declare function getNextTransactionSequence(currSequence: number, isNodeTx?: boolean): {
     nextSequence: number;
@@ -4766,6 +4811,7 @@ interface BroadcastResult {
 declare function isEphemeralAnchorOutput(script?: Uint8Array, amount?: bigint): boolean;
 declare function constructUnilateralExitTxs(nodeHexStrings: string[], sparkClient?: SparkServiceClient, network?: any): Promise<TxChain[]>;
 declare function constructUnilateralExitFeeBumpPackages(nodeHexStrings: string[], utxos: Utxo[], feeRate: FeeRate, electrsUrl: string, sparkClient?: SparkServiceClient, network?: any): Promise<FeeBumpTxChain[]>;
+declare function hash160(data: Uint8Array): Uint8Array;
 declare function constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRate, previousFeeBumpTx?: string): {
     feeBumpPsbt: string;
     usedUtxos: Utxo[];
@@ -4787,4 +4833,4 @@ declare class SparkSdkLogger {
     static setAllEnabled(enabled: boolean): void;
 }
 
-export { type AggregateFrostParams, AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, ConfigurationError, DEFAULT_FEE_SATS, DIRECT_HTLC_TIMELOCK_OFFSET, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, DefaultSparkSigner, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, HTLC_TIMELOCK_OFFSET, type IKeyPackage, INITIAL_DIRECT_SEQUENCE, INITIAL_SEQUENCE, InternalValidationError, LOGGER_NAMES, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, RPCError, type SignFrostParams, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, type SparkSigner, SparkWalletBare as SparkWallet, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, TaprootOutputKeysGenerator, TaprootSparkSigner, type TxChain, UnsafeStatelessSparkSigner, type Utxo, ValidationError, type VerifiableSecretShare, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, assertBech32, bech32mDecode, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createConnectorRefundTransactions, createLeafNodeTx, createNodeTx, createNodeTxs, createRefundTx, createRefundTxs, createRootTx, createSigningCommitment, createSigningNonce, createSplitTx, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, doesLeafNeedRefresh, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, encodeSparkAddressWithSignature, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenIdentifier, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromBech32mTokenIdentifier, getNetworkFromSparkAddress, getNetworkFromString, getNextHTLCTransactionSequence, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isLegacySparkAddress, isSafeForNumber, isTxBroadcast, isValidPublicKey, isValidSparkAddress, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, toProtoTimestamp, validateOutboundAdaptorSignature, validateShare, validateSparkInvoiceFields, validateSparkInvoiceSignature };
+export { type AggregateFrostParams, AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, ConfigurationError, DEFAULT_FEE_SATS, DIRECT_HTLC_TIMELOCK_OFFSET, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, DefaultSparkSigner, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, HTLC_TIMELOCK_OFFSET, type IKeyPackage, INITIAL_SEQUENCE, InternalValidationError, LOGGER_NAMES, type LeafInfo, type LegacySparkAddressFormat, type LoggerName, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, RPCError, type SignFrostParams, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkSdkLogger, type SparkSigner, SparkWalletBare as SparkWallet, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, TaprootOutputKeysGenerator, TaprootSparkSigner, type TxChain, UnsafeStatelessSparkSigner, type Utxo, ValidationError, type VerifiableSecretShare, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, assertBech32, bech32mDecode, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createConnectorRefundTxs, createCurrentTimelockRefundTxs, createDecrementedTimelockNodeTx, createDecrementedTimelockRefundTxs, createInitialTimelockNodeTx, createInitialTimelockRefundTxs, createRootNodeTx, createSigningCommitment, createSigningNonce, createTestUnilateralRefundTxs, createTestUnilateralTimelockNodeTx, createZeroTimelockNodeTx, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, doesLeafNeedRefresh, doesTxnNeedRenewed, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, encodeSparkAddressWithSignature, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenIdentifier, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromBech32mTokenIdentifier, getNetworkFromSparkAddress, getNetworkFromString, getNextHTLCTransactionSequence, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, hash160, isEphemeralAnchorOutput, isLegacySparkAddress, isSafeForNumber, isTxBroadcast, isValidPublicKey, isValidSparkAddress, isZeroTimelock, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, toProtoTimestamp, validateOutboundAdaptorSignature, validateShare, validateSparkInvoiceFields, validateSparkInvoiceSignature };