@buildonspark/spark-sdk 0.0.15 → 0.0.16

package/src/tests/lightning.test.ts

@@ -0,0 +1,307 @@
+import { afterEach, beforeAll, describe, expect, it } from "@jest/globals";
+import { hexToBytes } from "@noble/curves/abstract/utils";
+import { equalBytes, sha256 } from "@scure/btc-signer/utils";
+import { TransferStatus } from "../proto/spark.js";
+import { WalletConfigService } from "../services/config.js";
+import { ConnectionManager } from "../services/connection.js";
+import { LightningService } from "../services/lightning.js";
+import { LeafKeyTweak, TransferService } from "../services/transfer.js";
+import { createNewTree, getTestWalletConfig } from "./test-util.js";
+import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
+import { BitcoinFaucet } from "./utils/test-faucet.js";
+
+async function cleanUp() {
+  const config = getTestWalletConfig();
+
+  const preimage = hexToBytes(
+    "2d059c3ede82a107aa1452c0bea47759be3c5c6e5342be6a310f6c3a907d9f4c",
+  );
+  const paymentHash = sha256(preimage);
+
+  for (const operator of Object.values(config.signingOperators!)) {
+    const client = ConnectionManager.createMockClient(operator!.address);
+    await client.clean_up_preimage_share({
+      paymentHash,
+    });
+    client.close();
+  }
+}
+
+const fakeInvoiceCreator = async () => {
+  return "lnbcrt123450n1pnj6uf4pp5l26hsdxssmr52vd4xmn5xran7puzx34hpr6uevaq7ta0ayzrp8esdqqcqzpgxqyz5vqrzjqtr2vd60g57hu63rdqk87u3clac6jlfhej4kldrrjvfcw3mphcw8sqqqqzp3jlj6zyqqqqqqqqqqqqqq9qsp5w22fd8aqn7sdum7hxdf59ptgk322fkv589ejxjltngvgehlcqcyq9qxpqysgqvykwsxdx64qrj0s5pgcgygmrpj8w25jsjgltwn09yp24l9nvghe3dl3y0ycy70ksrlqmcn42hxn24e0ucuy3g9fjltudvhv4lrhhamgq3stqgp";
+};
+
+describe("LightningService", () => {
+  let userWallet: SparkWalletTesting;
+  let userConfig: WalletConfigService;
+  let lightningService: LightningService;
+  let transferService: TransferService;
+
+  let sspWallet: SparkWalletTesting;
+  let sspConfig: WalletConfigService;
+  let sspLightningService: LightningService;
+  let sspTransferService: TransferService;
+
+  // Skip all tests if running in GitHub Actions
+  const testFn = process.env.GITHUB_ACTIONS ? it.skip : it;
+
+  beforeAll(async () => {
+    const { wallet: wallet1 } = await SparkWalletTesting.create({
+      options: {
+        network: "LOCAL",
+      },
+    });
+
+    userWallet = wallet1;
+
+    userConfig = new WalletConfigService(
+      {
+        network: "LOCAL",
+      },
+      userWallet.getSigner(),
+    );
+    const connectionManager = new ConnectionManager(userConfig);
+    lightningService = new LightningService(userConfig, connectionManager);
+    transferService = new TransferService(userConfig, connectionManager);
+
+    const { wallet: wallet2 } = await SparkWalletTesting.create({
+      options: {
+        network: "LOCAL",
+      },
+    });
+
+    sspWallet = wallet2;
+
+    sspConfig = new WalletConfigService(
+      {
+        network: "LOCAL",
+      },
+      sspWallet.getSigner(),
+    );
+    const sspConnectionManager = new ConnectionManager(sspConfig);
+    sspLightningService = new LightningService(sspConfig, sspConnectionManager);
+    sspTransferService = new TransferService(sspConfig, sspConnectionManager);
+  });
+  afterEach(async () => {
+    await cleanUp();
+  });
+
+  testFn("should create an invoice", async () => {
+    const preimage = hexToBytes(
+      "2d059c3ede82a107aa1452c0bea47759be3c5c6e5342be6a310f6c3a907d9f4c",
+    );
+
+    const invoice = await lightningService.createLightningInvoiceWithPreImage({
+      invoiceCreator: fakeInvoiceCreator,
+      amountSats: 100,
+      memo: "test",
+      preimage,
+    });
+
+    expect(invoice).toBeDefined();
+  });
+
+  testFn(
+    "test receive lightning payment",
+    async () => {
+      const faucet = new BitcoinFaucet(
+        "http://127.0.0.1:18443",
+        "admin1",
+        "123",
+      );
+
+      const preimage = hexToBytes(
+        "2d059c3ede82a107aa1452c0bea47759be3c5c6e5342be6a310f6c3a907d9f4c",
+      );
+      const paymentHash = sha256(preimage);
+
+      const invoice = await lightningService.createLightningInvoiceWithPreImage(
+        {
+          invoiceCreator: fakeInvoiceCreator,
+          amountSats: 100,
+          memo: "test",
+          preimage,
+        },
+      );
+
+      expect(invoice).toBeDefined();
+
+      const sspLeafPubKey = await sspWallet.getSigner().generatePublicKey();
+      const nodeToSend = await createNewTree(
+        sspWallet,
+        sspLeafPubKey,
+        faucet,
+        12345n,
+      );
+
+      const newLeafPubKey = await sspWallet
+        .getSigner()
+        .generatePublicKey(sha256("1"));
+
+      const leaves: LeafKeyTweak[] = [
+        {
+          leaf: nodeToSend,
+          signingPubKey: sspLeafPubKey,
+          newSigningPubKey: newLeafPubKey,
+        },
+      ];
+
+      const response = await sspLightningService.swapNodesForPreimage({
+        leaves,
+        receiverIdentityPubkey: await userConfig.signer.getIdentityPublicKey(),
+        paymentHash,
+        isInboundPayment: true,
+      });
+
+      expect(equalBytes(response.preimage, preimage)).toBe(true);
+
+      const senderTransfer = response.transfer;
+
+      expect(senderTransfer).toBeDefined();
+
+      const transfer = await sspTransferService.sendTransferTweakKey(
+        senderTransfer!,
+        leaves,
+        new Map(),
+      );
+
+      expect(transfer.status).toEqual(
+        TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAKED,
+      );
+
+      const pendingTransfer = await transferService.queryPendingTransfers();
+
+      expect(pendingTransfer.transfers.length).toBe(1);
+
+      const receiverTransfer = pendingTransfer.transfers[0];
+
+      expect(receiverTransfer!.id).toEqual(senderTransfer!.id);
+
+      const leafPrivKeyMap = await transferService.verifyPendingTransfer(
+        receiverTransfer!,
+      );
+
+      expect(leafPrivKeyMap.size).toBe(1);
+      expect(leafPrivKeyMap.has(nodeToSend.id)).toBe(true);
+      expect(
+        equalBytes(leafPrivKeyMap.get(nodeToSend.id)!, newLeafPubKey),
+      ).toBe(true);
+
+      const finalLeafPubKey = await userWallet.getSigner().generatePublicKey();
+
+      const leaf = receiverTransfer!.leaves[0]!.leaf;
+      expect(leaf).toBeDefined();
+
+      const claimingNode = {
+        leaf: leaf!,
+        signingPubKey: newLeafPubKey,
+        newSigningPubKey: finalLeafPubKey,
+      };
+
+      await transferService.claimTransfer(receiverTransfer!, [claimingNode]);
+    },
+    60000,
+  );
+
+  testFn(
+    "test send lightning payment",
+    async () => {
+      const faucet = new BitcoinFaucet(
+        "http://127.0.0.1:18443",
+        "admin1",
+        "123",
+      );
+
+      const preimage = hexToBytes(
+        "2d059c3ede82a107aa1452c0bea47759be3c5c6e5342be6a310f6c3a907d9f4c",
+      );
+      const paymentHash = sha256(preimage);
+
+      const userLeafPubKey = await userWallet
+        .getSigner()
+        .generatePublicKey(sha256("1"));
+      const nodeToSend = await createNewTree(
+        userWallet,
+        userLeafPubKey,
+        faucet,
+        12345n,
+      );
+
+      const newLeafPubKey = await userWallet
+        .getSigner()
+        .generatePublicKey(sha256("2"));
+
+      const leaves: LeafKeyTweak[] = [
+        {
+          leaf: nodeToSend,
+          signingPubKey: userLeafPubKey,
+          newSigningPubKey: newLeafPubKey,
+        },
+      ];
+
+      const response = await lightningService.swapNodesForPreimage({
+        leaves,
+        receiverIdentityPubkey: await sspConfig.signer.getIdentityPublicKey(),
+        paymentHash,
+        isInboundPayment: false,
+        invoiceString: await fakeInvoiceCreator(),
+      });
+
+      expect(response.transfer).toBeDefined();
+
+      // const refunds = await sspLightningService.queryUserSignedRefunds(
+      //   paymentHash
+      // );
+
+      // let totalValue = 0n;
+      // for (const refund of refunds) {
+      //   const value = sspLightningService.validateUserSignedRefund(refund);
+      //   totalValue += value;
+      // }
+
+      // expect(totalValue).toBe(12345n);
+
+      const transfer = await transferService.sendTransferTweakKey(
+        response.transfer!,
+        leaves,
+        new Map(),
+      );
+
+      expect(transfer.status).toEqual(
+        TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAK_PENDING,
+      );
+
+      const receiverTransfer =
+        await sspLightningService.providePreimage(preimage);
+
+      expect(receiverTransfer.status).toEqual(
+        TransferStatus.TRANSFER_STATUS_SENDER_KEY_TWEAKED,
+      );
+      expect(receiverTransfer.id).toEqual(transfer.id);
+
+      const leafPrivKeyMap =
+        await sspTransferService.verifyPendingTransfer(receiverTransfer);
+
+      expect(leafPrivKeyMap.size).toBe(1);
+      expect(leafPrivKeyMap.has(nodeToSend.id)).toBe(true);
+      expect(
+        equalBytes(leafPrivKeyMap.get(nodeToSend.id)!, newLeafPubKey),
+      ).toBe(true);
+
+      const finalLeafPubKey = await sspWallet
+        .getSigner()
+        .generatePublicKey(sha256("2"));
+
+      expect(receiverTransfer.leaves[0]!.leaf).toBeDefined();
+
+      const claimingNode = {
+        leaf: receiverTransfer.leaves[0]!.leaf!,
+        signingPubKey: newLeafPubKey,
+        newSigningPubKey: finalLeafPubKey,
+      };
+
+      await sspTransferService.claimTransfer(receiverTransfer, [claimingNode]);
+    },
+    60000,
+  );
+});

