@buildonspark/spark-sdk 0.1.38 → 0.1.40

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

@@ -244,4 +244,229 @@ describe("swap", () => {
       leavesToClaim_1,
     );
   }, 30000);
+
+  it("test swap v2", async () => {
+    const faucet = BitcoinFaucet.getInstance();
+    // Initiate sender
+    const { wallet: senderWallet } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+    });
+    const senderPubkey = await senderWallet.getIdentityPublicKey();
+
+    const senderConfig = new WalletConfigService(
+      {
+        network: "LOCAL",
+      },
+      senderWallet.getSigner(),
+    );
+    const senderConnectionManager = new ConnectionManager(senderConfig);
+    const senderSigningService = new SigningService(senderConfig);
+    const senderTransferService = new TransferService(
+      senderConfig,
+      senderConnectionManager,
+      senderSigningService,
+    );
+
+    // Initiate receiver
+    const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
+      options: {
+        network: "LOCAL",
+      },
+    });
+    const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+
+    const receiverConfig = new WalletConfigService(
+      {
+        network: "LOCAL",
+      },
+      receiverWallet.getSigner(),
+    );
+    const receiverConnectionManager = new ConnectionManager(receiverConfig);
+    const receiverSigningService = new SigningService(receiverConfig);
+    const receiverTransferService = new TransferService(
+      receiverConfig,
+      receiverConnectionManager,
+      receiverSigningService,
+    );
+
+    const senderLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const senderRootNode = await createNewTree(
+      senderWallet,
+      senderLeafPubKey,
+      faucet,
+    );
+
+    const receiverLeafPubKey = await receiverWallet
+      .getSigner()
+      .generatePublicKey();
+    const receiverRootNode = await createNewTree(
+      receiverWallet,
+      receiverLeafPubKey,
+      faucet,
+    );
+
+    // Sender initiates transfer
+    const senderNewLeafPubKey = await senderWallet
+      .getSigner()
+      .generatePublicKey(sha256("1"));
+    const senderTransferNode: LeafKeyTweak = {
+      leaf: senderRootNode,
+      signingPubKey: senderLeafPubKey,
+      newSigningPubKey: senderNewLeafPubKey,
+    };
+    const senderLeavesToTransfer = [senderTransferNode];
+
+    // Get signature for refunds (normal flow)
+    const {
+      transfer: senderTransfer,
+      signatureMap: senderRefundSignatureMap,
+      leafDataMap: senderLeafDataMap,
+    } = await senderTransferService.startSwapSignRefund(
+      senderLeavesToTransfer,
+      hexToBytes(receiverPubkey),
+      new Date(Date.now() + 10 * 60 * 1000),
+    );
+
+    expect(senderRefundSignatureMap.size).toBe(1);
+    const senderSignature = senderRefundSignatureMap.get(senderRootNode.id);
+    expect(senderSignature).toBeDefined();
+    expect(senderLeafDataMap.size).toBe(1);
+
+    const { adaptorPrivateKey } = generateAdaptorFromSignature(
+      senderSignature!,
+    );
+    const adaptorPubKey = secp256k1.getPublicKey(adaptorPrivateKey);
+
+    const receiverNewLeafPubKey = await receiverWallet
+      .getSigner()
+      .generatePublicKey(sha256("1"));
+
+    const receiverTransferNode: LeafKeyTweak = {
+      leaf: receiverRootNode,
+      signingPubKey: receiverLeafPubKey,
+      newSigningPubKey: receiverNewLeafPubKey,
+    };
+    const receiverLeavesToTransfer = [receiverTransferNode];
+
+    const {
+      transfer: receiverTransfer,
+      signatureMap: receiverRefundSignatureMap,
+      leafDataMap: receiverLeafDataMap,
+      signingResults: operatorSigningResults,
+    } = await receiverTransferService.counterSwapSignRefund(
+      receiverLeavesToTransfer,
+      hexToBytes(senderPubkey),
+      new Date(Date.now() + 10 * 60 * 1000),
+      adaptorPubKey,
+    );
+
+    const newReceiverRefundSignatureMap = new Map<string, Uint8Array>();
+    for (const [nodeId, signature] of receiverRefundSignatureMap.entries()) {
+      const leafData = receiverLeafDataMap.get(nodeId);
+      if (!leafData?.refundTx) {
+        throw new ValidationError("Refund transaction not found", {
+          field: "refundTx",
+          value: leafData,
+        });
+      }
+      const sighash = getSigHashFromTx(
+        leafData.refundTx,
+        0,
+        leafData.tx.getOutput(leafData.vout),
+      );
+      let verifyingPubkey: Uint8Array | undefined;
+      for (const signingResult of operatorSigningResults) {
+        if (signingResult.leafId === nodeId) {
+          verifyingPubkey = signingResult.verifyingKey;
+        }
+      }
+      expect(verifyingPubkey).toBeDefined();
+      const taprootKey = computeTaprootKeyNoScript(
+        verifyingPubkey!.slice(1, 33),
+      );
+      const adaptorSig = applyAdaptorToSignature(
+        taprootKey.slice(1, 33),
+        sighash,
+        signature,
+        adaptorPrivateKey,
+      );
+      newReceiverRefundSignatureMap.set(nodeId, adaptorSig);
+    }
+    const senderTransferTweakKey =
+      await senderTransferService.deliverTransferPackage(
+        senderTransfer,
+        senderLeavesToTransfer,
+        senderRefundSignatureMap,
+      );
+
+    const pendingTransfer =
+      await receiverTransferService.queryPendingTransfers();
+    expect(pendingTransfer.transfers.length).toBe(1);
+    const receiverPendingTransfer = pendingTransfer.transfers[0];
+    expect(receiverPendingTransfer!.id).toBe(senderTransferTweakKey.id);
+
+    const leafPrivKeyMap = await receiverTransferService.verifyPendingTransfer(
+      receiverPendingTransfer!,
+    );
+
+    expect(leafPrivKeyMap.size).toBe(1);
+    expect(leafPrivKeyMap.get(senderRootNode.id)).toBeDefined();
+    const bytesEqual = equalBytes(
+      leafPrivKeyMap.get(senderRootNode.id)!,
+      senderNewLeafPubKey,
+    );
+    expect(bytesEqual).toBe(true);
+    expect(receiverPendingTransfer!.leaves[0]!.leaf).toBeDefined();
+    const finalLeafPubKey = await receiverWallet
+      .getSigner()
+      .generatePublicKey(sha256("2"));
+    const claimingNode: LeafKeyTweak = {
+      leaf: receiverPendingTransfer!.leaves[0]!.leaf!,
+      signingPubKey: senderNewLeafPubKey,
+      newSigningPubKey: finalLeafPubKey,
+    };
+    const leavesToClaim = [claimingNode];
+    await receiverTransferService.claimTransfer(
+      receiverPendingTransfer!,
+      leavesToClaim,
+    );
+    await receiverTransferService.deliverTransferPackage(
+      receiverTransfer,
+      receiverLeavesToTransfer,
+      newReceiverRefundSignatureMap,
+    );
+
+    const sPendingTransfer =
+      await senderTransferService.queryPendingTransfers();
+    expect(sPendingTransfer.transfers.length).toBe(1);
+    const senderPendingTransfer = sPendingTransfer.transfers[0];
+    expect(senderPendingTransfer!.id).toBe(receiverTransfer.id);
+
+    const senderLeafPrivKeyMap =
+      await senderTransferService.verifyPendingTransfer(senderPendingTransfer!);
+    expect(senderLeafPrivKeyMap.size).toBe(1);
+    expect(senderLeafPrivKeyMap.get(receiverRootNode.id)).toBeDefined();
+    const bytesEqual_1 = equalBytes(
+      senderLeafPrivKeyMap.get(receiverRootNode.id)!,
+      receiverNewLeafPubKey,
+    );
+    expect(bytesEqual_1).toBe(true);
+    expect(senderPendingTransfer!.leaves[0]!.leaf).toBeDefined();
+
+    const finalLeafPubKey_1 = await senderWallet
+      .getSigner()
+      .generatePublicKey(sha256("3"));
+    const claimingNode_1: LeafKeyTweak = {
+      leaf: senderPendingTransfer!.leaves[0]!.leaf!,
+      signingPubKey: receiverNewLeafPubKey,
+      newSigningPubKey: finalLeafPubKey_1,
+    };
+    const leavesToClaim_1 = [claimingNode_1];
+    await senderTransferService.claimTransfer(
+      senderPendingTransfer!,
+      leavesToClaim_1,
+    );
+  }, 30000);
 });

