@buildonspark/spark-sdk 0.3.5 → 0.3.7

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

@@ -13,7 +13,7 @@ import {
 } from "../../index.js";
 import { InvoiceStatus, TransferStatus } from "../../proto/spark.js";
 import { WalletConfigService } from "../../services/config.js";
-import { ConnectionManager } from "../../services/connection.js";
+import { ConnectionManagerNodeJS } from "../../services/connection/connection.node.js";
 import { SigningService } from "../../services/signing.js";
 import type { LeafKeyTweak } from "../../services/transfer.js";
 import { TransferService } from "../../services/transfer.js";
@@ -24,7 +24,10 @@ import {
 } 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 {
+  SparkWalletTesting,
+  SparkWalletTestingWithStream,
+} from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../utils/test-faucet.js";
 
 const testLocalOnly = process.env.GITHUB_ACTIONS ? it.skip : it;
@@ -49,7 +52,7 @@ describe.each(walletTypes)(
         options,
         senderWallet.getSigner(),
       );
-      const senderConnectionManager = new ConnectionManager(
+      const senderConnectionManager = new ConnectionManagerNodeJS(
         senderConfigService,
       );
       const signingService = new SigningService(senderConfigService);
@@ -77,7 +80,7 @@ describe.each(walletTypes)(
         options,
         receiverWallet.getSigner(),
       );
-      const receiverConnectionManager = new ConnectionManager(
+      const receiverConnectionManager = new ConnectionManagerNodeJS(
         receiverConfigService,
       );
       const receiverSigningService = new SigningService(receiverConfigService);
@@ -165,7 +168,7 @@ describe.each(walletTypes)(
         options,
         senderWallet.getSigner(),
       );
-      const senderConnectionManager = new ConnectionManager(
+      const senderConnectionManager = new ConnectionManagerNodeJS(
         senderConfigService,
       );
       const senderSigningService = new SigningService(senderConfigService);
@@ -186,7 +189,7 @@ describe.each(walletTypes)(
         options,
         receiverWallet.getSigner(),
       );
-      const receiverConnectionManager = new ConnectionManager(
+      const receiverConnectionManager = new ConnectionManagerNodeJS(
         receiverConfigService,
       );
       const receiverSigningService = new SigningService(receiverConfigService);
@@ -264,7 +267,7 @@ describe.each(walletTypes)(
 
       const transferService = new TransferService(
         receiverConfigService,
-        new ConnectionManager(receiverConfigService),
+        new ConnectionManagerNodeJS(receiverConfigService),
         new SigningService(receiverConfigService),
       );
 
@@ -329,7 +332,7 @@ describe.each(walletTypes)(
           options,
           senderWallet.getSigner(),
         );
-        const senderConnectionManager = new ConnectionManager(
+        const senderConnectionManager = new ConnectionManagerNodeJS(
           senderConfigService,
         );
         const senderSigningService = new SigningService(senderConfigService);
@@ -372,7 +375,7 @@ describe.each(walletTypes)(
           missingOperatorOptions,
           receiverWallet.getSigner(),
         );
-        const receiverConnectionManager = new ConnectionManager(
+        const receiverConnectionManager = new ConnectionManagerNodeJS(
           receiverConfigService,
         );
         const receiverSigningService = new SigningService(
@@ -457,9 +460,8 @@ describe.each(walletTypes)(
           receiverOptions,
           receiverWalletWithAllOperators.getSigner(),
         );
-        const receiverConnectionManagerWithAllOperators = new ConnectionManager(
-          receiverConfigServiceWithAllOperators,
-        );
+        const receiverConnectionManagerWithAllOperators =
+          new ConnectionManagerNodeJS(receiverConfigServiceWithAllOperators);
         const receiverSigningServiceWithAllOperators = new SigningService(
           receiverConfigServiceWithAllOperators,
         );
@@ -550,12 +552,10 @@ describe.each(walletTypes)(
 
       await senderWallet.claimDeposit(signedTx.id);
 
-      const { wallet: receiverWallet } = await SparkWalletTesting.initialize(
-        {
+      const { wallet: receiverWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options,
-        },
-        false,
-      );
+        });
 
       expect(await receiverWallet.getSparkAddress()).not.toEqual(
         await senderWallet.getSparkAddress(),
@@ -719,7 +719,9 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
       options,
       senderWallet.getSigner(),
     );
-    const senderConnectionManager = new ConnectionManager(senderConfigService);
+    const senderConnectionManager = new ConnectionManagerNodeJS(
+      senderConfigService,
+    );
     const signingService = new SigningService(senderConfigService);
     const senderTransferService = new TransferService(
       senderConfigService,
@@ -745,7 +747,7 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
       options,
       receiverWallet.getSigner(),
     );
-    const receiverConnectionManager = new ConnectionManager(
+    const receiverConnectionManager = new ConnectionManagerNodeJS(
       receiverConfigService,
     );
     const receiverSigningService = new SigningService(receiverConfigService);
@@ -834,7 +836,9 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
       options,
       senderWallet.getSigner(),
     );
-    const senderConnectionManager = new ConnectionManager(senderConfigService);
+    const senderConnectionManager = new ConnectionManagerNodeJS(
+      senderConfigService,
+    );
     const senderSigningService = new SigningService(senderConfigService);
     const senderTransferService = new TransferService(
       senderConfigService,
@@ -1093,7 +1097,7 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
       options,
       sdk2.getSigner(),
     );
-    const receiverConnectionManager = new ConnectionManager(
+    const receiverConnectionManager = new ConnectionManagerNodeJS(
       receiverConfigService,
     );
     const receiverSigningService = new SigningService(receiverConfigService);
@@ -1177,7 +1181,7 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
     });
 
     const bobConfigService = new WalletConfigService(options, bob.getSigner());
-    const bobConnectionManager = new ConnectionManager(bobConfigService);
+    const bobConnectionManager = new ConnectionManagerNodeJS(bobConfigService);
     const bobSigningService = new SigningService(bobConfigService);
 
     const bobTransferService = new TransferService(
@@ -1252,7 +1256,7 @@ describe.each(walletTypes)("transfer v2", ({ name, Signer, createTree }) => {
     });
 
     const bobConfigService = new WalletConfigService(options, bob.getSigner());
-    const bobConnectionManager = new ConnectionManager(bobConfigService);
+    const bobConnectionManager = new ConnectionManagerNodeJS(bobConfigService);
     const bobSigningService = new SigningService(bobConfigService);
 
     const bobTransferService = new TransferService(
@@ -1365,7 +1369,7 @@ describe.skip.each(walletTypes)(
         options,
         sdk2.getSigner(),
       );
-      const receiverConnectionManager = new ConnectionManager(
+      const receiverConnectionManager = new ConnectionManagerNodeJS(
         receiverConfigService,
       );
       const receiverSigningService = new SigningService(receiverConfigService);
@@ -1482,7 +1486,7 @@ describe.skip.each(walletTypes)(
         options,
         sdk2.getSigner(),
       );
-      const receiverConnectionManager = new ConnectionManager(
+      const receiverConnectionManager = new ConnectionManagerNodeJS(
         receiverConfigService,
       );
       const receiverSigningService = new SigningService(receiverConfigService);
@@ -1542,7 +1546,7 @@ describe.skip.each(walletTypes)(
         options,
         sdk2.getSigner(),
       );
-      const receiverConnectionManager = new ConnectionManager(
+      const receiverConnectionManager = new ConnectionManagerNodeJS(
         receiverConfigService,
       );
       const receiverSigningService = new SigningService(receiverConfigService);

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

@@ -3,7 +3,7 @@ import { bytesToHex, hexToBytes } from "@noble/curves/utils";
 import { uuidv7 } from "uuidv7";
 import { KeyDerivation, KeyDerivationType } from "../../index.js";
 import { WalletConfigService } from "../../services/config.js";
-import { ConnectionManager } from "../../services/connection.js";
+import { ConnectionManagerNodeJS } from "../../services/connection/connection.node.js";
 import { SigningService } from "../../services/signing.js";
 import type { LeafKeyTweak } from "../../services/transfer.js";
 import { TransferService } from "../../services/transfer.js";
@@ -42,7 +42,7 @@ describe.each(walletTypes)("Node compatibility tests", ({ name, Signer }) => {
       options,
       oldWallet.getSigner(),
     );
-    const oldConnectionManager = new ConnectionManager(oldConfigService);
+    const oldConnectionManager = new ConnectionManagerNodeJS(oldConfigService);
     const oldSigningService = new SigningService(oldConfigService);
     const oldTransferService = new TransferService(
       oldConfigService,
@@ -54,7 +54,7 @@ describe.each(walletTypes)("Node compatibility tests", ({ name, Signer }) => {
       options,
       newWallet.getSigner(),
     );
-    const newConnectionManager = new ConnectionManager(newConfigService);
+    const newConnectionManager = new ConnectionManagerNodeJS(newConfigService);
     const newSigningService = new SigningService(newConfigService);
     const newTransferService = new TransferService(
       newConfigService,

package/src/tests/optimize.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  greedyLeaves,
+  swapMinimizingLeaves,
+  maximizeUnilateralExit,
+  minimizeTransferSwap,
+  Swap,
+} from "../utils/optimize.js";
+
+describe("keys", () => {
+  it("test greedyLeaves", () => {
+    expect(greedyLeaves(0)).toEqual([]);
+    expect(greedyLeaves(1)).toEqual([1]);
+    expect(greedyLeaves(100)).toEqual([4, 32, 64]);
+    expect(greedyLeaves(255)).toEqual([1, 2, 4, 8, 16, 32, 64, 128]);
+    expect(greedyLeaves(256)).toEqual([256]);
+  });
+
+  it("test swapMinimizingLeaves", () => {
+    expect(swapMinimizingLeaves(0)).toEqual([]);
+    expect(swapMinimizingLeaves(1)).toEqual([1]);
+    expect(swapMinimizingLeaves(100)).toEqual([1, 1, 2, 4, 4, 8, 16, 32, 32]);
+    expect(swapMinimizingLeaves(255)).toEqual([1, 2, 4, 8, 16, 32, 64, 128]);
+    expect(swapMinimizingLeaves(256)).toEqual([1, 1, 2, 4, 8, 16, 32, 64, 128]);
+  });
+
+  it("test maximizeUnilateralExit", () => {
+    expect(maximizeUnilateralExit([100, 64, 28, 1, 1])).toEqual([
+      new Swap([1, 1, 28, 64, 100], [2, 64, 128]),
+    ]);
+    expect(maximizeUnilateralExit([1, 1, 1, 1, 1, 1, 1, 1], 2)).toEqual([
+      new Swap([1, 1], [2]),
+      new Swap([1, 1], [2]),
+      new Swap([1, 1], [2]),
+      new Swap([1, 1], [2]),
+    ]);
+  });
+
+  it("test minimizeTransferSwap", () => {
+    expect(minimizeTransferSwap([8])).toEqual([new Swap([8], [1, 1, 2, 4])]);
+    expect(minimizeTransferSwap([100])).toEqual([
+      new Swap([100], [1, 1, 2, 4, 4, 8, 16, 32, 32]),
+    ]);
+  });
+});

package/src/tests/spark-wallet/queryNodes.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect, beforeEach, jest } from "@jest/globals";
-import { SparkWallet } from "../../spark-wallet/spark-wallet.js";
-import type { ConnectionManager } from "../../services/connection.js";
+import { SparkWallet } from "../../spark-wallet/spark-wallet.node.js";
 
 /** Helper subclass to expose the private `queryNodes` method for testing. */
 class TestSparkWallet extends SparkWallet {

package/src/tests/test-utils.ts

@@ -8,7 +8,7 @@ import {
 } from "../index.js";
 import { FinalizeNodeSignaturesResponse, TreeNode } from "../proto/spark.js";
 import { WalletConfigService } from "../services/config.js";
-import { ConnectionManager } from "../services/connection.js";
+import { ConnectionManagerNodeJS } from "../services/connection/connection.node.js";
 import { DepositService } from "../services/deposit.js";
 import { ConfigOptions, WalletConfig } from "../services/wallet-config.js";
 import { getP2TRAddressFromPublicKey } from "../utils/bitcoin.js";
@@ -17,7 +17,7 @@ import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "./utils/test-faucet.js";
 import { sha256 } from "@noble/hashes/sha2";
 
-export { BitcoinFaucet };
+export { BitcoinFaucet, SparkWalletTesting };
 
 export function getTestWalletConfig() {
   const identityPrivateKey = secp256k1.utils.randomPrivateKey();
@@ -48,7 +48,7 @@ async function createDeposit(
     },
     wallet.getSigner(),
   );
-  const connectionManager = new ConnectionManager(configService);
+  const connectionManager = new ConnectionManagerNodeJS(configService);
   const depositService = new DepositService(configService, connectionManager);
 
   const pubKey = await wallet.getSigner().getPublicKeyFromDerivation({

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

@@ -1,8 +1,8 @@
-import { numberToBytesBE } from "@noble/curves/utils";
+import { numberToBytesBE, bytesToNumberBE } from "@noble/curves/utils";
 import { ValidationError } from "../errors/types.js";
 import { OutputWithPreviousTransactionData } from "../proto/spark.js";
 import { WalletConfigService } from "../services/config.js";
-import { ConnectionManager } from "../services/connection.js";
+import { ConnectionManager } from "../services/connection/connection.js";
 import { TokenTransactionService } from "../services/token-transactions.js";
 
 describe("select token outputs", () => {
@@ -17,6 +17,18 @@ describe("select token outputs", () => {
     );
   });
 
+  // Helper to access the private sorting method
+  const sortTokenOutputsByStrategy = (
+    tokenOutputs: OutputWithPreviousTransactionData[],
+    strategy: "SMALL_FIRST" | "LARGE_FIRST",
+  ) => {
+    // TypeScript bracket notation to access private method
+    (tokenTransactionService as any)["sortTokenOutputsByStrategy"](
+      tokenOutputs,
+      strategy,
+    );
+  };
+
   const createMockTokenOutput = (
     id: string,
     tokenAmount: bigint,
@@ -191,4 +203,51 @@ describe("select token outputs", () => {
       // Total: 600n >= 600n
     });
   });
+
+  describe("sorting with large amounts", () => {
+    it("should sort correctly when all amounts are above 2^60", () => {
+      const base = 2n ** 60n;
+      const amounts = [
+        base + 5000n,
+        base + 100n,
+        base + 1n,
+        base + 10000n,
+        base + 500n,
+      ];
+
+      const tokenOutputs = amounts.map((amount, i) =>
+        createMockTokenOutput(`output${i}`, amount),
+      );
+
+      // SMALL_FIRST
+      const smallFirstSorted = [...tokenOutputs];
+      sortTokenOutputsByStrategy(smallFirstSorted, "SMALL_FIRST");
+
+      const smallFirstAmounts = smallFirstSorted.map((o) =>
+        bytesToNumberBE(o.output!.tokenAmount!),
+      );
+      expect(smallFirstAmounts).toEqual([
+        base + 1n,
+        base + 100n,
+        base + 500n,
+        base + 5000n,
+        base + 10000n,
+      ]);
+
+      // LARGE_FIRST
+      const largeFirstSorted = [...tokenOutputs];
+      sortTokenOutputsByStrategy(largeFirstSorted, "LARGE_FIRST");
+
+      const largeFirstAmounts = largeFirstSorted.map((o) =>
+        bytesToNumberBE(o.output!.tokenAmount!),
+      );
+      expect(largeFirstAmounts).toEqual([
+        base + 10000n,
+        base + 5000n,
+        base + 500n,
+        base + 100n,
+        base + 1n,
+      ]);
+    });
+  });
 });

package/src/tests/utils/spark-testing-wallet.ts

@@ -1,65 +1,22 @@
 import { QueryTransfersResponse, Transfer } from "../../proto/spark.js";
 import { ConfigOptions } from "../../services/wallet-config.js";
 import { SparkSigner } from "../../signer/signer.js";
-import { SparkWallet } from "../../spark-wallet/spark-wallet.node.js";
 import type { SparkWalletProps } from "../../spark-wallet/types.js";
 import { BitcoinFaucet } from "./test-faucet.js";
 import { Transaction } from "@scure/btc-signer";
 import { NetworkType } from "../../index.node.js";
+import { SparkWalletNodeJS } from "../../spark-wallet/spark-wallet.node.js";
 
-interface ISparkWalletTesting extends SparkWallet {
-  getSigner(): SparkSigner;
-  queryPendingTransfers(): Promise<QueryTransfersResponse>;
-  verifyPendingTransfer(transfer: Transfer): Promise<Map<string, Uint8Array>>;
-}
-
-export class SparkWalletTesting
-  extends SparkWallet
-  implements ISparkWalletTesting
-{
-  private disableEvents: boolean;
-
-  constructor(
-    options?: ConfigOptions,
-    signer?: SparkSigner,
-    disableEvents = true,
-  ) {
-    super(options, signer);
-    this.disableEvents = disableEvents;
-  }
-
-  static async initialize(props: SparkWalletProps, disableEvents = true) {
-    const wallet = new SparkWalletTesting(
-      props.options,
-      props.signer,
-      disableEvents,
-    );
-
-    if (props.options && props.options.signerWithPreExistingKeys) {
-      await wallet.initWalletWithoutSeed();
-
-      return {
-        wallet,
-      };
-    } else {
-      const initResponse = await wallet.initWallet(
-        props.mnemonicOrSeed,
-        props.accountNumber,
-      );
-      return {
-        wallet,
-        mnemonic: initResponse?.mnemonic,
-      };
-    }
-  }
-
+export class SparkWalletTesting extends SparkWalletNodeJS {
   protected override async setupBackgroundStream() {
-    if (!this.disableEvents) {
-      await super.setupBackgroundStream();
-    }
+    // Background stream is disabled by default, use SparkWalletTestingWithStream to enable it
     return;
   }
 
+  protected async proxyParentSetupBackgroundStream() {
+    return super.setupBackgroundStream();
+  }
+
   public getSigner(): SparkSigner {
     return this.config.signer;
   }
@@ -75,7 +32,13 @@ export class SparkWalletTesting
   }
 }
 
-export async function initWallet(
+export class SparkWalletTestingWithStream extends SparkWalletTesting {
+  protected override async setupBackgroundStream() {
+    return this.proxyParentSetupBackgroundStream();
+  }
+}
+
+export async function initTestingWallet(
   amount: bigint,
   network: NetworkType,
 ): Promise<{
@@ -86,14 +49,11 @@ export async function initWallet(
   faucet: BitcoinFaucet;
 }> {
   const faucet = BitcoinFaucet.getInstance();
-  const { wallet: userWallet } = await SparkWalletTesting.initialize(
-    {
-      options: {
-        network: network,
-      },
+  const { wallet: userWallet } = await SparkWalletTestingWithStream.initialize({
+    options: {
+      network: network,
     },
-    false,
-  );
+  });
 
   const depositAddress = await userWallet.getStaticDepositAddress();
 

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

@@ -42,9 +42,9 @@ export class BitcoinFaucet {
   private lock: Promise<void> = Promise.resolve();
 
   private constructor(
-    private url: string = "http://127.0.0.1:8332",
-    private username: string = "testutil",
-    private password: string = "testutilpassword",
+    private url: string,
+    private username: string,
+    private password: string,
   ) {
     this.miningAddress = getP2TRAddressFromPublicKey(
       secp256k1.getPublicKey(STATIC_MINING_KEY),
@@ -52,12 +52,16 @@ export class BitcoinFaucet {
     );
   }
 
-  static getInstance(
-    url: string = "http://127.0.0.1:8332",
-    username: string = "testutil",
-    password: string = "testutilpassword",
-  ): BitcoinFaucet {
+  static getInstance(): BitcoinFaucet {
     if (!BitcoinFaucet.instance) {
+      const url =
+        process.env.BITCOIN_RPC_URL ||
+        (process.env.MINIKUBE_IP
+          ? `http://${process.env.MINIKUBE_IP}:8332`
+          : "http://127.0.0.1:8332");
+      const username = process.env.BITCOIN_RPC_USER || "testutil";
+      const password = process.env.BITCOIN_RPC_PASSWORD || "testutilpassword";
+
       BitcoinFaucet.instance = new BitcoinFaucet(url, username, password);
     }
     return BitcoinFaucet.instance;

package/src/tests/utils/utils.ts

@@ -0,0 +1,63 @@
+import { SparkWalletTesting } from "./spark-testing-wallet.js";
+import { SparkWalletEvent } from "../../index.js";
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * Retry a function until it succeeds.
+ * @param fn - The function to retry.
+ * @param maxAttempts - The maximum number of attempts.
+ * @param delayMs - The delay between attempts.
+ * @returns The result of the function.
+ */
+export async function retryUntilSuccess<T>(
+  fn: () => Promise<T>,
+  { maxAttempts = 20, delayMs = 2000 } = {},
+): Promise<T> {
+  let err: unknown;
+  for (let i = 1; i <= maxAttempts; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      err = e;
+    }
+    await sleep(delayMs);
+  }
+  throw err;
+}
+
+/**
+ * Wait for a claim to be made on a wallet.
+ * @param wallet - The wallet to wait for a claim on.
+ * @param timeoutMs - The timeout in milliseconds.
+ * @param throwOnTimeout - Whether to throw an error if the timeout is reached.
+ * @returns A promise that resolves when the claim is made.
+ */
+export async function waitForClaim({
+  wallet,
+  timeoutMs = 30000,
+  throwOnTimeout = false,
+}: {
+  wallet: SparkWalletTesting;
+  timeoutMs?: number;
+  throwOnTimeout?: boolean;
+}): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const onClaim = () => {
+      cleanup();
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      if (throwOnTimeout) {
+        reject(new Error("claim timeout"));
+      } else {
+        resolve();
+      }
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+    };
+    wallet.once(SparkWalletEvent.TransferClaimed, onClaim);
+  });
+}

package/src/tests/wrapWithOtelSpan.test.ts

@@ -3,9 +3,16 @@ import { SparkWalletTesting } from "./utils/spark-testing-wallet.js";
 import { getTestWalletConfig } from "./test-utils.js";
 import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
 import { trace } from "@opentelemetry/api";
+import { ConfigOptions } from "../index.node.js";
+import { SparkSigner } from "../signer/signer.js";
 
 class TestableWallet extends SparkWalletTesting {
   public wrapWithOtelSpanPublic = this.wrapWithOtelSpan;
+
+  // Public constructor to allow direct instantiation in tests without init
+  public constructor(options?: ConfigOptions, signer?: SparkSigner) {
+    super(options, signer);
+  }
 }
 
 // Set up a real tracer provider once for all tests

package/src/utils/network.ts

@@ -1,5 +1,5 @@
 import * as btc from "@scure/btc-signer";
-import * as bitcoin from "bitcoinjs-lib";
+import { bech32, bech32m } from "@scure/base";
 import { Network as NetworkProto } from "../proto/spark.js";
 import { BitcoinNetwork } from "../graphql/objects/BitcoinNetwork.js";
 import { ValidationError } from "../errors/index.js";
@@ -50,14 +50,6 @@ const NetworkConfig: Record<Network, typeof btc.NETWORK> = {
 export const getNetwork = (network: Network): typeof btc.NETWORK =>
   NetworkConfig[network];
 
-export const LRC_WALLET_NETWORK = Object.freeze({
-  [Network.MAINNET]: bitcoin.networks.bitcoin,
-  [Network.TESTNET]: bitcoin.networks.testnet,
-  [Network.SIGNET]: bitcoin.networks.testnet,
-  [Network.REGTEST]: bitcoin.networks.regtest,
-  [Network.LOCAL]: bitcoin.networks.regtest,
-});
-
 /**
  * Utility function to determine the network from a Bitcoin address.
  *
@@ -66,7 +58,16 @@ export const LRC_WALLET_NETWORK = Object.freeze({
  */
 export function getNetworkFromAddress(address: string) {
   try {
-    const decoded = bitcoin.address.fromBech32(address);
+    // Try bech32 first, then bech32m (Taproot)
+    const bechAddress = address as `${string}1${string}`;
+    const decoded = (() => {
+      try {
+        return bech32.decode(bechAddress);
+      } catch (_) {
+        return bech32m.decode(bechAddress);
+      }
+    })();
+
     // HRP (human-readable part) determines the network
     if (decoded.prefix === "bc") {
       return BitcoinNetwork.MAINNET;