@buildonspark/spark-sdk 0.3.9 → 0.4.0

package/src/tests/integration/lightning.test.ts

@@ -443,20 +443,6 @@ describe.each(walletTypes)(
       for (const leaf of transfer.leaves) {
         const cpfpRefund = getTxFromRawTxBytes(leaf.intermediateRefundTx);
         expectedValue += cpfpRefund.getOutput(0)?.amount || 0n;
-
-        if ((leaf.intermediateDirectRefundTx.length || 0) > 0) {
-          const directRefund = getTxFromRawTxBytes(
-            leaf.intermediateDirectRefundTx,
-          );
-          expectedValue += directRefund.getOutput(0)?.amount || 0n;
-        }
-
-        if ((leaf.intermediateDirectFromCpfpRefundTx.length || 0) > 0) {
-          const directFromCpfpRefund = getTxFromRawTxBytes(
-            leaf.intermediateDirectFromCpfpRefundTx,
-          );
-          expectedValue += directFromCpfpRefund.getOutput(0)?.amount || 0n;
-        }
       }
 
       let totalValue = 0n;
@@ -569,20 +555,6 @@ describe.each(walletTypes)(
       for (const leaf of transfer!.leaves) {
         const cpfpRefund = getTxFromRawTxBytes(leaf.intermediateRefundTx);
         expectedValue += cpfpRefund.getOutput(0)?.amount || 0n;
-
-        if (leaf.intermediateDirectRefundTx.length > 0) {
-          const directRefund = getTxFromRawTxBytes(
-            leaf.intermediateDirectRefundTx,
-          );
-          expectedValue += directRefund.getOutput(0)?.amount || 0n;
-        }
-
-        if (leaf.intermediateDirectFromCpfpRefundTx.length > 0) {
-          const directFromCpfpRefund = getTxFromRawTxBytes(
-            leaf.intermediateDirectFromCpfpRefundTx,
-          );
-          expectedValue += directFromCpfpRefund.getOutput(0)?.amount || 0n;
-        }
       }
 
       let totalValue = 0n;

package/src/tests/integration/static_deposit.test.ts

@@ -17,7 +17,7 @@ describe("SSP static deposit address integration", () => {
       } = await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
       // Wait for the transaction to be mined
-      await faucet.mineBlocks(6);
+      await faucet.mineBlocksAndWaitForMiningToComplete(6);
 
       const transactionId = signedTx.id;
 
@@ -30,11 +30,9 @@ describe("SSP static deposit address integration", () => {
         fee: 301,
       });
 
-      await new Promise((resolve) => setTimeout(resolve, 10000));
-
       await faucet.broadcastTx(txHex);
 
-      await faucet.mineBlocks(6);
+      await faucet.mineBlocksAndWaitForMiningToComplete(6);
 
       // Second refund attempt should fail
       console.log(
@@ -60,7 +58,7 @@ describe("SSP static deposit address integration", () => {
       } = await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
       // Wait for the transaction to be mined
-      await faucet.mineBlocks(6);
+      await faucet.mineBlocksAndWaitForMiningToComplete(6);
 
       const transactionId = signedTx.id;
 
@@ -74,8 +72,6 @@ describe("SSP static deposit address integration", () => {
           }),
       );
 
-      await faucet.mineBlocks(6);
-
       expect(txId).toBeDefined();
     }, 600000);
 
@@ -91,7 +87,7 @@ describe("SSP static deposit address integration", () => {
       } = await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
       // Wait for the transaction to be mined
-      await faucet.mineBlocks(6);
+      await faucet.mineBlocksAndWaitForMiningToComplete(6);
 
       const transactionId = signedTx.id;
 

package/src/tests/integration/unilateral-exit.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from "@jest/globals";
+import { bytesToHex } from "@noble/hashes/utils";
+
+import { RPCError } from "../../errors/types.js";
+import { Network } from "../../utils/network.js";
+import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
+import { BitcoinFaucet } from "../utils/test-faucet.js";
+import { waitForClaim } from "../utils/utils.js";
+import {
+  constructUnilateralExitFeeBumpPackages,
+  hash160,
+} from "../../utils/unilateral-exit.js";
+import { signPsbtWithExternalKey } from "../utils/signing.js";
+import { TreeNode } from "../../proto/spark.js";
+import { WalletConfigService } from "../../services/config.js";
+import { ConnectionManagerNodeJS } from "../../services/connection/connection.node.js";
+
+describe("unilateral exit", () => {
+  it("should unilateral exit", async () => {
+    const faucet = BitcoinFaucet.getInstance();
+
+    const { wallet: userWallet } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+    });
+
+    const depositResp = await userWallet.getSingleUseDepositAddress();
+
+    if (!depositResp) {
+      throw new RPCError("Deposit address not found", {
+        method: "getDepositAddress",
+      });
+    }
+
+    const signedTx = await faucet.sendToAddress(depositResp, 100_000n);
+
+    await faucet.mineBlocks(6);
+
+    await userWallet.claimDeposit(signedTx.id);
+
+    await waitForClaim({ wallet: userWallet });
+
+    const leaves = await userWallet.getLeaves();
+    expect(leaves.length).toBe(1);
+
+    const leaf = leaves[0]!;
+
+    const encodedLeaf = TreeNode.encode(leaf).finish();
+    const hexString = bytesToHex(encodedLeaf);
+
+    const {
+      address: fundingWalletAddress,
+      key: fundingWalletKey,
+      pubKey: fundingWalletPubKey,
+    } = await faucet.getNewExternalWallet();
+
+    const fundingTx = await faucet.sendToAddress(fundingWalletAddress, 50_000n);
+
+    await faucet.mineBlocks(6);
+
+    const pubKeyHash = hash160(fundingWalletPubKey);
+    const p2wpkhScript = new Uint8Array([0x00, 0x14, ...pubKeyHash]);
+
+    const utxos = [
+      {
+        txid: fundingTx.id,
+        vout: 0,
+        value: 50_000n,
+        script: bytesToHex(p2wpkhScript),
+        publicKey: bytesToHex(fundingWalletPubKey),
+      },
+    ];
+
+    // Create a spark client to be used for signing fee bump transactions.
+    const configService = new WalletConfigService(
+      { network: "LOCAL" },
+      userWallet.getSigner(),
+    );
+    const connectionManager = new ConnectionManagerNodeJS(configService);
+    const sparkClient = await connectionManager.createSparkClient(
+      configService.getCoordinatorAddress(),
+    );
+
+    const constructedTx = await constructUnilateralExitFeeBumpPackages(
+      [hexString],
+      utxos,
+      { satPerVbyte: 5 },
+      "http://mempool.minikube.local/api",
+      sparkClient,
+      Network.LOCAL,
+    );
+
+    const txPackages = constructedTx[0]?.txPackages;
+
+    // Broadcast unilateral exit transactions in order
+    txPackages?.forEach(async (txPackage) => {
+      const startBlock = await faucet.getBlockCount();
+      const feeBumpPsbtSigned = await signPsbtWithExternalKey(
+        txPackage.feeBumpPsbt!,
+        bytesToHex(fundingWalletKey),
+      );
+      await faucet.submitPackage([txPackage.tx, feeBumpPsbtSigned]);
+
+      // Mine 1910 blocks to expire time lock.
+      await faucet.mineBlocks(1910);
+
+      // Since we do not depend on the chain watcher, we just need to wait for the blocks to be mined.
+      await faucet.waitForBlocksMined({
+        startBlock,
+        expectedIncrease: 1910,
+      });
+    });
+
+    await connectionManager.closeConnections();
+  }, 90000);
+});

package/src/tests/optimize.test.ts

@@ -4,10 +4,12 @@ import {
   swapMinimizingLeaves,
   maximizeUnilateralExit,
   minimizeTransferSwap,
+  optimize,
   Swap,
+  shouldOptimize,
 } from "../utils/optimize.js";
 
-describe("keys", () => {
+describe("optimize", () => {
   it("test greedyLeaves", () => {
     expect(greedyLeaves(0)).toEqual([]);
     expect(greedyLeaves(1)).toEqual([1]);
@@ -42,4 +44,32 @@ describe("keys", () => {
       new Swap([100], [1, 1, 2, 4, 4, 8, 16, 32, 32]),
     ]);
   });
+
+  it("test shouldOptimize for unilateral exit", () => {
+    expect(shouldOptimize([16], 0)).toEqual(false);
+    expect(shouldOptimize([16, 16], 0)).toEqual(false);
+    expect(shouldOptimize([16, 16, 16, 16, 16, 16, 16, 16], 0)).toEqual(true);
+  });
+
+  it("test shouldOptimize for swap minimization", () => {
+    expect(shouldOptimize([2], 1)).toEqual(false);
+    expect(shouldOptimize([64], 1)).toEqual(true);
+  });
+
+  it("test optimize for unilateral exit", () => {
+    expect(optimize([8], 0)).toEqual([]);
+    expect(optimize([16], 0)).toEqual([]);
+    expect(optimize([16, 16, 16, 16, 16, 16, 16, 16], 0)).toEqual([
+      new Swap([16, 16, 16, 16, 16, 16, 16, 16], [128]),
+    ]);
+    expect(optimize([100000], 0)).toEqual([
+      new Swap([100000], [32, 128, 512, 1024, 32768, 65536]),
+    ]);
+  });
+
+  it("test optimize for swap minimization", () => {
+    expect(optimize([8], 1)).toEqual([new Swap([8], [1, 1, 2, 4])]);
+    expect(optimize([1, 4], 1)).toEqual([new Swap([4], [2, 2])]);
+    expect(optimize([1, 16], 1)).toEqual([new Swap([16], [2, 2, 4, 8])]);
+  });
 });

package/src/tests/utils/signing.ts

@@ -0,0 +1,33 @@
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import * as btc from "@scure/btc-signer";
+
+import { isEphemeralAnchorOutput } from "../../utils/unilateral-exit.js";
+
+export async function signPsbtWithExternalKey(
+  psbtHex: string,
+  privateKeyInput: string,
+): Promise<string> {
+  const tx = btc.Transaction.fromPSBT(hexToBytes(psbtHex), {
+    allowUnknown: true,
+    allowLegacyWitnessUtxo: true,
+    version: 3,
+  });
+  const privateKey = hexToBytes(privateKeyInput);
+  for (let i = 0; i < tx.inputsLength; i++) {
+    const input = tx.getInput(i);
+    if (
+      isEphemeralAnchorOutput(
+        input?.witnessUtxo?.script,
+        input?.witnessUtxo?.amount,
+      )
+    ) {
+      continue;
+    }
+    tx.updateInput(i, {
+      witnessScript: input?.witnessUtxo?.script,
+    });
+    tx.signIdx(privateKey, i);
+    tx.finalizeIdx(i);
+  }
+  return bytesToHex(tx.toBytes(true, true));
+}

package/src/tests/utils/test-faucet.ts

@@ -311,6 +311,17 @@ export class BitcoinFaucet {
     return await this.generateToAddress(numBlocks, this.miningAddress);
   }
 
+  async mineBlocksAndWaitForMiningToComplete(numBlocks: number) {
+    const startBlock = await this.getBlockCount();
+
+    await this.mineBlocks(numBlocks);
+
+    await this.waitForBlocksMined({
+      startBlock,
+      expectedIncrease: numBlocks,
+    });
+  }
+
   private async call(method: string, params: any[]) {
     try {
       const { fetch, Headers } = getFetch();
@@ -369,17 +380,67 @@ export class BitcoinFaucet {
     return await this.call("getblock", [blockHash, 2]);
   }
 
+  async getBlockCount(): Promise<number> {
+    return await this.call("getblockcount", []);
+  }
+
+  async waitForBlocksMined({
+    startBlock,
+    expectedIncrease,
+    timeoutMs = 30000,
+    intervalMs = 5000,
+  }: {
+    startBlock: number;
+    expectedIncrease: number;
+    timeoutMs?: number;
+    intervalMs?: number;
+  }) {
+    const deadline = Date.now() + timeoutMs;
+    // Give some time for the blocks to be mined and the chain watcher to catch up.
+    await new Promise((r) => setTimeout(r, intervalMs));
+
+    const start = startBlock;
+    const target = start + expectedIncrease;
+    while (Date.now() < deadline) {
+      const currentBlock = await this.getBlockCount();
+      if (currentBlock >= target) return currentBlock;
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    throw new Error(
+      `Timed out waiting for ${expectedIncrease} blocks (target height ${target})`,
+    );
+  }
+
   async broadcastTx(txHex: string) {
     let response = await this.call("sendrawtransaction", [txHex, 0]);
     return response;
   }
 
+  async submitPackage(txHexs: string[]) {
+    let response = await this.call("submitpackage", [txHexs]);
+    return response;
+  }
+
   async getNewAddress(): Promise<string> {
     const key = secp256k1.utils.randomPrivateKey();
     const pubKey = secp256k1.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, Network.LOCAL);
   }
 
+  async getNewExternalWallet(): Promise<{
+    address: string;
+    key: Uint8Array;
+    pubKey: Uint8Array;
+  }> {
+    const key = secp256k1.utils.randomPrivateKey();
+    const pubKey = secp256k1.getPublicKey(key);
+    return {
+      address: getP2TRAddressFromPublicKey(pubKey, Network.LOCAL),
+      key,
+      pubKey,
+    };
+  }
+
   async sendToAddress(
     address: string,
     amount: bigint,

package/src/utils/optimize.ts

@@ -224,3 +224,45 @@ export function minimizeTransferSwap(
 
   return swaps;
 }
+
+export function shouldOptimize(
+  inputLeaves: number[],
+  multiplicity: number = 1,
+  maxLeavesPerSwap: number = 64,
+): boolean {
+  if (multiplicity == 0) {
+    // When optimizing for unilateral exits, we should only optimize if it reduces the
+    // number of leaves by more than 5x.
+    const swaps = maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap);
+    const numInputs = sum(swaps.map((swap) => swap.inLeaves.length));
+    const numOutputs = sum(swaps.map((swap) => swap.outLeaves.length));
+    return numOutputs * 5 < numInputs;
+  } else {
+    // When optimizing for swap-minimization, we should only optimize if it changes the
+    // number of active denominations by more than 1.
+    const swaps = minimizeTransferSwap(
+      inputLeaves,
+      multiplicity,
+      maxLeavesPerSwap,
+    );
+    const inputCounter = countOccurrences(
+      swaps.flatMap((swap) => swap.inLeaves),
+    );
+    const outputCounter = countOccurrences(
+      swaps.flatMap((swap) => swap.outLeaves),
+    );
+    return Math.abs(inputCounter.size - outputCounter.size) > 1;
+  }
+}
+
+export function optimize(
+  inputLeaves: number[],
+  multiplicity: number = 1,
+  maxLeavesPerSwap: number = 64,
+): Swap[] {
+  if (multiplicity == 0) {
+    return maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap);
+  } else {
+    return minimizeTransferSwap(inputLeaves, multiplicity, maxLeavesPerSwap);
+  }
+}

package/src/utils/unilateral-exit.ts

@@ -60,45 +60,6 @@ export interface BroadcastResult {
   broadcastedPackages?: number;
 }
 
-// Helper function to convert WIF private key to hex
-function wifToHex(wif: string): string {
-  try {
-    // WIF decoding using base58 (simplified version)
-    const base58Alphabet =
-      "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-
-    // Decode base58
-    let decoded = BigInt(0);
-    for (let i = 0; i < wif.length; i++) {
-      const char = wif[i];
-      if (!char) {
-        throw new Error("Invalid character in WIF at position " + i);
-      }
-      const index = base58Alphabet.indexOf(char);
-      if (index === -1) {
-        throw new Error("Invalid character in WIF");
-      }
-      decoded = decoded * BigInt(58) + BigInt(index);
-    }
-
-    // Convert to hex and pad to ensure proper length
-    let hex = decoded.toString(16);
-
-    // WIF format: [version][32-byte private key][compression flag][4-byte checksum]
-    // We want the 32-byte private key part (skip version byte, take 32 bytes)
-    if (hex.length >= 74) {
-      // 1 + 32 + 1 + 4 = 38 bytes = 76 hex chars minimum
-      // Skip version byte (2 hex chars) and take 32 bytes (64 hex chars)
-      const privateKeyHex = hex.substring(2, 66);
-      return privateKeyHex;
-    }
-
-    throw new Error("Invalid WIF length");
-  } catch (error) {
-    throw new Error(`Failed to convert WIF to hex: ${error}`);
-  }
-}
-
 export function isEphemeralAnchorOutput(
   script?: Uint8Array,
   amount?: bigint,
@@ -542,7 +503,7 @@ export async function constructUnilateralExitFeeBumpPackages(
 }
 
 // Helper function to create RIPEMD160(SHA256(data)) hash
-function hash160(data: Uint8Array): Uint8Array {
+export function hash160(data: Uint8Array): Uint8Array {
   // Proper implementation using RIPEMD160(SHA256(data))
   const sha256Hash = sha256(data);
   return ripemd160(sha256Hash);