@buildonspark/spark-sdk 0.1.38 → 0.1.40

package/dist/utils/index.d.cts

@@ -1,11 +1,11 @@
 import * as btc from '@scure/btc-signer';
 import { Transaction } from '@scure/btc-signer';
 import { TransactionOutput, TransactionInput } from '@scure/btc-signer/psbt';
-import { N as Network } from '../network-GFGEHkS4.cjs';
-export { L as LRC_WALLET_NETWORK, c as LRC_WALLET_NETWORK_TYPE, b as NetworkToProto, a as NetworkType, g as getNetwork, d as getNetworkFromAddress } from '../network-GFGEHkS4.cjs';
-import { i as SigningNonce, h as SigningCommitment } from '../signer-C1t40Wus.cjs';
-export { V as VerifiableSecretShare, d as bigIntToPrivateKey, c as computerLagrangeCoefficients, e as evaluatePolynomial, f as fieldDiv, a as generatePolynomialForSecretSharing, g as getRandomBigInt, m as modInverse, r as recoverSecret, s as splitSecret, b as splitSecretWithProofs, v as validateShare } from '../signer-C1t40Wus.cjs';
-import { j as OutputWithPreviousTransactionData, l as TransferPackage } from '../spark-DXYE9gMM.cjs';
+import { N as Network } from '../network-B10hBoHp.cjs';
+export { L as LRC_WALLET_NETWORK, c as LRC_WALLET_NETWORK_TYPE, b as NetworkToProto, a as NetworkType, g as getNetwork, d as getNetworkFromAddress, e as getNetworkFromString } from '../network-B10hBoHp.cjs';
+import { i as SigningNonce, h as SigningCommitment } from '../signer-CYwn7h9U.cjs';
+export { V as VerifiableSecretShare, d as bigIntToPrivateKey, c as computerLagrangeCoefficients, e as evaluatePolynomial, f as fieldDiv, a as generatePolynomialForSecretSharing, g as getRandomBigInt, m as modInverse, r as recoverSecret, s as splitSecret, b as splitSecretWithProofs, v as validateShare } from '../signer-CYwn7h9U.cjs';
+import { j as OutputWithPreviousTransactionData, l as TransferPackage, g as SparkServiceClient } from '../spark-DXYE9gMM.cjs';
 import '@buildonspark/lrc20-sdk';
 import 'bitcoinjs-lib';
 import '../BitcoinNetwork-TnABML0T.cjs';
@@ -41,6 +41,7 @@ declare function sumOfPrivateKeys(keys: Uint8Array[]): Uint8Array<ArrayBufferLik
 declare function lastKeyWithTarget(target: Uint8Array, keys: Uint8Array[]): Uint8Array<ArrayBufferLike>;
 
 declare function getLatestDepositTxId(address: string): Promise<string | null>;
+declare function isTxBroadcast(txid: string, baseUrl: string, network?: any): Promise<boolean>;
 
 declare function proofOfPossessionMessageHashForDepositAddress(userPubkey: Uint8Array, operatorPubkey: Uint8Array, depositAddress: string): Uint8Array;
 
