@buildonspark/spark-sdk 0.2.3 → 0.2.5

package/dist/native/index.d.ts

@@ -1651,6 +1651,7 @@ declare function getTxFromRawTxBytes(rawTxBytes: Uint8Array): btc.Transaction;
 declare function getSigHashFromTx(tx: btc.Transaction, inputIndex: number, prevOutput: TransactionOutput): Uint8Array;
 declare function getTxId(tx: btc.Transaction): string;
 declare function getTxIdNoReverse(tx: btc.Transaction): string;
+declare function getTxEstimatedVbytesSizeByNumberOfInputsOutputs(numInputs: number, numOutputs: number): number;
 
 declare function addPublicKeys(a: Uint8Array, b: Uint8Array): Uint8Array;
 declare function applyAdditiveTweakToPublicKey(pubkey: Uint8Array, tweak: Uint8Array): Uint8Array<ArrayBufferLike>;
@@ -2163,8 +2164,21 @@ declare class DefaultSparkSigner implements SparkSigner {
     signTransactionIndex(tx: Transaction, index: number, publicKey: Uint8Array): void;
 }
 
-interface ClaimStaticDepositOutput {
-    transferId: string;
+declare enum ClaimStaticDepositStatus {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    CREATED = "CREATED",
+    TRANSFER_CREATED = "TRANSFER_CREATED",
+    TRANSFER_CREATION_FAILED = "TRANSFER_CREATION_FAILED",
+    REFUND_SIGNING_COMMITMENTS_QUERYING_FAILED = "REFUND_SIGNING_COMMITMENTS_QUERYING_FAILED",
+    REFUND_SIGNING_FAILED = "REFUND_SIGNING_FAILED",
+    UTXO_SWAPPING_FAILED = "UTXO_SWAPPING_FAILED",
+    TRANSFER_COMPLETED = "TRANSFER_COMPLETED",
+    SPEND_TX_CREATED = "SPEND_TX_CREATED",
+    SPEND_TX_BROADCAST = "SPEND_TX_BROADCAST"
 }
 
 /** This enum identifies the unit of currency associated with a CurrencyAmount. **/
@@ -2216,6 +2230,36 @@ interface CurrencyAmount {
     preferredCurrencyValueApprox: number;
 }
 
+interface ClaimStaticDeposit {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The network the lightning send request is on. **/
+    network: BitcoinNetwork;
+    /** The amount of credit to be added to the user's balance. **/
+    creditAmount: CurrencyAmount;
+    /** The maximum fee that the user is willing to pay. **/
+    maxFee: CurrencyAmount;
+    /** The status of the request. **/
+    status: ClaimStaticDepositStatus;
+    /** The transaction id of the deposit. **/
+    transactionId: string;
+    /** The output index of the deposit. **/
+    outputIndex: number;
+    /** The Bitcoin network of the deposit. **/
+    bitcoinNetwork: BitcoinNetwork;
+    /** The typename of the object **/
+    typename: string;
+    /** The id of the transfer. **/
+    transferSparkId?: string | undefined;
+}
+
 declare enum ExitSpeed {
     /**
      * This is an enum value that represents values that could be added in the future.
@@ -2334,88 +2378,6 @@ interface CoopExitRequest {
     transfer?: Transfer | undefined;
 }
 
-interface CompleteCoopExitInput {
-    userOutboundTransferExternalId: string;
-    coopExitRequestId: string;
-}
-
-interface CompleteLeavesSwapInput {
-    adaptorSecretKey: string;
-    userOutboundTransferExternalId: string;
-    leavesSwapRequestId: string;
-}
-
-interface CoopExitFeeEstimate {
-    userFee: CurrencyAmount;
-    l1BroadcastFee: CurrencyAmount;
-}
-
-interface CoopExitFeeEstimatesInput {
-    leafExternalIds: string[];
-    withdrawalAddress: string;
-}
-
-interface CoopExitFeeEstimatesOutput {
-    speedFast?: CoopExitFeeEstimate | undefined;
-    speedMedium?: CoopExitFeeEstimate | undefined;
-    speedSlow?: CoopExitFeeEstimate | undefined;
-}
-
-interface CoopExitFeeQuote {
-    /**
-     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
-     * string.
-     **/
-    id: string;
-    /** The date and time when the entity was first created. **/
-    createdAt: string;
-    /** The date and time when the entity was last updated. **/
-    updatedAt: string;
-    /** The network the coop exit fee quote is on. **/
-    network: BitcoinNetwork;
-    /** The total currency amount of all the nodes user swapped for the coop exit quote. **/
-    totalAmount: CurrencyAmount;
-    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is fast. **/
-    userFeeFast: CurrencyAmount;
-    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is medium. **/
-    userFeeMedium: CurrencyAmount;
-    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is slow. **/
-    userFeeSlow: CurrencyAmount;
-    /** The L1 broadcast fee user pays for the coop exit when exit speed is fast. **/
-    l1BroadcastFeeFast: CurrencyAmount;
-    /** The L1 broadcast fee user pays for the coop exit when exit speed is medium. **/
-    l1BroadcastFeeMedium: CurrencyAmount;
-    /** The L1 broadcast fee user pays for the coop exit when exit speed is slow. **/
-    l1BroadcastFeeSlow: CurrencyAmount;
-    /** The time when the coop exit fee quote expires. **/
-    expiresAt: string;
-    /** The typename of the object **/
-    typename: string;
-}
-
-interface CoopExitFeeQuoteInput {
-    leafExternalIds: string[];
-    withdrawalAddress: string;
-}
-
-interface GetChallengeOutput {
-    protectedChallenge: string;
-}
-
-interface Invoice {
-    encodedInvoice: string;
-    bitcoinNetwork: BitcoinNetwork;
-    paymentHash: string;
-    amount: CurrencyAmount;
-    createdAt: string;
-    expiresAt: string;
-    memo?: string | undefined;
-}
-
-interface LeavesSwapFeeEstimateOutput {
-    feeEstimate: CurrencyAmount;
-}
-
 declare enum SparkLeavesSwapRequestStatus {
     /**
      * This is an enum value that represents values that could be added in the future.
@@ -2436,6 +2398,10 @@ interface SwapLeaf {
     leafId: string;
     rawUnsignedRefundTransaction: string;
     adaptorSignedSignature: string;
+    directRawUnsignedRefundTransaction?: string;
+    directAdaptorSignedSignature?: string;
+    directFromCpfpRawUnsignedRefundTransaction?: string;
+    directFromCpfpAdaptorSignedSignature?: string;
 }
 
 interface LeavesSwapRequest {
@@ -2470,6 +2436,16 @@ interface LeavesSwapRequest {
     expiresAt?: string | undefined;
 }
 
+interface Invoice {
+    encodedInvoice: string;
+    bitcoinNetwork: BitcoinNetwork;
+    paymentHash: string;
+    amount: CurrencyAmount;
+    createdAt: string;
+    expiresAt: string;
+    memo?: string | undefined;
+}
+
 declare enum LightningReceiveRequestStatus {
     /**
      * This is an enum value that represents values that could be added in the future.
@@ -2514,19 +2490,6 @@ interface LightningReceiveRequest {
     receiverIdentityPublicKey?: string | undefined;
 }
 
-interface LightningSendFeeEstimateInput {
-    encodedInvoice: string;
-    /**
- * The amount you will pay for this invoice in sats. It should ONLY be set when the invoice amount is
- * zero.
-**/
-    amountSats?: number | undefined;
-}
-
-interface LightningSendFeeEstimateOutput {
-    feeEstimate: CurrencyAmount;
-}
-
 declare enum LightningSendRequestStatus {
     /**
      * This is an enum value that represents values that could be added in the future.
@@ -2570,6 +2533,137 @@ interface LightningSendRequest {
     paymentPreimage?: string | undefined;
 }
 
+interface WalletLeaf {
+    id: string;
+    treeId: string;
+    value: number;
+    parentNodeId?: string | undefined;
+    nodeTx: string;
+    refundTx: string;
+    vout: number;
+    verifyingPublicKey: string;
+    ownerIdentityPublicKey: string;
+    signingKeyshare: SigningKeyshare | undefined;
+    status: string;
+    network: keyof typeof Network$1;
+}
+declare enum TransferDirection {
+    INCOMING = "INCOMING",
+    OUTGOING = "OUTGOING"
+}
+type UserRequestType = LightningSendRequest | LightningReceiveRequest | LeavesSwapRequest | CoopExitRequest | ClaimStaticDeposit;
+interface WalletTransfer {
+    id: string;
+    senderIdentityPublicKey: string;
+    receiverIdentityPublicKey: string;
+    status: keyof typeof TransferStatus;
+    totalValue: number;
+    expiryTime: Date | undefined;
+    leaves: WalletTransferLeaf[];
+    createdTime: Date | undefined;
+    updatedTime: Date | undefined;
+    type: keyof typeof TransferType;
+    transferDirection: keyof typeof TransferDirection;
+    userRequest: Omit<UserRequestType, "transfer"> | undefined;
+}
+interface WalletTransferLeaf {
+    leaf: WalletLeaf | undefined;
+    secretCipher: string;
+    signature: string;
+    intermediateRefundTx: string;
+}
+
+interface ClaimStaticDepositOutput {
+    transferId: string;
+}
+
+interface CompleteCoopExitInput {
+    userOutboundTransferExternalId: string;
+    coopExitRequestId: string;
+}
+
+interface CompleteLeavesSwapInput {
+    adaptorSecretKey: string;
+    directAdaptorSecretKey: string;
+    directFromCpfpAdaptorSecretKey: string;
+    userOutboundTransferExternalId: string;
+    leavesSwapRequestId: string;
+}
+
+interface CoopExitFeeEstimate {
+    userFee: CurrencyAmount;
+    l1BroadcastFee: CurrencyAmount;
+}
+
+interface CoopExitFeeEstimatesInput {
+    leafExternalIds: string[];
+    withdrawalAddress: string;
+}
+
+interface CoopExitFeeEstimatesOutput {
+    speedFast?: CoopExitFeeEstimate | undefined;
+    speedMedium?: CoopExitFeeEstimate | undefined;
+    speedSlow?: CoopExitFeeEstimate | undefined;
+}
+
+interface CoopExitFeeQuote {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The network the coop exit fee quote is on. **/
+    network: BitcoinNetwork;
+    /** The total currency amount of all the nodes user swapped for the coop exit quote. **/
+    totalAmount: CurrencyAmount;
+    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is fast. **/
+    userFeeFast: CurrencyAmount;
+    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is medium. **/
+    userFeeMedium: CurrencyAmount;
+    /** The fee user pays for the coop exit not including the L1 broadcast fee when exit speed is slow. **/
+    userFeeSlow: CurrencyAmount;
+    /** The L1 broadcast fee user pays for the coop exit when exit speed is fast. **/
+    l1BroadcastFeeFast: CurrencyAmount;
+    /** The L1 broadcast fee user pays for the coop exit when exit speed is medium. **/
+    l1BroadcastFeeMedium: CurrencyAmount;
+    /** The L1 broadcast fee user pays for the coop exit when exit speed is slow. **/
+    l1BroadcastFeeSlow: CurrencyAmount;
+    /** The time when the coop exit fee quote expires. **/
+    expiresAt: string;
+    /** The typename of the object **/
+    typename: string;
+}
+
+interface CoopExitFeeQuoteInput {
+    leafExternalIds: string[];
+    withdrawalAddress: string;
+}
+
+interface GetChallengeOutput {
+    protectedChallenge: string;
+}
+
+interface LeavesSwapFeeEstimateOutput {
+    feeEstimate: CurrencyAmount;
+}
+
+interface LightningSendFeeEstimateInput {
+    encodedInvoice: string;
+    /**
+ * The amount you will pay for this invoice in sats. It should ONLY be set when the invoice amount is
+ * zero.
+**/
+    amountSats?: number | undefined;
+}
+
+interface LightningSendFeeEstimateOutput {
+    feeEstimate: CurrencyAmount;
+}
+
 interface RequestCoopExitInput {
     leafExternalIds: string[];
     withdrawalAddress: string;
@@ -2583,11 +2677,17 @@ interface RequestCoopExitInput {
 interface UserLeafInput {
     leaf_id: string;
     raw_unsigned_refund_transaction: string;
+    direct_raw_unsigned_refund_transaction: string;
+    direct_from_cpfp_raw_unsigned_refund_transaction: string;
     adaptor_added_signature: string;
+    direct_adaptor_added_signature: string;
+    direct_from_cpfp_adaptor_added_signature: string;
 }
 
 interface RequestLeavesSwapInput {
     adaptorPubkey: string;
+    directAdaptorPubkey?: string;
+    directFromCpfpAdaptorPubkey?: string;
     totalAmountSats: number;
     targetAmountSats: number;
     feeSats: number;
@@ -2671,6 +2771,9 @@ interface SspClientOptions {
     identityPublicKey: string;
     schemaEndpoint?: string;
 }
+interface TransferWithUserRequest extends Transfer {
+    userRequest?: UserRequestType;
+}
 interface MayHaveSspClientOptions {
     readonly sspClientOptions?: SspClientOptions;
 }
@@ -2694,8 +2797,8 @@ declare class SspClient {
     requestCoopExit({ leafExternalIds, withdrawalAddress, idempotencyKey, exitSpeed, feeLeafExternalIds, feeQuoteId, withdrawAll, }: RequestCoopExitInput): Promise<CoopExitRequest | null>;
     requestLightningReceive({ amountSats, network, paymentHash, expirySecs, memo, includeSparkAddress, receiverIdentityPubkey, descriptionHash, }: RequestLightningReceiveInput): Promise<LightningReceiveRequest | null>;
     requestLightningSend({ encodedInvoice, idempotencyKey, amountSats, }: RequestLightningSendInput): Promise<LightningSendRequest | null>;
-    requestLeaveSwap({ adaptorPubkey, totalAmountSats, targetAmountSats, feeSats, userLeaves, idempotencyKey, targetAmountSatsList, }: RequestLeavesSwapInput): Promise<LeavesSwapRequest | null>;
-    completeLeaveSwap({ adaptorSecretKey, userOutboundTransferExternalId, leavesSwapRequestId, }: CompleteLeavesSwapInput): Promise<LeavesSwapRequest | null>;
+    requestLeaveSwap({ adaptorPubkey, directAdaptorPubkey, directFromCpfpAdaptorPubkey, totalAmountSats, targetAmountSats, feeSats, userLeaves, idempotencyKey, targetAmountSatsList, }: RequestLeavesSwapInput): Promise<LeavesSwapRequest | null>;
+    completeLeaveSwap({ adaptorSecretKey, directAdaptorSecretKey, directFromCpfpAdaptorSecretKey, userOutboundTransferExternalId, leavesSwapRequestId, }: CompleteLeavesSwapInput): Promise<LeavesSwapRequest | null>;
     getLightningReceiveRequest(id: string): Promise<LightningReceiveRequest | null>;
     getLightningSendRequest(id: string): Promise<LightningSendRequest | null>;
     getLeaveSwapRequest(id: string): Promise<LeavesSwapRequest | null>;
@@ -2710,7 +2813,7 @@ declare class SspClient {
         signature: string;
         sspSignature: string;
     }): Promise<ClaimStaticDepositOutput | null>;
-    getTransfer(id: string): Promise<Transfer | null>;
+    getTransfers(ids: string[]): Promise<TransferWithUserRequest[]>;
     getChallenge(): Promise<GetChallengeOutput | null>;
     verifyChallenge(signature: string, protectedChallenge: string): Promise<VerifyChallengeOutput | null>;
     authenticate(): Promise<void>;
@@ -2844,19 +2947,66 @@ declare function filterTokenBalanceForTokenPublicKey(tokenBalances: TokenBalance
 
 declare function getTransferPackageSigningPayload(transferID: string, transferPackage: TransferPackage): Uint8Array;
 
+declare const DIRECT_TIMELOCK_OFFSET = 50;
+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;
 /**
  * Subtracts the default fee from the amount if it's greater than the fee.
  * Returns the original amount if it's less than or equal to the fee.
  */
 declare function maybeApplyFee(amount: bigint): bigint;
-declare function createRefundTx(sequence: number, nodeOutPoint: TransactionInput, amountSats: bigint, receivingPubkey: Uint8Array, network: Network): Transaction;
+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 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;
+interface CreateRefundTxsInput {
+    sequence: number;
+    directSequence?: number;
+    input: TransactionInput;
+    directInput?: TransactionInput;
+    amountSats: bigint;
+    receivingPubkey: Uint8Array;
+    network: Network;
+}
+declare function createRefundTxs({ sequence, directSequence, input, directInput, amountSats, receivingPubkey, network, }: CreateRefundTxsInput): {
+    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 getCurrentTimelock(currSequence?: number): number;
-declare function getTransactionSequence(currSequence?: number): number;
+declare function getTransactionSequence(currSequence?: number): {
+    nextSequence: number;
+    nextDirectSequence: number;
+};
 declare function checkIfValidSequence(currSequence?: number): void;
-declare function getNextTransactionSequence(currSequence?: number, forRefresh?: boolean): {
+declare function doesLeafNeedRefresh(currSequence: number, isNodeTx?: boolean): boolean;
+declare function getNextTransactionSequence(currSequence: number, isNodeTx?: boolean): {
     nextSequence: number;
-    needRefresh: boolean;
+    nextDirectSequence: number;
 };
 declare function getEphemeralAnchorOutput(): TransactionOutput;
 
@@ -3027,7 +3177,12 @@ declare class ConnectionManager {
 declare class SigningService {
     private readonly config;
     constructor(config: WalletConfigService);
-    signRefunds(leaves: LeafKeyTweak[], signingCommitments: RequestedSigningCommitments[], receiverIdentityPubkey: Uint8Array): Promise<UserSignedTxSigningJob[]>;
+    private signRefundsInternal;
+    signRefunds(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, cpfpSigningCommitments: RequestedSigningCommitments[], directSigningCommitments: RequestedSigningCommitments[], directFromCpfpSigningCommitments: RequestedSigningCommitments[]): Promise<{
+        cpfpLeafSigningJobs: UserSignedTxSigningJob[];
+        directLeafSigningJobs: UserSignedTxSigningJob[];
+        directFromCpfpLeafSigningJobs: UserSignedTxSigningJob[];
+    }>;
 }
 
 type LeafKeyTweak = {
@@ -3035,19 +3190,17 @@ type LeafKeyTweak = {
     keyDerivation: KeyDerivation;
     newKeyDerivation: KeyDerivation;
 };
-type ClaimLeafData = {
-    keyDerivation: KeyDerivation;
-    tx?: Transaction;
-    refundTx?: Transaction;
-    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
-    vout?: number;
-};
 type LeafRefundSigningData = {
     keyDerivation: KeyDerivation;
     receivingPubkey: Uint8Array;
+    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
+    directSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
     tx: Transaction;
+    directTx?: Transaction;
     refundTx?: Transaction;
-    signingNonceCommitment: SigningCommitmentWithOptionalNonce;
+    directRefundTx?: Transaction;
+    directFromCpfpRefundTx?: Transaction;
+    directFromCpfpRefundSigningNonceCommitment: SigningCommitmentWithOptionalNonce;
     vout: number;
 };
 declare class BaseTransferService {
@@ -3055,12 +3208,12 @@ declare class BaseTransferService {
     protected readonly connectionManager: ConnectionManager;
     protected readonly signingService: SigningService;
     constructor(config: WalletConfigService, connectionManager: ConnectionManager, signingService: SigningService);
-    sendTransferTweakKey(transfer: Transfer$1, leaves: LeafKeyTweak[], refundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
-    deliverTransferPackage(transfer: Transfer$1, leaves: LeafKeyTweak[], refundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
+    sendTransferTweakKey(transfer: Transfer$1, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
+    deliverTransferPackage(transfer: Transfer$1, leaves: LeafKeyTweak[], cpfpRefundSignatureMap: Map<string, Uint8Array>, directRefundSignatureMap: Map<string, Uint8Array>, directFromCpfpRefundSignatureMap: Map<string, Uint8Array>): Promise<Transfer$1>;
     sendTransferWithKeyTweaks(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array): Promise<Transfer$1>;
     private prepareTransferPackage;
     private finalizeTransfer;
-    signRefunds(leafDataMap: Map<string, ClaimLeafData>, operatorSigningResults: LeafRefundTxSigningResult[], adaptorPubKey?: Uint8Array): Promise<NodeSignatures[]>;
+    signRefunds(leafDataMap: Map<string, LeafRefundSigningData>, operatorSigningResults: LeafRefundTxSigningResult[], cpfpAdaptorPubKey?: Uint8Array, directAdaptorPubKey?: Uint8Array, directFromCpfpAdaptorPubKey?: Uint8Array): Promise<NodeSignatures[]>;
     private prepareSendTransferKeyTweaks;
     private prepareSingleSendTransferKeyTweak;
     protected findShare(shares: VerifiableSecretShare[], operatorID: number): VerifiableSecretShare | undefined;
@@ -3081,22 +3234,30 @@ declare class TransferService extends BaseTransferService {
     sendTransferSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
         transfer: Transfer$1;
         signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
         leafDataMap: Map<string, LeafRefundSigningData>;
     }>;
     startSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date): Promise<{
         transfer: Transfer$1;
         signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
         leafDataMap: Map<string, LeafRefundSigningData>;
     }>;
-    counterSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, adaptorPubKey?: Uint8Array): Promise<{
+    counterSwapSignRefund(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, cpfpAdaptorPubKey?: Uint8Array, directAdaptorPubKey?: Uint8Array, directFromCpfpAdaptorPubKey?: Uint8Array): Promise<{
         transfer: Transfer$1;
         signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
         leafDataMap: Map<string, LeafRefundSigningData>;
         signingResults: LeafRefundTxSigningResult[];
     }>;
-    sendTransferSignRefundInternal(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, forSwap: boolean, adaptorPubKey?: Uint8Array): Promise<{
+    sendTransferSignRefundInternal(leaves: LeafKeyTweak[], receiverIdentityPubkey: Uint8Array, expiryTime: Date, forSwap: boolean, cpfpAdaptorPubKey?: Uint8Array, directAdaptorPubKey?: Uint8Array, directFromCpfpAdaptorPubKey?: Uint8Array): Promise<{
         transfer: Transfer$1;
         signatureMap: Map<string, Uint8Array>;
+        directSignatureMap: Map<string, Uint8Array>;
+        directFromCpfpSignatureMap: Map<string, Uint8Array>;
         leafDataMap: Map<string, LeafRefundSigningData>;
         signingResults: LeafRefundTxSigningResult[];
     }>;
@@ -3108,47 +3269,11 @@ declare class TransferService extends BaseTransferService {
     private finalizeNodeSignatures;
     cancelTransfer(transfer: Transfer$1, operatorAddress: string): Promise<Transfer$1 | undefined>;
     queryPendingTransfersBySender(operatorAddress: string): Promise<QueryTransfersResponse>;
-    refreshTimelockNodes(nodes: TreeNode[], parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    private refreshTimelockNodesInternal;
+    refreshTimelockNodes(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
     extendTimelock(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-    refreshTimelockRefundTx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
-}
-
-interface WalletLeaf {
-    id: string;
-    treeId: string;
-    value: number;
-    parentNodeId?: string | undefined;
-    nodeTx: string;
-    refundTx: string;
-    vout: number;
-    verifyingPublicKey: string;
-    ownerIdentityPublicKey: string;
-    signingKeyshare: SigningKeyshare | undefined;
-    status: string;
-    network: keyof typeof Network$1;
-}
-declare enum TransferDirection {
-    INCOMING = "INCOMING",
-    OUTGOING = "OUTGOING"
-}
-interface WalletTransfer {
-    id: string;
-    senderIdentityPublicKey: string;
-    receiverIdentityPublicKey: string;
-    status: keyof typeof TransferStatus;
-    totalValue: number;
-    expiryTime: Date | undefined;
-    leaves: WalletTransferLeaf[];
-    createdTime: Date | undefined;
-    updatedTime: Date | undefined;
-    type: keyof typeof TransferType;
-    transferDirection: keyof typeof TransferDirection;
-}
-interface WalletTransferLeaf {
-    leaf: WalletLeaf | undefined;
-    secretCipher: string;
-    signature: string;
-    intermediateRefundTx: string;
+    testonly_expireTimeLockNodeTx(node: TreeNode, parentNode: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
+    testonly_expireTimeLockRefundtx(node: TreeNode): Promise<FinalizeNodeSignaturesResponse>;
 }
 
 /**
@@ -3336,20 +3461,37 @@ declare class SparkWallet extends EventEmitter {
         sspSignature: string;
         outputIndex?: number;
     }): Promise<ClaimStaticDepositOutput | null>;
+    /**
+     * Get a quote on how much credit you can claim for a deposit from the SSP. If the quote charges less fees than the max fee, claim the deposit.
+     *
+     * @param {Object} params - The parameters object
+     * @param {string} params.transactionId - The ID of the transaction
+     * @param {number} params.maxFee - The maximum fee to claim the deposit for
+     * @param {number} [params.outputIndex] - The index of the output
+     * @returns {Promise<StaticDepositQuoteOutput>} Quote for claiming a deposit to a static deposit address
+     */
+    claimStaticDepositWithMaxFee({ transactionId, maxFee, outputIndex, }: {
+        transactionId: string;
+        maxFee: number;
+        outputIndex?: number;
+    }): Promise<ClaimStaticDepositOutput | null>;
     /**
      * Refunds a static deposit to a destination address.
      *
-     * @param {string} depositTransactionId - The ID of the transaction
-     * @param {number} [outputIndex] - The index of the output
-     * @param {string} destinationAddress - The destination address
-     * @param {number} fee - The fee to refund
+     * @param {Object} params - The refund parameters
+     * @param {string} params.depositTransactionId - The ID of the transaction
+     * @param {number} [params.outputIndex] - The index of the output
+     * @param {string} params.destinationAddress - The destination address
+     * @param {number} [params.fee] - **@deprecated** The fee to refund
+     * @param {number} [params.satsPerVbyteFee] - The fee per vbyte to refund
      * @returns {Promise<string>} The hex of the refund transaction
      */
-    refundStaticDeposit({ depositTransactionId, outputIndex, destinationAddress, fee, }: {
+    refundStaticDeposit({ depositTransactionId, outputIndex, destinationAddress, fee, satsPerVbyteFee, }: {
         depositTransactionId: string;
         outputIndex?: number;
         destinationAddress: string;
-        fee: number;
+        /** @deprecated use `satsPerVbyteFee` */ fee?: number;
+        satsPerVbyteFee?: number;
     }): Promise<string>;
     private getStaticDepositSigningPayload;
     private getDepositTransactionVout;
@@ -3537,9 +3679,9 @@ declare class SparkWallet extends EventEmitter {
      * Gets a transfer that has been sent by the SSP to the wallet.
      *
      * @param {string} id - The ID of the transfer
-     * @returns {Promise<GraphQLTransferObj | null>} The transfer
+     * @returns {Promise<TransferWithUserRequest | undefined>} The transfer
      */
-    getTransferFromSsp(id: string): Promise<Transfer | null>;
+    getTransferFromSsp(id: string): Promise<TransferWithUserRequest | undefined>;
     /**
      * Gets a transfer, that the wallet is a participant of, in the Spark network.
      * Only contains data about the spark->spark transfer, use getTransferFromSsp if you're
@@ -3675,13 +3817,6 @@ declare class SparkWallet extends EventEmitter {
      * @returns {Promise<void>} Promise that resolves when the timelock is refreshed
      */
     testOnly_expireTimelock(nodeId: string): Promise<void>;
-    /**
-     * Refresh the timelock of a specific node's refund transaction only.
-     *
-     * @param {string} nodeId - The ID of the node whose refund transaction to refresh
-     * @returns {Promise<void>} Promise that resolves when the refund timelock is refreshed
-     */
-    testOnly_expireTimelockRefundTx(nodeId: string): Promise<void>;
     private cleanup;
     cleanupConnections(): Promise<void>;
     private startPeriodicClaimTransfers;
@@ -3743,4 +3878,4 @@ declare class TokenTransactionService {
     private createSignaturesForOperators;
 }
 
-export { AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, type ConfigOptions, ConfigurationError, ConnectionManager, type CreateLightningInvoiceParams, DEFAULT_FEE_SATS, type DecodedSparkAddressData, ReactNativeSparkSigner as DefaultSparkSigner, type DepositParams, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type InitWalletResponse, InternalValidationError, LRC_WALLET_NETWORK, LRC_WALLET_NETWORK_TYPE, type LeafInfo, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, type RawTokenIdentifierHex, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkWallet, type SparkWalletEvents, type SparkWalletProps, type TokenBalanceMap, type TokenMetadataMap, type TokenOutputsMap, TokenTransactionService, type TransferParams, type TxChain, type UserTokenMetadata, type Utxo, ValidationError, type VerifiableSecretShare, WalletConfig, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, bigIntToPrivateKey, checkIfSelectedOutputsAreAvailable, checkIfValidSequence, collectResponses, computeTaprootKeyNoScript, computerLagrangeCoefficients, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createRefundTx, createSigningCommitment, createSigningNonce, decodeBech32mTokenIdentifier, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, decodeSparkAddress, encodeBech32mTokenIdentifier, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, encodeSparkAddress, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromString, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isTxBroadcast, isValidPublicKey, isValidSparkAddress, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, validateOutboundAdaptorSignature, validateShare };
+export { AuthenticationError, type Bech32mTokenIdentifier, type Bech32mTokenIdentifierData, type BroadcastConfig, type BroadcastResult, type ConfigOptions, ConfigurationError, ConnectionManager, type CreateLightningInvoiceParams, DEFAULT_FEE_SATS, DIRECT_TIMELOCK_OFFSET, type DecodedSparkAddressData, ReactNativeSparkSigner as DefaultSparkSigner, type DepositParams, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, INITIAL_DIRECT_SEQUENCE, INITIAL_SEQUENCE, type InitWalletResponse, InternalValidationError, LRC_WALLET_NETWORK, LRC_WALLET_NETWORK_TYPE, type LeafInfo, Network, NetworkError, NetworkToProto, type NetworkType, NotImplementedError, type PayLightningInvoiceParams, RPCError, type RawTokenIdentifierHex, ReactNativeSparkSigner, type SparkAddressData, type SparkAddressFormat, SparkSDKError, SparkWallet, type SparkWalletEvents, type SparkWalletProps, TEST_UNILATERAL_DIRECT_SEQUENCE, TEST_UNILATERAL_SEQUENCE, type TokenBalanceMap, type TokenMetadataMap, type TokenOutputsMap, TokenTransactionService, type TransferParams, type TxChain, type UserTokenMetadata, type Utxo, ValidationError, type VerifiableSecretShare, WalletConfig, WalletConfigService, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, 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, evaluatePolynomial, fieldDiv, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generatePolynomialForSecretSharing, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNetwork, getNetworkFromAddress, getNetworkFromString, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomBigInt, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getSparkAddressFromTaproot, getTransactionSequence, getTransferPackageSigningPayload, getTxEstimatedVbytesSizeByNumberOfInputsOutputs, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isTxBroadcast, isValidPublicKey, isValidSparkAddress, lastKeyWithTarget, maybeApplyFee, modInverse, proofOfPossessionMessageHashForDepositAddress, protoToNetwork, recoverSecret, splitSecret, splitSecretWithProofs, subtractPrivateKeys, subtractPublicKeys, sumAvailableTokens, sumOfPrivateKeys, validateOutboundAdaptorSignature, validateShare };