package/src/tests/integration/tree-creation.test.ts

@@ -1,10 +1,14 @@
 // @ts-nocheck
 import { describe, expect, it } from "@jest/globals";
 import { bytesToHex } from "@noble/curves/abstract/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
 import { ValidationError } from "../../errors/types.js";
 import { getTxFromRawTxBytes, getTxId } from "../../utils/bitcoin.js";
 import { Network } from "../../utils/network.js";
+import { DEFAULT_FEE_SATS } from "../../utils/transaction.js";
+import { createNewTreeWithLevels } from "../test-util.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
+import { BitcoinFaucet } from "../utils/test-faucet.js";
 
 describe("Tree Creation", () => {
   it.skip("test tree creation address generation", async () => {
@@ -19,7 +23,7 @@ describe("Tree Creation", () => {
 
     const dummyTx = createDummyTx({
       address: depositResp.depositAddress!.address,
-      amountSats: 65536n,
+      amountSats: 65536n + DEFAULT_FEE_SATS,
     });
 
     const depositTxHex = bytesToHex(dummyTx.tx);

package/src/utils/index.ts

@@ -10,3 +10,4 @@ export * from "./signing.js";
 export * from "./token-transactions.js";
 export * from "./transfer_package.js";
 export * from "./transaction.js";
+export * from "./unilateral-exit.js";

package/src/utils/mempool.ts

@@ -3,7 +3,7 @@ import {
   getElectrsUrl,
 } from "../services/wallet-config.js";
 import { BitcoinNetwork } from "../types/index.js";
-import { getNetworkFromAddress } from "./network.js";
+import { Network, getNetworkFromAddress } from "./network.js";
 
 export async function getLatestDepositTxId(
   address: string,
@@ -42,3 +42,28 @@ export async function getLatestDepositTxId(
   }
   return null;
 }
+
+export async function isTxBroadcast(
+  txid: string,
+  baseUrl: string,
+  network?: any,
+): Promise<boolean> {
+  const headers: Record<string, string> = {};
+
+  if (network === Network.REGTEST) {
+    const auth = btoa(
+      `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`,
+    );
+    headers["Authorization"] = `Basic ${auth}`;
+  }
+  const response = await fetch(`${baseUrl}/tx/${txid}`, {
+    headers,
+  });
+
+  const tx = await response.json();
+  if (tx.error) {
+    return false;
+  }
+
+  return true;
+}

package/src/utils/network.ts

@@ -78,3 +78,18 @@ export function getNetworkFromAddress(address: string) {
   }
   return null;
 }
+
+/**
+ * Utility function to get the network enum value from a string.
+ *
+ * @param {string} network - The Bitcoin network to turn into an enum value
+ * @returns {Network} The enum value matching the string
+ */
+export function getNetworkFromString(network?: string) {
+  const net = (network ?? "REGTEST").toUpperCase();
+  if (net === "MAINNET") return Network.MAINNET;
+  if (net === "TESTNET") return Network.TESTNET;
+  if (net === "SIGNET") return Network.SIGNET;
+  if (net === "LOCAL") return Network.LOCAL;
+  return Network.REGTEST; // default
+}

package/src/utils/transaction.ts

@@ -6,6 +6,22 @@ import { Network } from "./network.js";
 
 const TIME_LOCK_INTERVAL = 100;
 
+// Default fee constants matching Go implementation
+const ESTIMATED_TX_SIZE = 191;
+const DEFAULT_SATS_PER_VBYTE = 5;
+export const DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
+
+/**
+ * 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.
+ */
+export function maybeApplyFee(amount: bigint): bigint {
+  if (amount > BigInt(DEFAULT_FEE_SATS)) {
+    return amount - BigInt(DEFAULT_FEE_SATS);
+  }
+  return amount;
+}
+
 export function createRefundTx(
   sequence: number,
   nodeOutPoint: TransactionInput,
@@ -13,7 +29,10 @@ export function createRefundTx(
   receivingPubkey: Uint8Array,
   network: Network,
 ): Transaction {
-  const newRefundTx = new Transaction({ allowUnknownOutputs: true });
+  const newRefundTx = new Transaction({
+    version: 3,
+    allowUnknownOutputs: true,
+  });
   newRefundTx.addInput({
     ...nodeOutPoint,
     sequence,
@@ -25,6 +44,7 @@ export function createRefundTx(
     script: refundPkScript,
     amount: amountSats,
   });
+
   newRefundTx.addOutput(getEphemeralAnchorOutput());
 
   return newRefundTx;
@@ -55,7 +75,7 @@ export function getNextTransactionSequence(
     };
   }
 
-  if (nextTimelock <= 0) {
+  if (nextTimelock < 0) {
     throw new ValidationError("timelock interval is less than or equal to 0", {
       field: "nextTimelock",
       value: nextTimelock,