@@ -65,6 +66,12 @@ declare function filterTokenBalanceForTokenPublicKey(tokenBalances: Map<string,
 
 declare function getTransferPackageSigningPayload(transferID: string, transferPackage: TransferPackage): Uint8Array;
 
+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 getCurrentTimelock(currSequence?: number): number;
 declare function getTransactionSequence(currSequence?: number): number;
@@ -74,4 +81,53 @@ declare function getNextTransactionSequence(currSequence?: number, forRefresh?:
 };
 declare function getEphemeralAnchorOutput(): TransactionOutput;
 
-export { Network, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, calculateAvailableTokenAmount, checkIfSelectedOutputsAreAvailable, collectResponses, computeTaprootKeyNoScript, createRefundTx, createSigningCommitment, createSigningNonce, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, lastKeyWithTarget, proofOfPossessionMessageHashForDepositAddress, subtractPrivateKeys, subtractPublicKeys, sumOfPrivateKeys, validateOutboundAdaptorSignature };
+interface LeafInfo {
+    leafId: string;
+    nodeTx: string;
+    refundTx: string;
+}
+interface Utxo {
+    txid: string;
+    vout: number;
+    value: bigint;
+    script: string;
+    publicKey: string;
+}
+interface FeeRate {
+    satPerVbyte: number;
+}
+interface FeeBumpTxPackage {
+    tx: string;
+    feeBumpPsbt?: string;
+}
+interface FeeBumpTxChain {
+    leafId: string;
+    txPackages: FeeBumpTxPackage[];
+}
+interface TxChain {
+    leafId: string;
+    transactions: string[];
+}
+interface BroadcastConfig {
+    bitcoinCoreRpcUrl?: string;
+    rpcUsername?: string;
+    rpcPassword?: string;
+    autoBroadcast?: boolean;
+    network?: "MAINNET" | "REGTEST" | "TESTNET" | "SIGNET" | "LOCAL";
+}
+interface BroadcastResult {
+    success: boolean;
+    txids?: string[];
+    error?: string;
+    broadcastedPackages?: number;
+}
+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 constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRate, previousFeeBumpTx?: string): {
+    feeBumpPsbt: string;
+    usedUtxos: Utxo[];
+    correctedParentTx?: string;
+};
+
+export { type BroadcastConfig, type BroadcastResult, DEFAULT_FEE_SATS, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type LeafInfo, Network, type TxChain, type Utxo, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, calculateAvailableTokenAmount, checkIfSelectedOutputsAreAvailable, collectResponses, computeTaprootKeyNoScript, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createRefundTx, createSigningCommitment, createSigningNonce, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isTxBroadcast, lastKeyWithTarget, maybeApplyFee, proofOfPossessionMessageHashForDepositAddress, subtractPrivateKeys, subtractPublicKeys, sumOfPrivateKeys, validateOutboundAdaptorSignature };

package/dist/utils/index.d.ts

@@ -1,11 +1,11 @@
 import * as btc from '@scure/btc-signer';
 import { Transaction } from '@scure/btc-signer';
 import { TransactionOutput, TransactionInput } from '@scure/btc-signer/psbt';
-import { N as Network } from '../network-DobHpaV6.js';
-export { L as LRC_WALLET_NETWORK, c as LRC_WALLET_NETWORK_TYPE, b as NetworkToProto, a as NetworkType, g as getNetwork, d as getNetworkFromAddress } from '../network-DobHpaV6.js';
-import { i as SigningNonce, h as SigningCommitment } from '../signer-DFGw9RRp.js';
-export { V as VerifiableSecretShare, d as bigIntToPrivateKey, c as computerLagrangeCoefficients, e as evaluatePolynomial, f as fieldDiv, a as generatePolynomialForSecretSharing, g as getRandomBigInt, m as modInverse, r as recoverSecret, s as splitSecret, b as splitSecretWithProofs, v as validateShare } from '../signer-DFGw9RRp.js';
-import { j as OutputWithPreviousTransactionData, l as TransferPackage } from '../spark-DXYE9gMM.js';
+import { N as Network } from '../network-CCgyIsGl.js';
+export { L as LRC_WALLET_NETWORK, c as LRC_WALLET_NETWORK_TYPE, b as NetworkToProto, a as NetworkType, g as getNetwork, d as getNetworkFromAddress, e as getNetworkFromString } from '../network-CCgyIsGl.js';
+import { i as SigningNonce, h as SigningCommitment } from '../signer-C5h1DpjF.js';
+export { V as VerifiableSecretShare, d as bigIntToPrivateKey, c as computerLagrangeCoefficients, e as evaluatePolynomial, f as fieldDiv, a as generatePolynomialForSecretSharing, g as getRandomBigInt, m as modInverse, r as recoverSecret, s as splitSecret, b as splitSecretWithProofs, v as validateShare } from '../signer-C5h1DpjF.js';
+import { j as OutputWithPreviousTransactionData, l as TransferPackage, g as SparkServiceClient } from '../spark-DXYE9gMM.js';
 import '@buildonspark/lrc20-sdk';
 import 'bitcoinjs-lib';
 import '../BitcoinNetwork-TnABML0T.js';
@@ -41,6 +41,7 @@ declare function sumOfPrivateKeys(keys: Uint8Array[]): Uint8Array<ArrayBufferLik
 declare function lastKeyWithTarget(target: Uint8Array, keys: Uint8Array[]): Uint8Array<ArrayBufferLike>;
 
 declare function getLatestDepositTxId(address: string): Promise<string | null>;