package/src/tests/secret-sharing.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "@jest/globals";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import {
+  modInverse,
+  recoverSecret,
+  splitSecretWithProofs,
+  validateShare,
+} from "../utils/secret-sharing.js";
+
+describe("Secret Sharing", () => {
+  describe("modInverse", () => {
+    it("should correctly calculate modular multiplicative inverse", () => {
+      // Test cases: [a, m, expected]
+      const testCases: [bigint, bigint, bigint][] = [
+        [3n, 11n, 4n], // 3 * 4 ≡ 1 (mod 11)
+        [10n, 17n, 12n], // 10 * 12 ≡ 1 (mod 17)
+        [7n, 13n, 2n], // 7 * 2 ≡ 1 (mod 13)
+        [-1n, secp256k1.CURVE.n, secp256k1.CURVE.n - 1n],
+      ];
+
+      for (const [a, m, expected] of testCases) {
+        const result = modInverse(a, m);
+        expect(result).toBe(expected);
+
+        // Normalize the result of (a * result) before taking modulo
+        const product = a * result;
+        const normalizedProduct = ((product % m) + m) % m;
+        expect(normalizedProduct).toBe(1n);
+      }
+    });
+
+    it("should throw error when modular inverse doesn't exist", () => {
+      expect(() => modInverse(4n, 8n)).toThrow(
+        "Modular inverse does not exist",
+      );
+      expect(() => modInverse(6n, 9n)).toThrow(
+        "Modular inverse does not exist",
+      );
+    });
+  });
+
+  it("test secret sharing", () => {
+    const fieldModulus = secp256k1.CURVE.n;
+    const secret =
+      56223216183876340914672117764605975762373003965917245943571257601961255596156n;
+    const threshold = 3;
+    const numberOfShares = 5;
+
+    const shares = splitSecretWithProofs(
+      secret,
+      fieldModulus,
+      threshold,
+      numberOfShares,
+    );
+
+    for (const share of shares) {
+      validateShare(share);
+    }
+
+    const recoveredSecret = recoverSecret(shares.slice(0, threshold));
+    expect(recoveredSecret).toBe(secret);
+  });
+});

