@buildonspark/spark-sdk 0.1.40 → 0.1.41

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

@@ -22,6 +22,8 @@ import { createNewTree } from "../../tests/test-util.js";
 import { NetworkType } from "../../utils/network.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
+import { RPCError } from "../../errors/types.js";
+
 describe("Transfer", () => {
   jest.setTimeout(15_000);
   it("test transfer", async () => {
@@ -120,22 +122,8 @@ describe("Transfer", () => {
       claimingNode,
     ]);
 
-    const { wallet: newReceiverWallet } = await SparkWalletTesting.initialize({
-      options: {
-        network: "LOCAL",
-      },
-    });
-    const newReceiverPubkey = await newReceiverWallet.getSparkAddress();
-
-    await receiverWallet.transfer({
-      amountSats: 1000,
-      receiverSparkAddress: newReceiverPubkey,
-    });
-
-    const newPendingTransfer = await newReceiverWallet.queryPendingTransfers();
-
-    expect(newPendingTransfer.transfers.length).toBe(1);
-    await newReceiverWallet.getBalance();
+    const balance = await receiverWallet.getBalance();
+    expect(balance.balance).toBe(1000n);
   }, 30000);
 
   it("test transfer with separate", async () => {
@@ -589,25 +577,11 @@ describe("Transfer", () => {
       options,
     });
 
-    const senderConfigService = new WalletConfigService(
-      options,
-      senderWallet.getSigner(),
-    );
-    const senderConnectionManager = new ConnectionManager(senderConfigService);
-    const signingService = new SigningService(senderConfigService);
-    const senderTransferService = new TransferService(
-      senderConfigService,
-      senderConnectionManager,
-      signingService,
-    );
+    const depositAddress = await senderWallet.getSingleUseDepositAddress();
 
-    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-    const rootNode = await createNewTree(
-      senderWallet,
-      leafPubKey,
-      faucet,
-      1000n,
-    );
+    const signedTx = await faucet.sendToAddress(depositAddress, 1_000n);
+
+    await senderWallet.claimDeposit(signedTx.id);
 
     const { wallet: receiverWallet } = await SparkWalletTesting.initialize(
       {
@@ -620,20 +594,10 @@ describe("Transfer", () => {
       await senderWallet.getSparkAddress(),
     );
 
-    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
-
-    const transferNode: LeafKeyTweak = {
-      leaf: rootNode,
-      signingPubKey: leafPubKey,
-      newSigningPubKey: newLeafPubKey,
-    };
-
-    const leavesToTransfer = [transferNode];
-
-    const transfer = await senderTransferService.sendTransfer(
-      leavesToTransfer,
-      hexToBytes(await receiverWallet.getIdentityPublicKey()),
-    );
+    const transfer = await senderWallet.transfer({
+      amountSats: 1000,
+      receiverSparkAddress: await receiverWallet.getSparkAddress(),
+    });
 
     async function waitForTransferClaim(
       transferId: string,
@@ -761,201 +725,209 @@ describe("Transfer", () => {
     //   },
     // );
   });
+});
 
-  describe("transfer v2", () => {
-    jest.setTimeout(15_000);
-    it("test transfer with pretweaked package", async () => {
-      const faucet = BitcoinFaucet.getInstance();
+describe("transfer v2", () => {
+  jest.setTimeout(15_000);
+  it("test transfer with pretweaked package", async () => {
+    const faucet = BitcoinFaucet.getInstance();
 
-      const options: ConfigOptions = {
-        network: "LOCAL",
-      };
+    const options: ConfigOptions = {
+      network: "LOCAL",
+    };
 
-      const { wallet: senderWallet } = await SparkWalletTesting.initialize({
-        options,
-      });
+    const { wallet: senderWallet } = await SparkWalletTesting.initialize({
+      options,
+    });
 
-      const senderConfigService = new WalletConfigService(
-        options,
-        senderWallet.getSigner(),
-      );
-      const senderConnectionManager = new ConnectionManager(
-        senderConfigService,
-      );
-      const signingService = new SigningService(senderConfigService);
-      const senderTransferService = new TransferService(
-        senderConfigService,
-        senderConnectionManager,
-        signingService,
-      );
+    const senderConfigService = new WalletConfigService(
+      options,
+      senderWallet.getSigner(),
+    );
+    const senderConnectionManager = new ConnectionManager(senderConfigService);
+    const signingService = new SigningService(senderConfigService);
+    const senderTransferService = new TransferService(
+      senderConfigService,
+      senderConnectionManager,
+      signingService,
+    );
 
-      const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-      const rootNode = await createNewTree(
-        senderWallet,
-        leafPubKey,
-        faucet,
-        1000n,
-      );
+    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const rootNode = await createNewTree(
+      senderWallet,
+      leafPubKey,
+      faucet,
+      1000n,
+    );
 
-      const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
 
-      const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
-        options,
-      });
-      const receiverPubkey = await receiverWallet.getIdentityPublicKey();
+    const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
+      options,
+    });
+    const receiverPubkey = await receiverWallet.getIdentityPublicKey();
 
-      const receiverConfigService = new WalletConfigService(
-        options,
-        receiverWallet.getSigner(),
-      );
-      const receiverConnectionManager = new ConnectionManager(
-        receiverConfigService,
-      );
-      const receiverSigningService = new SigningService(receiverConfigService);
+    const receiverConfigService = new WalletConfigService(
+      options,
+      receiverWallet.getSigner(),
+    );
+    const receiverConnectionManager = new ConnectionManager(
+      receiverConfigService,
+    );
+    const receiverSigningService = new SigningService(receiverConfigService);
 
-      const receiverTransferService = new TransferService(
-        receiverConfigService,
-        receiverConnectionManager,
-        receiverSigningService,
-      );
+    const receiverTransferService = new TransferService(
+      receiverConfigService,
+      receiverConnectionManager,
+      receiverSigningService,
+    );
 
-      const transferNode = {
-        leaf: rootNode,
-        signingPubKey: leafPubKey,
-        newSigningPubKey: newLeafPubKey,
-      };
+    const transferNode = {
+      leaf: rootNode,
+      signingPubKey: leafPubKey,
+      newSigningPubKey: newLeafPubKey,
+    };
 
-      const senderTransfer =
-        await senderTransferService.sendTransferWithKeyTweaks(
-          [transferNode],
-          hexToBytes(receiverPubkey),
-        );
+    const senderTransfer =
+      await senderTransferService.sendTransferWithKeyTweaks(
+        [transferNode],
+        hexToBytes(receiverPubkey),
+      );
 
-      const pendingTransfer = await receiverWallet.queryPendingTransfers();
+    const pendingTransfer = await receiverWallet.queryPendingTransfers();
 
-      expect(pendingTransfer.transfers.length).toBe(1);
+    expect(pendingTransfer.transfers.length).toBe(1);
 
-      const receiverTransfer = pendingTransfer.transfers[0];
+    const receiverTransfer = pendingTransfer.transfers[0];
 
-      expect(receiverTransfer!.id).toBe(senderTransfer.id);
-      expect(receiverTransfer!.expiryTime?.getTime() ?? 0).toBeLessThan(
-        Date.now(),
-      );
+    expect(receiverTransfer!.id).toBe(senderTransfer.id);
+    expect(receiverTransfer!.expiryTime?.getTime() ?? 0).toBeLessThan(
+      Date.now(),
+    );
 
-      const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
-        receiverTransfer!,
-      );
+    const leafPrivKeyMap = await receiverWallet.verifyPendingTransfer(
+      receiverTransfer!,
+    );
 
-      expect(leafPrivKeyMap.size).toBe(1);
+    expect(leafPrivKeyMap.size).toBe(1);
 
-      const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
-      expect(leafPrivKeyMapBytes).toBeDefined();
-      expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
+    const leafPrivKeyMapBytes = leafPrivKeyMap.get(rootNode.id);
+    expect(leafPrivKeyMapBytes).toBeDefined();
+    expect(bytesToHex(leafPrivKeyMapBytes!)).toBe(bytesToHex(newLeafPubKey));
 
-      const finalLeafPubKey = await receiverWallet
-        .getSigner()
-        .generatePublicKey(sha256(rootNode.id));
+    const finalLeafPubKey = await receiverWallet
+      .getSigner()
+      .generatePublicKey(sha256(rootNode.id));
 
-      const claimingNode = {
-        leaf: rootNode,
-        signingPubKey: newLeafPubKey,
-        newSigningPubKey: finalLeafPubKey,
-      };
+    const claimingNode = {
+      leaf: rootNode,
+      signingPubKey: newLeafPubKey,
+      newSigningPubKey: finalLeafPubKey,
+    };
 
-      await receiverTransferService.claimTransfer(receiverTransfer!, [
-        claimingNode,
-      ]);
+    await receiverTransferService.claimTransfer(receiverTransfer!, [
+      claimingNode,
+    ]);
 
-      const { wallet: newReceiverWallet } = await SparkWalletTesting.initialize(
-        {
-          options: {
-            network: "LOCAL",
-          },
-        },
+    const balance = await receiverWallet.getBalance();
+    expect(balance.balance).toBe(1000n);
+  }, 30000);
+
+  it("test self transfer with pretweaked package", async () => {
+    const faucet = BitcoinFaucet.getInstance();
+    const options: ConfigOptions = {
+      network: "LOCAL",
+    };
+    const { wallet: senderWallet } = await SparkWalletTesting.initialize({
+      options,
+    });
+    const senderConfigService = new WalletConfigService(
+      options,
+      senderWallet.getSigner(),
+    );
+    const senderConnectionManager = new ConnectionManager(senderConfigService);
+    const senderSigningService = new SigningService(senderConfigService);
+    const senderTransferService = new TransferService(
+      senderConfigService,
+      senderConnectionManager,
+      senderSigningService,
+    );
+    const leafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const rootNode = await createNewTree(
+      senderWallet,
+      leafPubKey,
+      faucet,
+      1000n,
+    );
+    const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
+    const receiverPubkey = await senderWallet.getIdentityPublicKey();
+    const transferNode = {
+      leaf: rootNode,
+      signingPubKey: leafPubKey,
+      newSigningPubKey: newLeafPubKey,
+    };
+    const senderTransfer =
+      await senderTransferService.sendTransferWithKeyTweaks(
+        [transferNode],
+        hexToBytes(receiverPubkey),
       );
-      const newReceiverPubkey = await newReceiverWallet.getSparkAddress();
+    const receiverTransfer = await senderTransferService.queryTransfer(
+      senderTransfer.id,
+    );
+    expect(receiverTransfer!.id).toBe(senderTransfer.id);
+    expect(receiverTransfer!.expiryTime?.getTime() ?? 0).toBeLessThan(
+      Date.now(),
+    );
 
-      await receiverWallet.transfer({
-        amountSats: 1000,
-        receiverSparkAddress: newReceiverPubkey,
-      });
+    const finalLeafPubKey = await senderWallet
+      .getSigner()
+      .generatePublicKey(sha256(rootNode.id));
+    const claimingNode = {
+      leaf: rootNode,
+      signingPubKey: newLeafPubKey,
+      newSigningPubKey: finalLeafPubKey,
+    };
+    await senderTransferService.claimTransfer(receiverTransfer!, [
+      claimingNode,
+    ]);
 
-      const newPendingTransfer =
-        await newReceiverWallet.queryPendingTransfers();
+    const balance = await senderWallet.getBalance();
+    expect(balance.balance).toBe(1000n);
+  }, 30000);
 
-      expect(newPendingTransfer.transfers.length).toBe(1);
-      await newReceiverWallet.getBalance();
-    }, 30000);
+  it("test transfer with wallet", async () => {
+    const faucet = BitcoinFaucet.getInstance();
 
-    it("test self transfer with pretweaked package", async () => {
-      const faucet = BitcoinFaucet.getInstance();
-      const options: ConfigOptions = {
+    const { wallet: sdk } = await SparkWalletTesting.initialize({
+      options: {
         network: "LOCAL",
-      };
-      const { wallet: senderWallet } = await SparkWalletTesting.initialize({
-        options,
-      });
-      const senderConfigService = new WalletConfigService(
-        options,
-        senderWallet.getSigner(),
-      );
-      const senderConnectionManager = new ConnectionManager(
-        senderConfigService,
-      );
-      const senderSigningService = new SigningService(senderConfigService);
-      const senderTransferService = new TransferService(
-        senderConfigService,
-        senderConnectionManager,
-        senderSigningService,
-      );
-      const leafPubKey = await senderWallet.getSigner().generatePublicKey();
-      const rootNode = await createNewTree(
-        senderWallet,
-        leafPubKey,
-        faucet,
-        1000n,
-      );
-      const newLeafPubKey = await senderWallet.getSigner().generatePublicKey();
-      const receiverPubkey = await senderWallet.getIdentityPublicKey();
-      const transferNode = {
-        leaf: rootNode,
-        signingPubKey: leafPubKey,
-        newSigningPubKey: newLeafPubKey,
-      };
-      const senderTransfer =
-        await senderTransferService.sendTransferWithKeyTweaks(
-          [transferNode],
-          hexToBytes(receiverPubkey),
-        );
-      const receiverTransfer = await senderTransferService.queryTransfer(
-        senderTransfer.id,
-      );
-      expect(receiverTransfer!.id).toBe(senderTransfer.id);
-      expect(receiverTransfer!.expiryTime?.getTime() ?? 0).toBeLessThan(
-        Date.now(),
-      );
+      },
+    });
 
-      const finalLeafPubKey = await senderWallet
-        .getSigner()
-        .generatePublicKey(sha256(rootNode.id));
-      const claimingNode = {
-        leaf: rootNode,
-        signingPubKey: newLeafPubKey,
-        newSigningPubKey: finalLeafPubKey,
-      };
-      await senderTransferService.claimTransfer(receiverTransfer!, [
-        claimingNode,
-      ]);
-
-      // Test self transfer with wallet v2 flow
-      const selfPubKey = await senderWallet.getSparkAddress();
-      await senderWallet.transfer({
-        amountSats: 1000,
-        receiverSparkAddress: selfPubKey,
+    const depositResp = await sdk.getSingleUseDepositAddress();
+    if (!depositResp) {
+      throw new RPCError("Deposit address not found", {
+        method: "getDepositAddress",
       });
-      const newPendingTransfer = await senderWallet.queryPendingTransfers();
-      expect(newPendingTransfer.transfers.length).toBe(0);
-      await senderWallet.getBalance();
-    }, 30000);
+    }
+
+    const signedTx = await faucet.sendToAddress(depositResp, 1_000n);
+
+    await sdk.claimDeposit(signedTx.id);
+
+    const balance = await sdk.getBalance();
+    expect(balance.balance).toBe(1_000n);
+
+    const sparkAddress = await sdk.getSparkAddress();
+
+    await sdk.transfer({
+      amountSats: 1000,
+      receiverSparkAddress: sparkAddress,
+    });
+
+    const newPendingTransfer = await sdk.queryPendingTransfers();
+    expect(newPendingTransfer.transfers.length).toBe(0);
+    const newBalance = await sdk.getBalance();
+    expect(newBalance.balance).toBe(1000n);
   });
 });

package/src/tests/signer.test.ts

@@ -0,0 +1,34 @@
+import { HDKey } from "@scure/bip32";
+import { TaprootOutputKeysGenerator } from "../signer/signer.js";
+import * as btc from "@scure/btc-signer";
+
+describe("signer", () => {
+  let randomSeed = new Uint8Array(32);
+
+  beforeAll(() => {
+    crypto.getRandomValues(randomSeed);
+  });
+
+  it.each([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])(
+    "TaprootOutputKeysGenerator account %d",
+    async (accountNumber) => {
+      const masterSeed = HDKey.fromMasterSeed(randomSeed);
+      const taprootOutputKeys =
+        await new TaprootOutputKeysGenerator().deriveKeysFromSeed(
+          randomSeed,
+          accountNumber,
+        );
+
+      const taprootInternalKey = masterSeed.derive(
+        `m/86'/0'/${accountNumber}'/0/0`,
+      )!;
+      const xOnlyPublicKey = taprootInternalKey.publicKey!.slice(-32);
+      expect(
+        Buffer.from(taprootOutputKeys.identityKey.publicKey).toString("hex"),
+      ).toBe(
+        "02" +
+          Buffer.from(btc.p2tr(xOnlyPublicKey).tweakedPubkey).toString("hex"),
+      );
+    },
+  );
+});

package/src/tests/transaction.test.ts

@@ -0,0 +1,12 @@
+import { checkIfValidSequence } from "../utils/transaction.js";
+
+describe("checkIfValidSequence", () => {
+  it("should throw an error if the sequence is not valid", () => {
+    const noTimelockSequence = (1 << 31) | 1000;
+    expect(() => checkIfValidSequence(noTimelockSequence)).toThrow();
+    const secondstimelockSequence = (1 << 22) | 1000;
+    expect(() => checkIfValidSequence(secondstimelockSequence)).toThrow();
+    const sequence = 1000;
+    expect(() => checkIfValidSequence(sequence)).not.toThrow();
+  });
+});

package/src/tests/xchain-address.test.ts

@@ -0,0 +1,28 @@
+import { getSparkAddressFromTaproot } from "../utils/xchain-address.js";
+
+describe("xchain-address", () => {
+  it.each([
+    [
+      "mainnet",
+      "bc1pvluhspufxmuus9wh3dshxhxfg3656c9mwfw85scaydyp7sk9800sl4h5ae",
+      "sp1pgssyele0qrcjdheeq2a0zmpwdwvj3r4f4stkuju0fp36g6grapv2w7ltce4pm",
+    ],
+    [
+      "testnet",
+      "tb1psw24aa3jkdkndr68gy2gk3ws4hm7dnsccqqtd92fxxqv2jhv5fcqkfyu7v",
+      "spt1pgss9qu4tmmr9vmdx685wsg53dzapt0hum8p3sqqk625jvvqc49wegns9pkyp6",
+    ],
+    [
+      "regtest",
+      "bcrt1p47kh0ff29d3rjw2n43vxqgmrgv9az562x37x6dp4ehyqq7ezyhcqlz5y42",
+      "sprt1pgss9tadw7jj52mz8yu48tzcvq3kxsct69f55drud56rtnwgqpajyf0sp8jkjq",
+    ],
+  ])(
+    "getSparkAddressFromTaproot success (%s)",
+    (_network, taprootAddress, expectedSparkAddress) => {
+      expect(getSparkAddressFromTaproot(taprootAddress)).toBe(
+        expectedSparkAddress,
+      );
+    },
+  );
+});

package/src/utils/index.ts

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

package/src/utils/transaction.ts

@@ -59,6 +59,27 @@ export function getTransactionSequence(currSequence?: number): number {
   return (1 << 30) | timelock;
 }
 
+export function checkIfValidSequence(currSequence?: number) {
+  // Check bit 31 is active. If not equal to 0, timelock is not active.
+  const TIME_LOCK_ACTIVE = (currSequence || 0) & 0x80000000;
+  if (TIME_LOCK_ACTIVE !== 0) {
+    throw new ValidationError("Timelock not active", {
+      field: "currSequence",
+      value: currSequence,
+    });
+  }
+
+  // Check bit 22 is active. If not equal to 0, block based time lock not active.
+  const RELATIVE_TIME_LOCK_ACTIVE = (currSequence || 0) & 0x00400000;
+  if (RELATIVE_TIME_LOCK_ACTIVE !== 0) {
+    throw new ValidationError("Block based timelock not active", {
+      field: "currSequence",
+      value: currSequence,
+    });
+  }
+}
+
+// make sure that the leaves are ok before sending or else next user could lose funds
 export function getNextTransactionSequence(
   currSequence?: number,
   forRefresh?: boolean,
@@ -66,8 +87,15 @@ export function getNextTransactionSequence(
   nextSequence: number;
   needRefresh: boolean;
 } {
+  // Check if the previous sequence is valid. If not, the user could lose funds.
+  checkIfValidSequence(currSequence);
+
   const currentTimelock = getCurrentTimelock(currSequence);
   const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
+
+  // Confirm that the next sequence is valid. This should never happen since bit 17-31 should all be 0.
+  checkIfValidSequence(nextTimelock);
+
   if (forRefresh && nextTimelock <= 100 && currentTimelock > 0) {
     return {
       nextSequence: (1 << 30) | nextTimelock,
@@ -75,8 +103,8 @@ export function getNextTransactionSequence(
     };
   }
 
-  if (nextTimelock < 0) {
-    throw new ValidationError("timelock interval is less than or equal to 0", {
+  if (nextTimelock < 100) {
+    throw new ValidationError("timelock interval is less than 100", {
       field: "nextTimelock",
       value: nextTimelock,
     });

package/src/utils/xchain-address.ts

@@ -0,0 +1,36 @@
+import { encodeSparkAddress, SparkAddressFormat } from "../address/address.js";
+import * as btc from "@scure/btc-signer";
+import { ValidationError } from "../errors/index.js";
+
+const networkByType = {
+  MAINNET: btc.NETWORK,
+  TESTNET: btc.TEST_NETWORK,
+  REGTEST: {
+    ...btc.TEST_NETWORK,
+    bech32: "bcrt",
+  },
+} as const;
+
+export function getSparkAddressFromTaproot(
+  taprootAddress: string,
+): SparkAddressFormat {
+  for (const networkType of ["MAINNET", "TESTNET", "REGTEST"] as const) {
+    try {
+      const result = btc
+        .Address(networkByType[networkType])
+        .decode(taprootAddress);
+      if (result.type === "tr") {
+        const outputPublicKey = result.pubkey;
+        return encodeSparkAddress({
+          identityPublicKey: Buffer.concat([
+            Buffer.from([0x02]),
+            outputPublicKey,
+          ]).toString("hex"),
+          network: networkType,
+        });
+      }
+    } catch (_) {}
+  }
+
+  throw new ValidationError("Invalid taproot address");
+}

package/android/build/.transforms/040d8fa2b9716b9d83b2ee652456153b/results.bin

@@ -1 +0,0 @@
-o/classes

package/android/build/.transforms/2d0f5d3b1e10a4215d771884270da0bd/results.bin

@@ -1 +0,0 @@
-o/classes

package/android/build/.transforms/54700a025e43a95050ec1055d0701a4f/results.bin

@@ -1 +0,0 @@
-o/bundleLibRuntimeToDirDebug