+declare function isTxBroadcast(txid: string, baseUrl: string, network?: any): Promise<boolean>;
 
 declare function proofOfPossessionMessageHashForDepositAddress(userPubkey: Uint8Array, operatorPubkey: Uint8Array, depositAddress: string): Uint8Array;
 
@@ -65,6 +66,12 @@ declare function filterTokenBalanceForTokenPublicKey(tokenBalances: Map<string,
 
 declare function getTransferPackageSigningPayload(transferID: string, transferPackage: TransferPackage): Uint8Array;
 
+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 getCurrentTimelock(currSequence?: number): number;
 declare function getTransactionSequence(currSequence?: number): number;
@@ -74,4 +81,53 @@ declare function getNextTransactionSequence(currSequence?: number, forRefresh?:
 };
 declare function getEphemeralAnchorOutput(): TransactionOutput;
 
-export { Network, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, calculateAvailableTokenAmount, checkIfSelectedOutputsAreAvailable, collectResponses, computeTaprootKeyNoScript, createRefundTx, createSigningCommitment, createSigningNonce, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, lastKeyWithTarget, proofOfPossessionMessageHashForDepositAddress, subtractPrivateKeys, subtractPublicKeys, sumOfPrivateKeys, validateOutboundAdaptorSignature };
+interface LeafInfo {
+    leafId: string;
+    nodeTx: string;
+    refundTx: string;
+}
+interface Utxo {
+    txid: string;
+    vout: number;
+    value: bigint;
+    script: string;
+    publicKey: string;
+}
+interface FeeRate {
+    satPerVbyte: number;
+}
+interface FeeBumpTxPackage {
+    tx: string;
+    feeBumpPsbt?: string;
+}
+interface FeeBumpTxChain {
+    leafId: string;
+    txPackages: FeeBumpTxPackage[];
+}
+interface TxChain {
+    leafId: string;
+    transactions: string[];
+}
+interface BroadcastConfig {
+    bitcoinCoreRpcUrl?: string;
+    rpcUsername?: string;
+    rpcPassword?: string;
+    autoBroadcast?: boolean;
+    network?: "MAINNET" | "REGTEST" | "TESTNET" | "SIGNET" | "LOCAL";
+}
+interface BroadcastResult {
+    success: boolean;
+    txids?: string[];
+    error?: string;
+    broadcastedPackages?: number;
+}
+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 constructFeeBumpTx(txHex: string, utxos: Utxo[], feeRate: FeeRate, previousFeeBumpTx?: string): {
+    feeBumpPsbt: string;
+    usedUtxos: Utxo[];
+    correctedParentTx?: string;
+};
+
+export { type BroadcastConfig, type BroadcastResult, DEFAULT_FEE_SATS, type FeeBumpTxChain, type FeeBumpTxPackage, type FeeRate, type LeafInfo, Network, type TxChain, type Utxo, addPrivateKeys, addPublicKeys, applyAdaptorToSignature, applyAdditiveTweakToPublicKey, calculateAvailableTokenAmount, checkIfSelectedOutputsAreAvailable, collectResponses, computeTaprootKeyNoScript, constructFeeBumpTx, constructUnilateralExitFeeBumpPackages, constructUnilateralExitTxs, createRefundTx, createSigningCommitment, createSigningNonce, decodeBytesToSigningCommitment, decodeBytesToSigningNonce, encodeSigningCommitmentToBytes, encodeSigningNonceToBytes, filterTokenBalanceForTokenPublicKey, generateAdaptorFromSignature, generateSignatureFromExistingAdaptor, getCurrentTimelock, getEphemeralAnchorOutput, getLatestDepositTxId, getNextTransactionSequence, getP2TRAddressFromPkScript, getP2TRAddressFromPublicKey, getP2TRScriptFromPublicKey, getP2WPKHAddressFromPublicKey, getRandomSigningNonce, getSigHashFromTx, getSigningCommitmentFromNonce, getTransactionSequence, getTransferPackageSigningPayload, getTxFromRawTxBytes, getTxFromRawTxHex, getTxId, getTxIdNoReverse, isEphemeralAnchorOutput, isTxBroadcast, lastKeyWithTarget, maybeApplyFee, proofOfPossessionMessageHashForDepositAddress, subtractPrivateKeys, subtractPublicKeys, sumOfPrivateKeys, validateOutboundAdaptorSignature };

package/dist/utils/index.js

@@ -1,5 +1,9 @@
 import {
+  DEFAULT_FEE_SATS,
   computeTaprootKeyNoScript,
+  constructFeeBumpTx,
+  constructUnilateralExitFeeBumpPackages,
+  constructUnilateralExitTxs,
   createRefundTx,
   getCurrentTimelock,
   getEphemeralAnchorOutput,
@@ -16,26 +20,29 @@ import {
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  isEphemeralAnchorOutput,
+  isTxBroadcast,
+  maybeApplyFee,
   proofOfPossessionMessageHashForDepositAddress
-} from "../chunk-E5SL7XTO.js";
+} from "../chunk-ED3ZAFDI.js";
+import "../chunk-A74XSEW3.js";
+import "../chunk-S7KD6DDL.js";
 import {
   calculateAvailableTokenAmount,
   checkIfSelectedOutputsAreAvailable,
   collectResponses,
   filterTokenBalanceForTokenPublicKey
 } from "../chunk-57XLH3ZR.js";
-import "../chunk-A74XSEW3.js";
-import "../chunk-S7KD6DDL.js";
 import {
   LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE,
   Network,
   NetworkToProto,
   getNetwork,
-  getNetworkFromAddress
-} from "../chunk-VJTDG4BQ.js";
+  getNetworkFromAddress,
+  getNetworkFromString
+} from "../chunk-HK6LPV6Z.js";
 import "../chunk-ZUVYYR5T.js";