package/src/tests/swap.test.ts

@@ -0,0 +1,252 @@
+import { describe, expect, it } from "@jest/globals";
+import { equalBytes, hexToBytes } from "@noble/curves/abstract/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { sha256 } from "@scure/btc-signer/utils";
+import { WalletConfigService } from "../services/config.js";
+import { ConnectionManager } from "../services/connection.js";
+import { LeafKeyTweak, TransferService } from "../services/transfer.js";
+import {
+  applyAdaptorToSignature,
+  generateAdaptorFromSignature,
+} from "../utils/adaptor-signature.js";
+import {
+  computeTaprootKeyNoScript,
+  getSigHashFromTx,
+} from "../utils/bitcoin.js";
+import { createNewTree } from "./test-util.js";
+import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
+import { BitcoinFaucet } from "./utils/test-faucet.js";
+
+describe("swap", () => {
+  const testFn = process.env.GITHUB_ACTIONS ? it.skip : it;
+
+  testFn(
+    "test swap",
+    async () => {
+      const faucet = new BitcoinFaucet(
+        "http://127.0.0.1:18443",
+        "admin1",
+        "123",
+      );
+      // Initiate sender
+      const { wallet: senderWallet } = await SparkWalletTesting.create({
+        options: {
+          network: "LOCAL",
+        },
+      });
+      const senderPubkey = await senderWallet.getIdentityPublicKey();
+
+      const senderConfig = new WalletConfigService(
+        {
+          network: "LOCAL",
+        },
+        senderWallet.getSigner(),
+      );
+      const senderConnectionManager = new ConnectionManager(senderConfig);
+      const senderTransferService = new TransferService(
+        senderConfig,
+        senderConnectionManager,
+      );
+
+      // Initiate receiver
+      const { wallet: receiverWallet } = await SparkWalletTesting.create({
+        options: {
+          network: "LOCAL",
+        },
+      });
+      const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+
+      const receiverConfig = new WalletConfigService(
+        {
+          network: "LOCAL",
+        },
+        receiverWallet.getSigner(),
+      );
+      const receiverConnectionManager = new ConnectionManager(receiverConfig);
+      const receiverTransferService = new TransferService(
+        receiverConfig,
+        receiverConnectionManager,
+      );
+
+      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.sendTransferSignRefund(
+        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, adaptorSignature } =
+        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.sendSwapSignRefund(
+        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 Error(`No refund tx for leaf ${nodeId}`);
+        }
+        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.sendTransferTweakKey(
+          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.sendTransferTweakKey(
+        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/test-util.ts

@@ -0,0 +1,92 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { Address, OutScript, Transaction } from "@scure/btc-signer";
+import { TreeNode } from "../proto/spark.js";
+import { WalletConfigService } from "../services/config.js";
+import { ConnectionManager } from "../services/connection.js";
+import { DepositService } from "../services/deposit.js";
+import {
+  ConfigOptions,
+  LOCAL_WALLET_CONFIG,
+} from "../services/wallet-config.js";
+import { getP2TRAddressFromPublicKey } from "../utils/bitcoin.js";
+import { getNetwork, Network } from "../utils/network.js";
+import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
+import { BitcoinFaucet } from "./utils/test-faucet.js";
+
+export function getTestWalletConfig() {
+  const identityPrivateKey = secp256k1.utils.randomPrivateKey();
+  return getTestWalletConfigWithIdentityKey(identityPrivateKey);
+}
+
+export function getTestWalletConfigWithIdentityKey(
+  identityPrivateKey: Uint8Array,
+) {
+  return {
+    ...LOCAL_WALLET_CONFIG,
+    identityPrivateKey,
+  } as ConfigOptions;
+}
+
+export async function createNewTree(
+  wallet: SparkWalletTesting,
+  pubKey: Uint8Array,
+  faucet: BitcoinFaucet,
+  amountSats: bigint = 100_000n,
+): Promise<TreeNode> {
+  const faucetCoin = await faucet.fund();
+
+  const configService = new WalletConfigService(
+    {
+      network: "LOCAL",
+    },
+    wallet.getSigner(),
+  );
+  const connectionManager = new ConnectionManager(configService);
+  const depositService = new DepositService(configService, connectionManager);
+
+  const depositResp = await depositService.generateDepositAddress({
+    signingPubkey: pubKey,
+  });
+
+  if (!depositResp.depositAddress) {
+    throw new Error("deposit address not found");
+  }
+
+  const depositTx = new Transaction();
+  depositTx.addInput(faucetCoin!.outpoint);
+
+  // Add the main output
+  const addr = Address(getNetwork(Network.LOCAL)).decode(
+    depositResp.depositAddress.address,
+  );
+  const script = OutScript.encode(addr);
+  depositTx.addOutput({ script, amount: amountSats });
+
+  const treeResp = await depositService.createTreeRoot({
+    signingPubKey: pubKey,
+    verifyingKey: depositResp.depositAddress.verifyingKey,
+    depositTx,
+    vout: 0,
+  });
+
+  const signedDepositTx = await faucet.signFaucetCoin(
+    depositTx,
+    faucetCoin!.txout,
+    faucetCoin!.key,
+  );
+
+  await faucet.broadcastTx(signedDepositTx.hex);
+
+  // Mine just 1 block instead of waiting for many confirmations
+  const randomKey = secp256k1.utils.randomPrivateKey();
+  const randomPubKey = secp256k1.getPublicKey(randomKey);
+  const randomAddress = getP2TRAddressFromPublicKey(
+    randomPubKey,
+    Network.LOCAL,
+  );
+
+  await faucet.generateToAddress(1, randomAddress);
+
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  return treeResp.nodes[0]!;
+}