@buildonspark/spark-sdk 0.3.4 → 0.3.6

package/src/spark-wallet/spark-wallet.ts

@@ -51,7 +51,7 @@ import {
 } from "../proto/spark.js";
 import { QueryTokenTransactionsResponse } from "../proto/spark_token.js";
 import { WalletConfigService } from "../services/config.js";
-import { ConnectionManager } from "../services/connection.js";
+import { ConnectionManager } from "../services/connection/connection.js";
 import { CoopExitService } from "../services/coop-exit.js";
 import { DepositService } from "../services/deposit.js";
 import { LightningService } from "../services/lightning.js";
@@ -157,7 +157,7 @@ import { SparkWalletEvent } from "./types.js";
  * It provides methods for creating and managing wallets, handling deposits, executing transfers,
  * and interacting with the Lightning Network.
  */
-export class SparkWallet extends EventEmitter<SparkWalletEvents> {
+export abstract class SparkWallet extends EventEmitter<SparkWalletEvents> {
   protected config: WalletConfigService;
 
   protected connectionManager: ConnectionManager;
@@ -193,11 +193,11 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
 
   private tracer: Tracer | null = null;
 
-  protected constructor(options?: ConfigOptions, signer?: SparkSigner) {
+  constructor(options?: ConfigOptions, signer?: SparkSigner) {
     super();
 
     this.config = new WalletConfigService(options, signer);
-    this.connectionManager = new ConnectionManager(this.config);
+    this.connectionManager = this.buildConnectionManager(this.config);
     this.signingService = new SigningService(this.config);
     this.depositService = new DepositService(
       this.config,
@@ -225,34 +225,23 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
 
     this.tracer = trace.getTracer(this.tracerId);
     this.wrapSparkWalletMethodsWithTracing();
+    this.initializeTracer(this);
   }
 
-  public static async initialize({
-    mnemonicOrSeed,
-    accountNumber,
-    signer,
-    options,
-  }: SparkWalletProps) {
-    const wallet = new SparkWallet(options, signer);
-    wallet.initializeTracer(wallet);
-
-    if (options && options.signerWithPreExistingKeys) {
-      await wallet.initWalletWithoutSeed();
-
-      return {
-        wallet,
-      };
-    }
-
-    const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
-
-    return {
-      wallet,
-      ...initResponse,
-    };
+  public static async initialize<T extends SparkWallet>(
+    this: new (options?: ConfigOptions, signer?: SparkSigner) => T,
+    { mnemonicOrSeed, accountNumber, signer, options = {} }: SparkWalletProps,
+  ): Promise<InitWalletResponse<T>> {
+    const wallet = new this(options, signer);
+    const initWalletResponse = await wallet.initWallet(
+      mnemonicOrSeed,
+      accountNumber,
+      options,
+    );
+    return initWalletResponse as InitWalletResponse<T>;
   }
 
-  private async initializeWallet() {
+  private async createClientsAndSyncWallet() {
     this.sspClient = new SspClient(this.config);
     await this.connectionManager.createClients();
 
@@ -274,6 +263,10 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
     return this.sspClient;
   }
 
+  protected buildConnectionManager(config: WalletConfigService) {
+    return new ConnectionManager(config);
+  }
+
   private async handleStreamEvent({ event }: SubscribeToEventsResponse) {
     try {
       if (
@@ -880,14 +873,22 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
    *
    * @returns {Promise<Object>} Object containing:
    *   - mnemonic: The mnemonic if one was generated (undefined for raw seed)
-   *   - balance: The wallet's initial balance in satoshis
-   *   - tokenBalance: Map of token balances
+   *   - wallet: The wallet instance
    * @private
    */
   protected async initWallet(
     mnemonicOrSeed?: Uint8Array | string,
     accountNumber?: number,
-  ): Promise<InitWalletResponse | undefined> {
+    options: ConfigOptions = {},
+  ): Promise<InitWalletResponse<this>> {
+    if (options.signerWithPreExistingKeys) {
+      await this.initWalletWithoutSeed();
+      return {
+        wallet: this,
+        mnemonic: undefined,
+      };
+    }
+
     if (accountNumber === undefined) {
       if (this.config.getNetwork() === Network.REGTEST) {
         accountNumber = 0;
@@ -917,6 +918,7 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
 
     return {
       mnemonic,
+      wallet: this,
     };
   }
 
@@ -925,7 +927,7 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
    * @private
    */
   protected async initWalletWithoutSeed() {
-    await this.initializeWallet();
+    await this.createClientsAndSyncWallet();
 
     const identityPublicKey = await this.config.signer.getIdentityPublicKey();
 
@@ -957,7 +959,7 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
   ) {
     const identityPublicKey =
       await this.config.signer.createSparkWalletFromSeed(seed, accountNumber);
-    await this.initializeWallet();
+    await this.createClientsAndSyncWallet();
 
     this.sparkAddress = encodeSparkAddress({
       identityPublicKey: identityPublicKey,
@@ -2708,7 +2710,7 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
       amountSatsArray.push(amountSats);
     }
 
-    const transferJobs = await this.withLeaves(async () => {
+    return await this.withLeaves(async () => {
       const selectLeavesToSendMap: Map<number, TreeNode[][]> =
         await this.selectLeaves(amountSatsArray);
 
@@ -2751,50 +2753,49 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
         this.leaves = this.leaves.filter((leaf) => !idsToRemove.has(leaf.id));
       }
 
-      return jobs;
-    });
+      const signerIdentityPublicKey =
+        await this.config.signer.getIdentityPublicKey();
 
-    const signerIdentityPublicKey =
-      await this.config.signer.getIdentityPublicKey();
-
-    const outcomes = await Promise.all(
-      transferJobs.map(async (job) => {
-        try {
-          const transfer = await this.transferService.sendTransferWithKeyTweaks(
-            job.leafKeyTweaks,
-            job.receiverIdentityPubkey,
-            job.sparkInvoice,
-          );
-          const isSelfTransfer = equalBytes(
-            signerIdentityPublicKey,
-            job.receiverIdentityPubkey,
-          );
-          if (isSelfTransfer) {
-            const pending = await this.transferService.queryTransfer(
-              transfer.id,
+      const outcomes = await Promise.all(
+        jobs.map(async (job) => {
+          try {
+            const transfer =
+              await this.transferService.sendTransferWithKeyTweaks(
+                job.leafKeyTweaks,
+                job.receiverIdentityPubkey,
+                job.sparkInvoice,
+              );
+            const isSelfTransfer = equalBytes(
+              signerIdentityPublicKey,
+              job.receiverIdentityPubkey,
             );
-            if (pending) {
-              await this.claimTransfer({ transfer: pending, optimize: true });
+            if (isSelfTransfer) {
+              const pending = await this.transferService.queryTransfer(
+                transfer.id,
+              );
+              if (pending) {
+                await this.claimTransfer({ transfer: pending, optimize: true });
+              }
             }
+            return {
+              ok: true as const,
+              transfer: mapTransferToWalletTransfer(
+                transfer,
+                bytesToHex(await this.config.signer.getIdentityPublicKey()),
+              ),
+              param: job.param,
+            };
+          } catch (error) {
+            return {
+              ok: false as const,
+              error: error instanceof Error ? error : new Error(String(error)),
+              param: job.param,
+            };
           }
-          return {
-            ok: true as const,
-            transfer: mapTransferToWalletTransfer(
-              transfer,
-              bytesToHex(await this.config.signer.getIdentityPublicKey()),
-            ),
-            param: job.param,
-          };
-        } catch (error) {
-          return {
-            ok: false as const,
-            error: error instanceof Error ? error : new Error(String(error)),
-            param: job.param,
-          };
-        }
-      }),
-    );
-    return outcomes;
+        }),
+      );
+      return outcomes;
+    });
   }
 
   private buildTweaksByAmount(
@@ -3289,7 +3290,18 @@ export class SparkWallet extends EventEmitter<SparkWalletEvents> {
         });
       }
 
-      if (decodedInvoice.amountMSats !== BigInt(amountSats * 1000)) {
+      if (decodedInvoice.amountMSats === null && amountSats !== 0) {
+        throw new ValidationError("Amount mismatch", {
+          field: "amountMSats",
+          value: "null",
+          expected: amountSats * 1000,
+        });
+      }
+
+      if (
+        decodedInvoice.amountMSats !== null &&
+        decodedInvoice.amountMSats !== BigInt(amountSats * 1000)
+      ) {
         throw new ValidationError("Amount mismatch", {
           field: "amountMSats",
           value: decodedInvoice.amountMSats,

package/src/spark-wallet/types.ts

@@ -7,6 +7,7 @@ import { KeyDerivation } from "../signer/types.js";
 import { Bech32mTokenIdentifier } from "../utils/token-identifier.js";
 import { SparkAddressFormat } from "../utils/address.js";
 import { WalletTransfer } from "../types/index.js";
+import type { SparkWallet } from "./spark-wallet.js";
 
 export type CreateLightningInvoiceParams = {
   amountSats: number;
@@ -140,8 +141,9 @@ export type TokenOutputsMap = Map<
 
 export type TokenMetadataMap = Map<Bech32mTokenIdentifier, TokenMetadata>;
 
-export type InitWalletResponse = {
-  mnemonic?: string | undefined;
+export type InitWalletResponse<T extends SparkWallet = SparkWallet> = {
+  wallet: T;
+  mnemonic: string | undefined;
 };
 export interface SparkWalletProps {
   mnemonicOrSeed?: Uint8Array | string;

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

@@ -6,7 +6,7 @@ import { TransactionInput } from "@scure/btc-signer/psbt";
 import { equalBytes } from "@scure/btc-signer/utils";
 import { uuidv7 } from "uuidv7";
 import { WalletConfigService } from "../../services/config.js";
-import { ConnectionManager } from "../../services/connection.js";
+import { ConnectionManagerNodeJS } from "../../services/connection/connection.node.js";
 import { CoopExitService } from "../../services/coop-exit.js";
 import { SigningService } from "../../services/signing.js";
 import type { LeafKeyTweak } from "../../services/transfer.js";
@@ -47,7 +47,7 @@ describe.each(walletTypes)("coop exit", ({ name, Signer, createTree }) => {
       options,
       userWallet.getSigner(),
     );
-    const connectionManager = new ConnectionManager(configService);
+    const connectionManager = new ConnectionManagerNodeJS(configService);
     const signingService = new SigningService(configService);
     const coopExitService = new CoopExitService(
       configService,
@@ -69,7 +69,7 @@ describe.each(walletTypes)("coop exit", ({ name, Signer, createTree }) => {
       options,
       sspWallet.getSigner(),
     );
-    const sspConnectionManager = new ConnectionManager(sspConfigService);
+    const sspConnectionManager = new ConnectionManagerNodeJS(sspConfigService);
     const sspSigningService = new SigningService(sspConfigService);
     const sspTransferService = new TransferService(
       sspConfigService,

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

@@ -11,7 +11,7 @@ import {
 } from "../../index.js";
 import { 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 { LightningService } from "../../services/lightning.js";
 import { SigningService } from "../../services/signing.js";
 import type { LeafKeyTweak } from "../../services/transfer.js";
@@ -34,7 +34,7 @@ async function cleanUp() {
   const paymentHash = sha256(preimage);
 
   const configService = new WalletConfigService(config);
-  const connectionManager = new ConnectionManager(configService);
+  const connectionManager = new ConnectionManagerNodeJS(configService);
   for (const operator of Object.values(config.signingOperators!)) {
     const client = await connectionManager.createMockClient(operator!.address);
     await client.clean_up_preimage_share({
@@ -108,7 +108,7 @@ describe.each(walletTypes)(
         },
         userWallet.getSigner(),
       );
-      const connectionManager = new ConnectionManager(userConfig);
+      const connectionManager = new ConnectionManagerNodeJS(userConfig);
       signingService = new SigningService(userConfig);
       lightningService = new LightningService(
         userConfig,
@@ -136,7 +136,7 @@ describe.each(walletTypes)(
         },
         sspWallet.getSigner(),
       );
-      const sspConnectionManager = new ConnectionManager(sspConfig);
+      const sspConnectionManager = new ConnectionManagerNodeJS(sspConfig);
       sspSigningService = new SigningService(sspConfig);
       sspLightningService = new LightningService(
         sspConfig,

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

@@ -1,6 +1,6 @@
 import { Transaction } from "@scure/btc-signer";
 import {
-  initWallet,
+  initTestingWallet,
   SparkWalletTesting,
 } from "../../utils/spark-testing-wallet.js";
 import { expect } from "@jest/globals";
@@ -16,10 +16,8 @@ describe("SSP coop exit basic validation", () => {
   let quoteAmount: number;
 
   beforeAll(async () => {
-    const { wallet, depositAddress, signedTx, vout, faucet } = await initWallet(
-      DEPOSIT_AMOUNT,
-      "LOCAL",
-    );
+    const { wallet, depositAddress, signedTx, vout, faucet } =
+      await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
     // Wait for the transaction to be mined
     await new Promise((resolve) => setTimeout(resolve, 30000));

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

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "@jest/globals";
 import { ExitSpeed } from "../../../types/index.js";
 import {
-  initWallet,
+  initTestingWallet,
   SparkWalletTesting,
 } from "../../utils/spark-testing-wallet.js";
 import { getNewAddress } from "../../utils/regtest-test-faucet.js";
@@ -15,10 +15,8 @@ describe("SSP coop exit integration", () => {
   let quoteAmount: number;
 
   beforeEach(async () => {
-    const { wallet, depositAddress, signedTx, vout, faucet } = await initWallet(
-      DEPOSIT_AMOUNT,
-      "LOCAL",
-    );
+    const { wallet, depositAddress, signedTx, vout, faucet } =
+      await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
     // Wait for the transaction to be mined
     await new Promise((resolve) => setTimeout(resolve, 30000));

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "@jest/globals";
 import { ConfigOptions } from "../../../services/wallet-config.js";
-import { SparkWallet } from "../../../spark-wallet/spark-wallet.js";
+import { SparkWallet } from "../../../spark-wallet/spark-wallet.node.js";
 import {
   BitcoinNetwork,
   CurrencyUnit,

package/src/tests/integration/ssp/static-deposit-validation.test.ts

@@ -1,5 +1,5 @@
 import {
-  initWallet,
+  initTestingWallet,
   SparkWalletTesting,
 } from "../../utils/spark-testing-wallet.js";
 import { sha256 } from "@noble/hashes/sha2";
@@ -60,7 +60,7 @@ describe("SSP static deposit validation tests", () => {
       signedTx,
       vout,
       faucet,
-    } = await initWallet(DEPOSIT_AMOUNT, "LOCAL");
+    } = await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
     await new Promise((resolve) => setTimeout(resolve, 30000));
 

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

@@ -1,9 +1,10 @@
 import {
-  SparkWalletTesting,
-  initWallet,
+  SparkWalletTestingWithStream,
+  initTestingWallet,
 } from "../../utils/spark-testing-wallet.js";
 import { bytesToHex } from "@noble/hashes/utils";
 import { BitcoinFaucet } from "../../utils/test-faucet.js";
+import { retryUntilSuccess, waitForClaim } from "../../utils/utils.js";
 
 export const DEPOSIT_AMOUNT = 10000n;
 const SECOND_DEPOSIT_AMOUNT = 20000n;
@@ -13,14 +14,12 @@ describe("SSP static deposit address integration", () => {
   describe("Happy path testing", () => {
     it("should claim deposits to a static deposit address", async () => {
       const faucet = BitcoinFaucet.getInstance();
-      const { wallet: userWallet } = await SparkWalletTesting.initialize(
-        {
+      const { wallet: userWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options: {
             network: "LOCAL",
           },
-        },
-        false,
-      );
+        });
 
       const depositAddress = await userWallet.getStaticDepositAddress();
       expect(depositAddress).toBeDefined();
@@ -111,14 +110,12 @@ describe("SSP static deposit address integration", () => {
     it("should create a refund transaction", async () => {
       const faucet = BitcoinFaucet.getInstance();
 
-      const { wallet: userWallet } = await SparkWalletTesting.initialize(
-        {
+      const { wallet: userWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options: {
             network: "LOCAL",
           },
-        },
-        false,
-      );
+        });
 
       const depositAddress = await userWallet.getStaticDepositAddress();
       expect(depositAddress).toBeDefined();
@@ -147,11 +144,15 @@ describe("SSP static deposit address integration", () => {
 
       const refundAddress = await faucet.getNewAddress();
 
-      const refundTx = await userWallet.refundStaticDeposit({
-        depositTransactionId: transactionId,
-        destinationAddress: refundAddress,
-        satsPerVbyteFee: 2,
-      });
+      // Chainwatcher needs to catch up. Could take a few seconds so retry until success.
+      const refundTx = await retryUntilSuccess(
+        async () =>
+          await userWallet.refundStaticDeposit({
+            depositTransactionId: transactionId,
+            destinationAddress: refundAddress,
+            satsPerVbyteFee: 2,
+          }),
+      );
 
       expect(refundTx).toBeDefined();
 
@@ -170,14 +171,12 @@ describe("SSP static deposit address integration", () => {
 
     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(
-        {
+      const { wallet: userWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options: {
             network: "LOCAL",
           },
-        },
-        false,
-      );
+        });
 
       const depositAddress = await userWallet.getStaticDepositAddress();
       expect(depositAddress).toBeDefined();
@@ -301,25 +300,19 @@ describe("SSP static deposit address integration", () => {
     it("Wallet balance should be correct after concurrent claims of the same wallet initted in different places", async () => {
       const faucet = BitcoinFaucet.getInstance();
       const { wallet: aliceWallet, mnemonic: aliceMnemonic } =
-        await SparkWalletTesting.initialize(
-          {
-            options: {
-              network: "LOCAL",
-            },
+        await SparkWalletTestingWithStream.initialize({
+          options: {
+            network: "LOCAL",
           },
-          false,
-        );
+        });
 
       const { wallet: aliceWallet2, mnemonic: aliceMnemonic2 } =
-        await SparkWalletTesting.initialize(
-          {
-            options: {
-              network: "LOCAL",
-            },
-            mnemonicOrSeed: aliceMnemonic,
+        await SparkWalletTestingWithStream.initialize({
+          options: {
+            network: "LOCAL",
           },
-          false,
-        );
+          mnemonicOrSeed: aliceMnemonic,
+        });
 
       expect(aliceMnemonic).toEqual(aliceMnemonic2);
 
@@ -368,7 +361,7 @@ describe("SSP static deposit address integration", () => {
       expect(successes).toHaveLength(1);
       expect(failures).toHaveLength(1);
 
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await waitForClaim({ wallet: aliceWallet });
 
       const { balance: aliceBalance } = await aliceWallet.getBalance();
       const { balance: alice2Balance } = await aliceWallet2.getBalance();
@@ -381,14 +374,12 @@ describe("SSP static deposit address integration", () => {
 
     it("Wallet balance should be correct after concurrent claims of the same initted wallet", async () => {
       const faucet = BitcoinFaucet.getInstance();
-      const { wallet: aliceWallet } = await SparkWalletTesting.initialize(
-        {
+      const { wallet: aliceWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options: {
             network: "LOCAL",
           },
-        },
-        false,
-      );
+        });
 
       const depositAddress = await aliceWallet.getStaticDepositAddress();
 
@@ -442,23 +433,19 @@ describe("SSP static deposit address integration", () => {
 
   describe("Quote unhappy path testing", () => {
     it("should error claim quote from a different wallet", async () => {
-      const { wallet: aliceWallet } = await SparkWalletTesting.initialize(
-        {
+      const { wallet: aliceWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options: {
             network: "LOCAL",
           },
-        },
-        false,
-      );
+        });
 
-      const { wallet: bobWallet } = await SparkWalletTesting.initialize(
-        {
+      const { wallet: bobWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options: {
             network: "LOCAL",
           },
-        },
-        false,
-      );
+        });
 
       const faucet = BitcoinFaucet.getInstance();
 
@@ -483,14 +470,12 @@ describe("SSP static deposit address integration", () => {
     }, 60000);
 
     it("should error if txid does not exist", async () => {
-      const { wallet: aliceWallet } = await SparkWalletTesting.initialize(
-        {
+      const { wallet: aliceWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options: {
             network: "LOCAL",
           },
-        },
-        false,
-      );
+        });
 
       const faucet = BitcoinFaucet.getInstance();
 
@@ -517,14 +502,12 @@ describe("SSP static deposit address integration", () => {
     });
 
     it("should error claim quote if tx already claimed", async () => {
-      const { wallet: aliceWallet } = await SparkWalletTesting.initialize(
-        {
+      const { wallet: aliceWallet } =
+        await SparkWalletTestingWithStream.initialize({
           options: {
             network: "LOCAL",
           },
-        },
-        false,
-      );
+        });
 
       const faucet = BitcoinFaucet.getInstance();
 
@@ -570,7 +553,7 @@ describe("SSP static deposit address integration", () => {
         signedTx,
         vout,
         faucet,
-      } = await initWallet(DEPOSIT_AMOUNT, "LOCAL");
+      } = await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
       // Wait for the transaction to be mined
       await faucet.mineBlocks(6);
@@ -610,7 +593,7 @@ describe("SSP static deposit address integration", () => {
         signedTx,
         vout,
         faucet,
-      } = await initWallet(DEPOSIT_AMOUNT, "LOCAL");
+      } = await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
       // Wait for the transaction to be mined
       await faucet.mineBlocks(6);
@@ -661,7 +644,7 @@ describe("SSP static deposit address integration", () => {
         signedTx,
         vout,
         faucet,
-      } = await initWallet(DEPOSIT_AMOUNT, "LOCAL");
+      } = await initTestingWallet(DEPOSIT_AMOUNT, "LOCAL");
 
       // Wait for the transaction to be mined
       await faucet.mineBlocks(6);

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

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "@jest/globals";
 import { SparkWalletTesting } from "../../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "../../utils/test-faucet.js";
+import { SparkWalletTestingWithStream } from "../../utils/spark-testing-wallet.js";
 
 const DEPOSIT_AMOUNT = 10000n;
 
@@ -8,14 +9,12 @@ describe("SSP swap", () => {
   it("it should swap with the SSP before sending a transfer if the user does not have exact leaf amount", async () => {
     const faucet = BitcoinFaucet.getInstance();
 
-    const { wallet: userWallet } = await SparkWalletTesting.initialize(
-      {
+    const { wallet: userWallet } =
+      await SparkWalletTestingWithStream.initialize({
         options: {
           network: "LOCAL",
         },
-      },
-      false,
-    );
+      });
 
     const depositAddress = await userWallet.getSingleUseDepositAddress();
     expect(depositAddress).toBeDefined();