-import "../chunk-HMLOC6TE.js";
 import {
   addPrivateKeys,
   addPublicKeys,
@@ -70,11 +77,13 @@ import {
   splitSecretWithProofs,
   validateShare
 } from "../chunk-MGPRLH6Q.js";
+import "../chunk-HMLOC6TE.js";
 import "../chunk-VTUGIIWI.js";
-import "../chunk-C5LTJBI7.js";
 import "../chunk-TWF35O6M.js";
+import "../chunk-C5LTJBI7.js";
 import "../chunk-MVRQ5US7.js";
 export {
+  DEFAULT_FEE_SATS,
   LRC_WALLET_NETWORK,
   LRC_WALLET_NETWORK_TYPE,
   Network,
@@ -89,6 +98,9 @@ export {
   collectResponses,
   computeTaprootKeyNoScript,
   computerLagrangeCoefficients,
+  constructFeeBumpTx,
+  constructUnilateralExitFeeBumpPackages,
+  constructUnilateralExitTxs,
   createRefundTx,
   createSigningCommitment,
   createSigningNonce,
@@ -107,6 +119,7 @@ export {
   getLatestDepositTxId,
   getNetwork,
   getNetworkFromAddress,
+  getNetworkFromString,
   getNextTransactionSequence,
   getP2TRAddressFromPkScript,
   getP2TRAddressFromPublicKey,
@@ -122,7 +135,10 @@ export {
   getTxFromRawTxHex,
   getTxId,
   getTxIdNoReverse,
+  isEphemeralAnchorOutput,
+  isTxBroadcast,
   lastKeyWithTarget,
+  maybeApplyFee,
   modInverse,
   proofOfPossessionMessageHashForDepositAddress,
   recoverSecret,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/spark-sdk",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "author": "",
   "license": "Apache-2.0",
   "main": "./dist/index.js",

package/src/services/deposit.ts

@@ -20,6 +20,10 @@ import {
 import { subtractPublicKeys } from "../utils/keys.js";
 import { getNetwork } from "../utils/network.js";
 import { proofOfPossessionMessageHashForDepositAddress } from "../utils/proof.js";
+import {
+  DEFAULT_FEE_SATS,
+  getEphemeralAnchorOutput,
+} from "../utils/transaction.js";
 import { WalletConfigService } from "./config.js";
 import { ConnectionManager } from "./connection.js";
 
@@ -184,7 +188,7 @@ export class DepositService {
     vout,
   }: CreateTreeRootParams) {
     // Create a root tx
-    const rootTx = new Transaction();
+    const rootTx = new Transaction({ version: 3 });
     const output = depositTx.getOutput(vout);
     if (!output) {
       throw new ValidationError("Invalid deposit transaction output", {
@@ -203,6 +207,13 @@ export class DepositService {
       });
     }
 
+    // Calculate fee and adjust output amount
+    let outputAmount = amount;
+    /*if (outputAmount > DEFAULT_FEE_SATS) {
+      outputAmount = outputAmount - BigInt(DEFAULT_FEE_SATS);
+    }*/
+
+    // Create new output with fee-adjusted amount
     rootTx.addInput({
       txid: getTxId(depositTx),
       index: vout,
@@ -210,16 +221,21 @@ export class DepositService {
 
     rootTx.addOutput({
       script,
-      amount,
+      amount: outputAmount,
     });
 
+    rootTx.addOutput(getEphemeralAnchorOutput());
+
     const rootNonceCommitment =
       await this.config.signer.getRandomSigningCommitment();
     const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
 
     // Create a refund tx
-    const refundTx = new Transaction();
+    const refundTx = new Transaction({ version: 3 });
     const sequence = (1 << 30) | INITIAL_TIME_LOCK;
+    /* if (outputAmount > DEFAULT_FEE_SATS) {
+      outputAmount = outputAmount - BigInt(DEFAULT_FEE_SATS);
+    }*/
     refundTx.addInput({
       txid: getTxId(rootTx),
       index: 0,
@@ -237,12 +253,14 @@ export class DepositService {
 
     refundTx.addOutput({
       script: refundPkScript,
-      amount: amount,
+      amount: outputAmount,
     });
 
+    refundTx.addOutput(getEphemeralAnchorOutput());
+
     const refundNonceCommitment =
       await this.config.signer.getRandomSigningCommitment();
-    const refundTxSighash = getSigHashFromTx(refundTx, 0, output);
+    const refundTxSighash = getSigHashFromTx(refundTx, 0, rootTx.getOutput(0));
 
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress(),

package/src/services/token-transactions.ts

@@ -40,7 +40,7 @@ import { SigningOperator } from "./wallet-config.js";
 import { hexToBytes } from "@noble/hashes/utils";
 import { decodeSparkAddress } from "../address/index.js";
 
-const MAX_TOKEN_OUTPUTS = 1000;
+const MAX_TOKEN_OUTPUTS = 500;
 
 export class TokenTransactionService {
   protected readonly config: WalletConfigService;

package/src/services/transfer.ts

@@ -49,6 +49,7 @@ import {
   getEphemeralAnchorOutput,
   getNextTransactionSequence,
   getTransactionSequence,
+  maybeApplyFee,
 } from "../utils/transaction.js";
 import { getTransferPackageSigningPayload } from "../utils/transfer_package.js";
 import { WalletConfigService } from "./config.js";
@@ -156,6 +157,42 @@ export class BaseTransferService {
     return updatedTransfer;
   }
 
+  async deliverTransferPackage(
+    transfer: Transfer,
+    leaves: LeafKeyTweak[],
+    refundSignatureMap: Map<string, Uint8Array>,
+  ): Promise<Transfer> {
+    const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
+      transfer.id,
+      transfer.receiverIdentityPublicKey,
+      leaves,
+      refundSignatureMap,
+    );
+
+    const transferPackage = await this.prepareTransferPackage(
+      transfer.id,
+      keyTweakInputMap,
+      leaves,
+      transfer.receiverIdentityPublicKey,
+    );
+
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    const response = await sparkClient.finalize_transfer_with_transfer_package({
+      transferId: transfer.id,
+      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      transferPackage,
+    });
+
+    if (!response.transfer) {
+      throw new ValidationError("No transfer response from operator");
+    }
+
+    return response.transfer;
+  }
+
   async sendTransferWithKeyTweaks(
     leaves: LeafKeyTweak[],
     receiverIdentityPubkey: Uint8Array,
@@ -1179,10 +1216,27 @@ export class TransferService extends BaseTransferService {
         throw Error("Could not fetch tx input");
       }
 
-      const newTx = new Transaction({ allowUnknownOutputs: true });
-      for (let j = 0; j < nodeTx.outputsLength; j++) {
-        newTx.addOutput(nodeTx.getOutput(j));
+      const newTx = new Transaction({ version: 3, allowUnknownOutputs: true });
+
+      // Apply fee to the main output
+      const originalOutput = nodeTx.getOutput(0);
+      if (!originalOutput) {
+        throw Error("Could not get original output");
+      }
+
+      newTx.addOutput({
+        script: originalOutput.script!,
+        amount: originalOutput.amount!,
+      });
+
+      // Copy any additional outputs (like ephemeral anchors) without fee reduction
+      for (let j = 1; j < nodeTx.outputsLength; j++) {
+        const additionalOutput = nodeTx.getOutput(j);
+        if (additionalOutput) {
+          newTx.addOutput(additionalOutput);
+        }
       }
+
       if (i === 0) {
         const currSequence = input.sequence;
 
@@ -1212,10 +1266,28 @@ export class TransferService extends BaseTransferService {
       throw Error("leaf does not have refund tx");
     }
     const refundTx = getTxFromRawTxBytes(leaf?.refundTx);
-    const newRefundTx = new Transaction({ allowUnknownOutputs: true });
+    const newRefundTx = new Transaction({
+      version: 3,
+      allowUnknownOutputs: true,
+    });
+
+    // Apply fee to the refund output
+    const originalRefundOutput = refundTx.getOutput(0);
+    if (!originalRefundOutput) {
+      throw Error("Could not get original refund output");
+    }
 
-    for (let j = 0; j < refundTx.outputsLength; j++) {
-      newRefundTx.addOutput(refundTx.getOutput(j));
+    newRefundTx.addOutput({
+      script: originalRefundOutput.script!,
+      amount: originalRefundOutput.amount!,
+    });
+
+    // Copy any additional outputs (like ephemeral anchors) without fee reduction
+    for (let j = 1; j < refundTx.outputsLength; j++) {
+      const additionalOutput = refundTx.getOutput(j);
+      if (additionalOutput) {
+        newRefundTx.addOutput(additionalOutput);
+      }
     }
 
     const refundTxInput = refundTx.getInput(0);
@@ -1347,10 +1419,12 @@ export class TransferService extends BaseTransferService {
       refundTxSignature: refundSignature,
     });
 
-    return await sparkClient.finalize_node_signatures({
+    const result = await sparkClient.finalize_node_signatures({
       intent: SignatureIntent.REFRESH,
       nodeSignatures,
     });
+
+    return result;
   }
 
   async extendTimelock(node: TreeNode, signingPubKey: Uint8Array) {
@@ -1365,9 +1439,24 @@ export class TransferService extends BaseTransferService {
 
     const { nextSequence: newNodeSequence } =
       getNextTransactionSequence(refundSequence);
-    const newNodeTx = new Transaction({ allowUnknownOutputs: true });
+    const newNodeTx = new Transaction({
+      version: 3,
+      allowUnknownOutputs: true,
+    });
     newNodeTx.addInput({ ...newNodeOutPoint, sequence: newNodeSequence });
-    newNodeTx.addOutput(nodeTx.getOutput(0));
+
+    // Apply fee to the new node transaction output
+    const originalOutput = nodeTx.getOutput(0);
+    if (!originalOutput) {
+      throw Error("Could not get original node output");
+    }
+
+    // const feeReducedAmount = maybeApplyFee(originalOutput.amount!);
+    newNodeTx.addOutput({
+      script: originalOutput.script!,
+      amount: originalOutput.amount!, // feeReducedAmount,
+    });
+
     newNodeTx.addOutput(getEphemeralAnchorOutput());
 
     const newRefundOutPoint: TransactionInput = {
@@ -1380,16 +1469,22 @@ export class TransferService extends BaseTransferService {
       throw new Error("Amount not found in extendTimelock");
     }
 
+    // Apply fee to the refund transaction as well
+    // const feeReducedRefundAmount = maybeApplyFee(amountSats);
     const newRefundTx = createRefundTx(
       initialSequence(),
       newRefundOutPoint,
-      amountSats,
+      amountSats, // feeReducedRefundAmount,
       signingPubKey,
       this.config.getNetwork(),
     );
 
     const nodeSighash = getSigHashFromTx(newNodeTx, 0, nodeTx.getOutput(0));
-    const refundSighash = getSigHashFromTx(newRefundTx, 0, nodeTx.getOutput(0));
+    const refundSighash = getSigHashFromTx(
+      newRefundTx,
+      0,
+      newNodeTx.getOutput(0),
+    );
 
     const newNodeSigningJob = {
       signingPublicKey: signingPubKey,
@@ -1483,4 +1578,116 @@ export class TransferService extends BaseTransferService {
       ],
     });
   }
+
+  async refreshTimelockRefundTx(node: TreeNode, signingPubKey: Uint8Array) {
+    const nodeTx = getTxFromRawTxBytes(node.nodeTx);
+    const refundTx = getTxFromRawTxBytes(node.refundTx);
+
+    const currSequence = refundTx.getInput(0).sequence || 0;
+    const { nextSequence } = getNextTransactionSequence(currSequence);
+
+    const newRefundTx = new Transaction({
+      version: 3,
+      allowUnknownOutputs: true,
+    });
+
+    // Apply fee to the refund output
+    const originalRefundOutput = refundTx.getOutput(0);
+    if (!originalRefundOutput) {
+      throw Error("Could not get original refund output");
+    }
+
+    newRefundTx.addOutput({
+      script: originalRefundOutput.script!,
+      amount: originalRefundOutput.amount!,
+    });
+
+    // Copy any additional outputs (like ephemeral anchors) without fee reduction
+    for (let j = 1; j < refundTx.outputsLength; j++) {
+      const additionalOutput = refundTx.getOutput(j);
+      if (additionalOutput) {
+        newRefundTx.addOutput(additionalOutput);
+      }
+    }
+
+    const refundTxInput = refundTx.getInput(0);
+    if (!refundTxInput) {
+      throw Error("refund tx doesn't have input");
+    }
+
+    newRefundTx.addInput({
+      ...refundTxInput,
+      sequence: nextSequence,
+    });
+
+    const refundSigningJob = {
+      signingPublicKey: signingPubKey,
+      rawTx: newRefundTx.toBytes(),
+      signingNonceCommitment:
+        await this.config.signer.getRandomSigningCommitment(),
+    };
+
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    const response = await sparkClient.refresh_timelock({
+      leafId: node.id,
+      ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
+      signingJobs: [refundSigningJob],
+    });
+
+    if (response.signingResults.length !== 1) {
+      throw Error(
+        `Expected 1 signing result, got ${response.signingResults.length}`,
+      );
+    }
+
+    const signingResult = response.signingResults[0];
+    if (!signingResult || !refundSigningJob.signingNonceCommitment) {
+      throw Error("Signing result or nonce commitment does not exist");
+    }
+
+    const rawTx = getTxFromRawTxBytes(refundSigningJob.rawTx);
+    const txOut = nodeTx.getOutput(0);
+
+    const rawTxSighash = getSigHashFromTx(rawTx, 0, txOut);
+
+    const userSignature = await this.config.signer.signFrost({
+      message: rawTxSighash,
+      privateAsPubKey: signingPubKey,
+      publicKey: signingPubKey,
+      verifyingKey: signingResult.verifyingKey,
+      selfCommitment: refundSigningJob.signingNonceCommitment,
+      statechainCommitments:
+        signingResult.signingResult?.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array(),
+    });
+
+    const signature = await this.config.signer.aggregateFrost({
+      message: rawTxSighash,
+      statechainSignatures: signingResult.signingResult?.signatureShares,
+      statechainPublicKeys: signingResult.signingResult?.publicKeys,
+      verifyingKey: signingResult.verifyingKey,
+      statechainCommitments:
+        signingResult.signingResult?.signingNonceCommitments,
+      selfCommitment: refundSigningJob.signingNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: userSignature,
+      adaptorPubKey: new Uint8Array(),
+    });
+
+    const result = await sparkClient.finalize_node_signatures({
+      intent: SignatureIntent.REFRESH,
+      nodeSignatures: [
+        {
+          nodeId: node.id,
+          nodeTxSignature: new Uint8Array(),
+          refundTxSignature: signature,
+        },
+      ],
+    });
+
+    return result;
+  }
 }