@buildonspark/spark-sdk 0.2.11 → 0.2.13

package/src/tests/cross-language-hash.test.ts

@@ -0,0 +1,79 @@
+// sdks/js/packages/spark-sdk/src/tests/cross-language-hash.test.ts
+/**
+ * Cross-language hash compatibility test for SparkInvoiceFields.
+ * This test validates that our JavaScript protoreflecthash implementation
+ * produces identical hashes to the Go implementation for the same data.
+ */
+
+import { describe, expect, it } from "@jest/globals";
+import fs from "fs";
+import { SparkInvoiceFields } from "../proto/spark.js";
+import { createProtoHasher } from "../spark-wallet/proto-hash.js";
+import { getFieldNumbers } from "../spark-wallet/proto-reflection.js";
+
+function toHex(bytes: Uint8Array): string {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+describe("Cross-Language Hash Compatibility", () => {
+  const hasher = createProtoHasher();
+
+  // Load canonical protobuf JSON test cases from the repo
+  const candidates = [
+    new URL(
+      "../../../../../../spark/testdata/cross_language_hash_cases_proto.json",
+      import.meta.url,
+    ),
+  ];
+
+  let jsonData: any | null = null;
+  for (const u of candidates) {
+    try {
+      const raw = fs.readFileSync(u, "utf8");
+      jsonData = JSON.parse(raw);
+      break;
+    } catch {
+      // try next
+    }
+  }
+
+  if (!jsonData) {
+    it("skips when proto-JSON dataset is absent", () => {
+      expect(true).toBe(true);
+    });
+    return;
+  }
+
+  const allCases = (jsonData.testCases || []) as any[];
+
+  it("should extract correct field numbers from SparkInvoiceFields", () => {
+    const fieldNumbers = getFieldNumbers("spark.SparkInvoiceFields");
+    expect(fieldNumbers.version).toBe(1);
+    expect(fieldNumbers.id).toBe(2);
+  });
+
+  for (const tc of allCases) {
+    it(`matches expected hash for ${tc.name}`, async () => {
+      const msg = SparkInvoiceFields.fromJSON(tc.sparkInvoiceFields);
+      const hash = await hasher.hashProto(msg, "spark.SparkInvoiceFields");
+      const hex = toHex(hash);
+
+      // Always 32 bytes and deterministic.
+      expect(hash).toHaveLength(32);
+      const hash2 = await hasher.hashProto(msg, "spark.SparkInvoiceFields");
+      expect(hash).toEqual(hash2);
+
+      // Compare against expected hash from JSON
+      expect(hex.toLowerCase()).toBe(String(tc.expectedHash).toLowerCase());
+    });
+  }
+
+  it("errors on nil/undefined messages", async () => {
+    await expect(hasher.hashProto(null as any)).rejects.toThrow(
+      /cannot hash nil/i,
+    );
+    await expect(hasher.hashProto(undefined as any)).rejects.toThrow(
+      /cannot hash nil/i,
+    );
+  });
+});

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

@@ -12,7 +12,7 @@ describe("address", () => {
   ])(
     ".seedOrMnemonic(%s)",
     (seedOrMnemonic) => {
-      test.concurrent.each([["LOCAL", "spl", "bcrt"]])(
+      test.each([["LOCAL", "spl", "bcrt"]])(
         `.network(%s)`,
         async (network, sparkAddressPrefix, blockchainAddressPrefix) => {
           const options: ConfigOptions = {
@@ -32,13 +32,8 @@ describe("address", () => {
           );
           expect(sparkAddress).toEqual(await wallet.getSparkAddress());
 
-          // Make multiple concurrent calls to getSingleUseDepositAddress
           const depositAddresses = await Promise.all([
             wallet.getSingleUseDepositAddress(),
-            wallet.getSingleUseDepositAddress(),
-            wallet.getSingleUseDepositAddress(),
-            wallet.getSingleUseDepositAddress(),
-            wallet.getSingleUseDepositAddress(),
           ]);
 
           // Verify each address is unique and valid
@@ -49,7 +44,7 @@ describe("address", () => {
             );
             addressMap.set(depositAddress, depositAddress);
           }
-          expect(addressMap.size).toBe(5);
+          expect(addressMap.size).toBe(1);
 
           // Create a new wallet with the same seed or mnemonic
           const { wallet: wallet2, ...rest2 } =
@@ -67,10 +62,6 @@ describe("address", () => {
           // New wallet should continue to generate unique addresses
           const depositAddresses2 = await Promise.all([
             wallet2.getSingleUseDepositAddress(),
-            wallet2.getSingleUseDepositAddress(),
-            wallet2.getSingleUseDepositAddress(),
-            wallet2.getSingleUseDepositAddress(),
-            wallet2.getSingleUseDepositAddress(),
           ]);
 
           // Verify each address is unique and valid
@@ -80,7 +71,7 @@ describe("address", () => {
             );
             addressMap.set(depositAddress, depositAddress);
           }
-          expect(addressMap.size).toBe(10);
+          expect(addressMap.size).toBe(2);
         },
         30000,
       );

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "@jest/globals";
-import { hexToBytes } from "@noble/curves/abstract/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
+import { hexToBytes } from "@noble/curves/utils";
 import { Address, OutScript, Transaction } from "@scure/btc-signer";
 import { TransactionInput } from "@scure/btc-signer/psbt";
 import { equalBytes } from "@scure/btc-signer/utils";

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeAll, describe, expect, it } from "@jest/globals";
-import { hexToBytes } from "@noble/curves/abstract/utils";
+import { hexToBytes } from "@noble/curves/utils";
 import { sha256 } from "@noble/hashes/sha2";
 import { equalBytes } from "@scure/btc-signer/utils";
 import { uuidv7 } from "uuidv7";

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

@@ -5,7 +5,6 @@ import {
 import { bytesToHex } from "@noble/hashes/utils";
 import { BitcoinFaucet } from "../../utils/test-faucet.js";
 
-const SMALL_DEPOSIT_AMOUNT = 10n;
 export const DEPOSIT_AMOUNT = 10000n;
 const SECOND_DEPOSIT_AMOUNT = 20000n;
 const THIRD_DEPOSIT_AMOUNT = 30000n;
@@ -168,6 +167,134 @@ describe("SSP static deposit address integration", () => {
 
       expect(refundTx).not.toBe(refundTx2);
     }, 60000);
+
+    it("should return the right amount of txns when querying for utxos sent to a static deposit address", async () => {
+      const faucet = BitcoinFaucet.getInstance();
+      const { wallet: userWallet } = await SparkWalletTesting.initialize(
+        {
+          options: {
+            network: "LOCAL",
+          },
+        },
+        false,
+      );
+
+      const depositAddress = await userWallet.getStaticDepositAddress();
+      expect(depositAddress).toBeDefined();
+      const signedTx = await faucet.sendToAddress(
+        depositAddress,
+        DEPOSIT_AMOUNT,
+      );
+
+      // Wait for the transaction to be mined
+      await faucet.mineBlocks(6);
+      expect(signedTx).toBeDefined();
+      const transactionId = signedTx.id;
+      let vout;
+      for (let i = 0; i < signedTx.outputsLength; i++) {
+        const output = signedTx.getOutput(i);
+        if (output.amount === DEPOSIT_AMOUNT) {
+          vout = i;
+          break;
+        }
+      }
+
+      const quote = await userWallet.getClaimStaticDepositQuote(
+        transactionId,
+        vout!,
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      const quoteAmount = quote!.creditAmountSats;
+      const sspSignature = quote!.signature;
+
+      await userWallet.claimStaticDeposit({
+        transactionId,
+        creditAmountSats: quoteAmount,
+        sspSignature,
+        outputIndex: vout!,
+      });
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      const { balance } = await userWallet.getBalance();
+      expect(balance).toBe(BigInt(quoteAmount));
+
+      // Test depositing money to the same address and second time and claiming.
+      const signedTx2 = await faucet.sendToAddress(
+        depositAddress,
+        SECOND_DEPOSIT_AMOUNT,
+      );
+      const transactionId2 = signedTx2.id;
+      // Wait for the transaction to be mined
+      await faucet.mineBlocks(6);
+      // Test claiming and getting the quote without passing in the output index.
+      const quote2 =
+        await userWallet.getClaimStaticDepositQuote(transactionId2);
+      const quoteAmount2 = quote2!.creditAmountSats;
+      const sspSignature2 = quote2!.signature;
+      await userWallet.claimStaticDeposit({
+        transactionId: transactionId2,
+        creditAmountSats: quoteAmount2,
+        sspSignature: sspSignature2,
+      });
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      const { balance: balance2 } = await userWallet.getBalance();
+      expect(balance2).toBe(BigInt(quoteAmount + quoteAmount2));
+
+      // Test depositing money to the same address and test claim with max fee flow.
+      const signedTx3 = await faucet.sendToAddress(
+        depositAddress,
+        THIRD_DEPOSIT_AMOUNT,
+      );
+      const transactionId3 = signedTx3.id;
+      // Wait for the transaction to be mined
+      await faucet.mineBlocks(6);
+      // Get quote so we can calculate the expected balance. Not needed for actual flow.
+      const quote3 =
+        await userWallet.getClaimStaticDepositQuote(transactionId3);
+      const quoteAmount3 = quote3!.creditAmountSats;
+      await userWallet.claimStaticDepositWithMaxFee({
+        transactionId: transactionId3,
+        maxFee: 1000,
+      });
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      const { balance: balance3 } = await userWallet.getBalance();
+      expect(balance3).toBe(BigInt(quoteAmount + quoteAmount2 + quoteAmount3));
+      // Get transfers should include static deposit transfers.
+      const transfers = await userWallet.getTransfers();
+      expect(transfers.transfers.length).toBe(3);
+
+      for (let i = 0; i < 98; i++) {
+        await faucet.sendToAddress(depositAddress, THIRD_DEPOSIT_AMOUNT);
+      }
+
+      await faucet.mineBlocks(6);
+
+      let utxosExcludeClaimed: any[] = [];
+      const utxosExcludeClaimedExpected = 98;
+      const maxAttempts = 10;
+      for (let attempt = 1; attempt <= 10; attempt++) {
+        utxosExcludeClaimed = await userWallet.getUtxosForDepositAddress(
+          depositAddress,
+          100,
+          0,
+          true,
+        );
+        if (utxosExcludeClaimed.length === utxosExcludeClaimedExpected) break;
+        if (attempt < maxAttempts)
+          await new Promise((r) => setTimeout(r, 5000));
+      }
+
+      expect(utxosExcludeClaimed.length).toBe(98);
+
+      const utxos = await userWallet.getUtxosForDepositAddress(
+        depositAddress,
+        100,
+        0,
+        false,
+      );
+      expect(utxos.length).toBe(100);
+    }, 60000);
   });
 
   describe("Concurrency testing", () => {

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

@@ -52,6 +52,32 @@ describe("SSP static deposit address integration", () => {
       ).rejects.toThrow();
     }, 600000);
 
+    it("should refund and broadcast a static deposit refund transaction", async () => {
+      const {
+        wallet: userWallet,
+        depositAddress,
+        signedTx,
+        vout,
+        faucet,
+      } = await initWallet(DEPOSIT_AMOUNT, "LOCAL");
+
+      // Wait for the transaction to be mined
+      await faucet.mineBlocks(6);
+
+      const transactionId = signedTx.id;
+
+      const txId = await userWallet.refundAndBroadcastStaticDeposit({
+        depositTransactionId: transactionId,
+        outputIndex: vout!,
+        destinationAddress: depositAddress,
+        satsPerVbyteFee: 2,
+      });
+
+      await faucet.mineBlocks(6);
+
+      expect(txId).toBeDefined();
+    }, 600000);
+
     it("should fail due to low fee", async () => {
       console.log("Initializing wallet for low-fee refund test...");
       const {

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "@jest/globals";
-import { hexToBytes } from "@noble/curves/abstract/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
+import { hexToBytes } from "@noble/curves/utils";
 import { uuidv7 } from "uuidv7";
 import { ValidationError } from "../../errors/types.js";
 import { KeyDerivationType } from "../../index.js";

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

@@ -1,9 +1,5 @@
 import { describe, expect, it, jest } from "@jest/globals";
-import {
-  bytesToHex,
-  equalBytes,
-  hexToBytes,
-} from "@noble/curves/abstract/utils";
+import { bytesToHex, equalBytes, hexToBytes } from "@noble/curves/utils";
 import { generateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
 import { uuidv7 } from "uuidv7";
@@ -309,130 +305,6 @@ describe.each(walletTypes)(
       );
     });
 
-    testLocalOnly(`${name} - cancel transfer`, async () => {
-      const faucet = BitcoinFaucet.getInstance();
-
-      const options: ConfigOptions = {
-        network: "LOCAL",
-      };
-      const { wallet: senderWallet } = await SparkWalletTesting.initialize({
-        options,
-        signer: new Signer(),
-      });
-      const mnemonic = generateMnemonic(wordlist);
-
-      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 receiverTransferService = new TransferService(
-        receiverConfigService,
-        receiverConnectionManager,
-        receiverSigningService,
-      );
-
-      const leafId = uuidv7();
-      const rootNode = await createTree(senderWallet, leafId, faucet, 100_000n);
-
-      const newLeafDerivationPath: KeyDerivation = {
-        type: KeyDerivationType.LEAF,
-        path: uuidv7(),
-      };
-
-      const transferNode: LeafKeyTweak = {
-        leaf: rootNode,
-        keyDerivation: {
-          type: KeyDerivationType.LEAF,
-          path: leafId,
-        },
-        newKeyDerivation: newLeafDerivationPath,
-      };
-
-      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 senderTransfer = await senderTransferService.sendTransferSignRefund(
-        [transferNode],
-        hexToBytes(receiverPubkey),
-        new Date(Date.now() + 10 * 60 * 1000),
-      );
-
-      await senderTransferService.cancelTransfer(
-        senderTransfer.transfer,
-        senderConfigService.getCoordinatorAddress(),
-      );
-
-      const newSenderTransfer =
-        await senderTransferService.sendTransferWithKeyTweaks(
-          [transferNode],
-          hexToBytes(receiverPubkey),
-        );
-
-      const pendingTransfer = await receiverWallet.queryPendingTransfers();
-      expect(pendingTransfer.transfers.length).toBe(1);
-
-      const receiverTransfer = pendingTransfer.transfers[0];
-      expect(receiverTransfer!.id).toBe(newSenderTransfer.id);
-
-      const leafPubKeyMap = await receiverWallet.verifyPendingTransfer(
-        receiverTransfer!,
-      );
-
-      expect(leafPubKeyMap.size).toBe(1);
-
-      const leafPubKeyMapBytes = leafPubKeyMap.get(rootNode.id);
-      expect(leafPubKeyMapBytes).toBeDefined();
-      expect(
-        equalBytes(
-          leafPubKeyMapBytes!,
-          await senderWallet
-            .getSigner()
-            .getPublicKeyFromDerivation(newLeafDerivationPath),
-        ),
-      ).toBe(true);
-
-      const claimingNodes: LeafKeyTweak[] = receiverTransfer!.leaves.map(
-        (leaf) => ({
-          leaf: receiverTransfer!.leaves[0]!.leaf!,
-          keyDerivation: {
-            type: KeyDerivationType.ECIES,
-            path: leaf.secretCipher,
-          },
-          newKeyDerivation: {
-            type: KeyDerivationType.LEAF,
-            path: leaf.leaf!.id,
-          },
-        }),
-      );
-
-      await receiverTransferService.claimTransfer(
-        receiverTransfer!,
-        claimingNodes,
-      );
-    });
-
     testLocalOnly(
       `${name} - test that when the receiver has tweaked the key on some SOs, we can still claim the transfer`,
       async () => {

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

@@ -1,20 +1,20 @@
 import { describe, expect, it } from "@jest/globals";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { bytesToHex } from "@noble/curves/utils";
+import type { Transaction } from "@scure/btc-signer";
 import { ConfigOptions } from "../../services/wallet-config.js";
-import { NetworkType } from "../../utils/network.js";
-import { walletTypes } from "../test-utils.js";
-import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
-import { secp256k1, schnorr } from "@noble/curves/secp256k1";
-import { bytesToHex } from "@noble/curves/abstract/utils";
 import type { SparkSigner } from "../../signer/signer.js";
-import type { Transaction } from "@scure/btc-signer";
 import type {
   AggregateFrostParams,
   KeyDerivation,
-  SigningCommitmentWithOptionalNonce,
   SignFrostParams,
+  SigningCommitmentWithOptionalNonce,
   SplitSecretWithProofsParams,
 } from "../../signer/types.js";
+import { NetworkType } from "../../utils/network.js";
 import type { VerifiableSecretShare } from "../../utils/secret-sharing.js";
+import { walletTypes } from "../test-utils.js";
+import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 
 describe.each(walletTypes)("wallet", ({ name, Signer }) => {
   it(`${name} - should initialize a wallet`, async () => {

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

@@ -1,5 +1,5 @@
 import { describe, expect, it, jest } from "@jest/globals";
-import { bytesToHex, hexToBytes } from "@noble/curves/abstract/utils";
+import { bytesToHex, hexToBytes } from "@noble/curves/utils";
 import { uuidv7 } from "uuidv7";
 import { KeyDerivation, KeyDerivationType } from "../../index.js";
 import { WalletConfigService } from "../../services/config.js";

package/src/tests/token-hashing.test.ts

@@ -1,14 +1,11 @@
-import { numberToBytesBE } from "@noble/curves/abstract/utils";
+import { numberToBytesBE } from "@noble/curves/utils";
+import { sha256 } from "@noble/hashes/sha2";
+import { Network } from "../proto/spark.js";
 import {
   hashTokenTransactionV0,
   hashTokenTransactionV1,
   hashTokenTransactionV2,
 } from "../utils/token-hashing.js";
-import { Network, OutputWithPreviousTransactionData } from "../proto/spark.js";
-import { TokenTransactionService } from "../services/token-transactions.js";
-import { WalletConfigService } from "../services/config.js";
-import { ConnectionManager } from "../services/connection.js";
-import { sha256 } from "@noble/hashes/sha2";
 
 // Test constants for consistent test data across all hash tests
 const TEST_TOKEN_PUBLIC_KEY = new Uint8Array([

package/src/tests/token-outputs.test.ts

@@ -1,9 +1,9 @@
-import { numberToBytesBE } from "@noble/curves/abstract/utils";
+import { numberToBytesBE } from "@noble/curves/utils";
+import { ValidationError } from "../errors/types.js";
 import { OutputWithPreviousTransactionData } from "../proto/spark.js";
-import { TokenTransactionService } from "../services/token-transactions.js";
 import { WalletConfigService } from "../services/config.js";
 import { ConnectionManager } from "../services/connection.js";
-import { ValidationError } from "../errors/types.js";
+import { TokenTransactionService } from "../services/token-transactions.js";
 
 describe("select token outputs", () => {
   let tokenTransactionService: TokenTransactionService;

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

@@ -1,5 +1,5 @@
-import { bytesToHex, hexToBytes } from "@noble/curves/abstract/utils";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { bytesToHex, hexToBytes } from "@noble/curves/utils";
 import * as btc from "@scure/btc-signer";
 import { Address, OutScript, SigHash, Transaction } from "@scure/btc-signer";
 import { TransactionInput, TransactionOutput } from "@scure/btc-signer/psbt";
@@ -9,8 +9,8 @@ import {
   getP2TRAddressFromPublicKey,
   getP2TRScriptFromPublicKey,
 } from "../../utils/bitcoin.js";
-import { getNetwork, Network } from "../../utils/network.js";
 import { getFetch } from "../../utils/fetch.js";
+import { getNetwork, Network } from "../../utils/network.js";
 
 // Static keys for deterministic testing
 // P2TRAddress: bcrt1p2uy9zw5ltayucsuzl4tet6ckelzawp08qrtunacscsszflye907q62uqhl

package/src/types/sdk-types.ts

@@ -1,4 +1,4 @@
-import { bytesToHex } from "@noble/curves/abstract/utils";
+import { bytesToHex } from "@noble/curves/utils";
 import ClaimStaticDeposit from "../graphql/objects/ClaimStaticDeposit.js";
 import CoopExitRequest from "../graphql/objects/CoopExitRequest.js";
 import LeavesSwapRequest from "../graphql/objects/LeavesSwapRequest.js";

package/src/utils/adaptor-signature.ts

@@ -1,6 +1,6 @@
 import { mod } from "@noble/curves/abstract/modular";
-import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/abstract/utils";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/utils";
 import { ValidationError } from "../errors/index.js";
 
 export function generateSignatureFromExistingAdaptor(

package/src/utils/address.ts

@@ -1,6 +1,6 @@
 import { BinaryWriter } from "@bufbuild/protobuf/wire";
-import { bytesToNumberBE } from "@noble/curves/abstract/utils";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { bytesToNumberBE } from "@noble/curves/utils";
 import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
 import { bech32m } from "@scure/base";
 import { UUID } from "uuidv7";

package/src/utils/bitcoin.ts

@@ -1,9 +1,5 @@
-import {
-  bytesToHex,
-  bytesToNumberBE,
-  hexToBytes,
-} from "@noble/curves/abstract/utils";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+import { bytesToHex, bytesToNumberBE, hexToBytes } from "@noble/curves/utils";
 
 import { sha256 } from "@noble/hashes/sha2";
 import * as btc from "@scure/btc-signer";

package/src/utils/keys.ts

@@ -1,5 +1,5 @@
-import { numberToBytesBE } from "@noble/curves/abstract/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
+import { numberToBytesBE } from "@noble/curves/utils";
 import { ValidationError } from "../errors/index.js";
 
 export function addPublicKeys(a: Uint8Array, b: Uint8Array): Uint8Array {

package/src/utils/secret-sharing.ts

@@ -1,5 +1,5 @@
-import { bytesToHex, equalBytes } from "@noble/curves/abstract/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
+import { bytesToHex, equalBytes } from "@noble/curves/utils";
 import { ValidationError } from "../errors/index.js";
 import { getCrypto } from "./crypto.js";
 

package/src/utils/token-transactions.ts

@@ -1,5 +1,4 @@
-import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
-import { equalBytes } from "@scure/btc-signer/utils";
+import { bytesToNumberBE, equalBytes } from "@noble/curves/utils";
 import { OutputWithPreviousTransactionData } from "../proto/spark.js";
 import { TokenBalanceMap, TokenOutputsMap } from "../spark-wallet/types.js";
 import {

package/src/utils/transfer_package.ts

@@ -1,4 +1,4 @@
-import { hexToBytes } from "@noble/curves/abstract/utils";
+import { hexToBytes } from "@noble/curves/utils";
 import { sha256 } from "@noble/hashes/sha2";
 import { TransferPackage } from "../proto/spark.js";
 

package/src/utils/unilateral-exit.ts

@@ -1,6 +1,6 @@
 // unilateral-exit.ts
 
-import { bytesToHex, hexToBytes } from "@noble/curves/abstract/utils";
+import { bytesToHex, hexToBytes } from "@noble/curves/utils";
 import { ripemd160 } from "@noble/hashes/legacy";
 import { sha256 } from "@noble/hashes/sha2";
 import * as btc from "@scure/btc-signer";