@buildonspark/issuer-sdk 0.0.34 → 0.0.36

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

@@ -1,4 +1,4 @@
-import { SparkWallet } from "@buildonspark/spark-sdk";
+import { filterTokenBalanceForTokenPublicKey } from "@buildonspark/spark-sdk/utils";
 import { jest } from "@jest/globals";
 import { hexToBytes } from "@noble/curves/abstract/utils";
 import {
@@ -6,16 +6,16 @@ import {
   LOCAL_WALLET_CONFIG_SCHNORR,
 } from "../../../../spark-sdk/src/services/wallet-config.js";
 import { BitcoinFaucet } from "../../../../spark-sdk/src/tests/utils/test-faucet.js";
-import { IssuerSparkWallet } from "../../issuer-spark-wallet.js";
-import { filterTokenBalanceForTokenPublicKey } from "@buildonspark/spark-sdk/utils";
+import { IssuerSparkWalletTesting } from "../utils/issuer-test-wallet.js";
+import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 
 const brokenTestFn = process.env.GITHUB_ACTIONS ? it.skip : it;
 describe("token integration test", () => {
   jest.setTimeout(80000);
 
-  it("should issue a single token with ECDSA", async () => {
+  brokenTestFn("should issue a single token with ECDSA", async () => {
     const tokenAmount: bigint = 1000n;
-    const { wallet } = await IssuerSparkWallet.initialize({
+    const { wallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_ECDSA,
     });
 
@@ -25,9 +25,9 @@ describe("token integration test", () => {
     expect(tokenBalance).toEqual(tokenAmount);
   });
 
-  it("should issue a single token with Schnorr", async () => {
+  brokenTestFn("should issue a single token with Schnorr", async () => {
     const tokenAmount: bigint = 1000n;
-    const { wallet } = await IssuerSparkWallet.initialize({
+    const { wallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_SCHNORR,
     });
 
@@ -39,15 +39,15 @@ describe("token integration test", () => {
 
   brokenTestFn("should announce and issue a single token", async () => {
     const tokenAmount: bigint = 1000n;
-    const { wallet } = await IssuerSparkWallet.initialize({
+    const { wallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_SCHNORR,
     });
 
     // Faucet funds to the Issuer wallet because announcing a token
     // requires ownership of an L1 UTXO.
-    const faucet = new BitcoinFaucet();
-    const l1WalletPubKey = await wallet.getIdentityPublicKey();
-    await faucet.sendFaucetCoinToP2WPKHAddress(hexToBytes(l1WalletPubKey));
+    const faucet = BitcoinFaucet.getInstance();
+    const l1WalletPubKey = await wallet.getTokenL1Address();
+    await faucet.sendToAddress(l1WalletPubKey, 100_000n);
     await faucet.mineBlocks(6);
 
     await new Promise((resolve) => setTimeout(resolve, 5000));
@@ -57,7 +57,7 @@ describe("token integration test", () => {
         tokenName: "TestToken1",
         tokenTicker: "TT1",
         decimals: 0,
-        maxSupply: 0,
+        maxSupply: 0n,
         isFreezable: false,
       });
       console.log("Announce token response:", response);
@@ -96,43 +96,50 @@ describe("token integration test", () => {
     expect(tokenInfo[0].maxSupply).toEqual(tokenAmount);
   });
 
-  it("should issue a single token and transfer it with ECDSA", async () => {
-    const tokenAmount: bigint = 1000n;
-
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
-      options: LOCAL_WALLET_CONFIG_ECDSA,
-    });
-
-    const { wallet: destinationWallet } = await SparkWallet.initialize({
-      options: LOCAL_WALLET_CONFIG_ECDSA,
-    });
-
-    await issuerWallet.mintTokens(tokenAmount);
-    await issuerWallet.transferTokens({
-      tokenAmount,
-      tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
-      receiverSparkAddress: await destinationWallet.getSparkAddress(),
-    });
-    const sourceBalance = (await issuerWallet.getIssuerTokenBalance()).balance;
-    expect(sourceBalance).toEqual(0n);
-
-    const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
-    const balanceObj = await destinationWallet.getBalance();
-    const destinationBalance = filterTokenBalanceForTokenPublicKey(
-      balanceObj?.tokenBalances,
-      tokenPublicKey,
-    );
-    expect(destinationBalance.balance).toEqual(tokenAmount);
-  });
-
-  it("monitoring operations", async () => {
+  brokenTestFn(
+    "should issue a single token and transfer it with ECDSA",
+    async () => {
+      const tokenAmount: bigint = 1000n;
+
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: LOCAL_WALLET_CONFIG_ECDSA,
+        });
+
+      const { wallet: destinationWallet } = await SparkWalletTesting.initialize(
+        {
+          options: LOCAL_WALLET_CONFIG_ECDSA,
+        },
+      );
+
+      await issuerWallet.mintTokens(tokenAmount);
+      await issuerWallet.transferTokens({
+        tokenAmount,
+        tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
+        receiverSparkAddress: await destinationWallet.getSparkAddress(),
+      });
+      const sourceBalance = (await issuerWallet.getIssuerTokenBalance())
+        .balance;
+      expect(sourceBalance).toEqual(0n);
+
+      const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
+      const balanceObj = await destinationWallet.getBalance();
+      const destinationBalance = filterTokenBalanceForTokenPublicKey(
+        balanceObj?.tokenBalances,
+        tokenPublicKey,
+      );
+      expect(destinationBalance.balance).toEqual(tokenAmount);
+    },
+  );
+
+  brokenTestFn("monitoring operations", async () => {
     const tokenAmount: bigint = 1000n;
 
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
+    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_ECDSA,
     });
 
-    const { wallet: destinationWallet } = await SparkWallet.initialize({
+    const { wallet: destinationWallet } = await SparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_ECDSA,
     });
 
@@ -162,37 +169,44 @@ describe("token integration test", () => {
     }
   });
 
-  it("should issue a single token and transfer it with Schnorr", async () => {
-    const tokenAmount: bigint = 1000n;
-
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
-      options: LOCAL_WALLET_CONFIG_SCHNORR,
-    });
-
-    const { wallet: destinationWallet } = await SparkWallet.initialize({
-      options: LOCAL_WALLET_CONFIG_SCHNORR,
-    });
-
-    await issuerWallet.mintTokens(tokenAmount);
-    await issuerWallet.transferTokens({
-      tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
-      tokenAmount,
-      receiverSparkAddress: await destinationWallet.getSparkAddress(),
-    });
-    const sourceBalance = (await issuerWallet.getIssuerTokenBalance()).balance;
-    expect(sourceBalance).toEqual(0n);
-    const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
-    const balanceObj = await destinationWallet.getBalance();
-    const destinationBalance = filterTokenBalanceForTokenPublicKey(
-      balanceObj?.tokenBalances,
-      tokenPublicKey,
-    );
-    expect(destinationBalance.balance).toEqual(tokenAmount);
-  });
-
-  it("should freeze tokens with ECDSA", async () => {
+  brokenTestFn(
+    "should issue a single token and transfer it with Schnorr",
+    async () => {
+      const tokenAmount: bigint = 1000n;
+
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: LOCAL_WALLET_CONFIG_SCHNORR,
+        });
+
+      const { wallet: destinationWallet } = await SparkWalletTesting.initialize(
+        {
+          options: LOCAL_WALLET_CONFIG_SCHNORR,
+        },
+      );
+
+      await issuerWallet.mintTokens(tokenAmount);
+      await issuerWallet.transferTokens({
+        tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
+        tokenAmount,
+        receiverSparkAddress: await destinationWallet.getSparkAddress(),
+      });
+      const sourceBalance = (await issuerWallet.getIssuerTokenBalance())
+        .balance;
+      expect(sourceBalance).toEqual(0n);
+      const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
+      const balanceObj = await destinationWallet.getBalance();
+      const destinationBalance = filterTokenBalanceForTokenPublicKey(
+        balanceObj?.tokenBalances,
+        tokenPublicKey,
+      );
+      expect(destinationBalance.balance).toEqual(tokenAmount);
+    },
+  );
+
+  brokenTestFn("should freeze tokens with ECDSA", async () => {
     const tokenAmount: bigint = 1000n;
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
+    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_ECDSA,
     });
 
@@ -203,7 +217,7 @@ describe("token integration test", () => {
       .balance;
     expect(issuerBalanceAfterMint).toEqual(tokenAmount);
 
-    const { wallet: userWallet } = await SparkWallet.initialize({
+    const { wallet: userWallet } = await SparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_ECDSA,
     });
     const userWalletPublicKey = await userWallet.getSparkAddress();
@@ -237,9 +251,9 @@ describe("token integration test", () => {
     expect(unfreezeResponse.impactedTokenAmount).toEqual(tokenAmount);
   });
 
-  it("should freeze tokens with Schnorr", async () => {
+  brokenTestFn("should freeze tokens with Schnorr", async () => {
     const tokenAmount: bigint = 1000n;
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
+    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_SCHNORR,
     });
 
@@ -250,7 +264,7 @@ describe("token integration test", () => {
       .balance;
     expect(issuerBalanceAfterMint).toEqual(tokenAmount);
 
-    const { wallet: userWallet } = await SparkWallet.initialize({
+    const { wallet: userWallet } = await SparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_SCHNORR,
     });
     const userWalletPublicKey = await userWallet.getSparkAddress();
@@ -284,9 +298,9 @@ describe("token integration test", () => {
     expect(unfreezeResult.impactedTokenAmount).toBe(1000n);
   });
 
-  it("should burn tokens with ECDSA", async () => {
+  brokenTestFn("should burn tokens with ECDSA", async () => {
     const tokenAmount: bigint = 200n;
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
+    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_ECDSA,
     });
     await issuerWallet.mintTokens(tokenAmount);
@@ -303,9 +317,9 @@ describe("token integration test", () => {
     expect(issuerTokenBalanceAfterBurn).toEqual(0n);
   });
 
-  it("should burn tokens with Schnorr", async () => {
+  brokenTestFn("should burn tokens with Schnorr", async () => {
     const tokenAmount: bigint = 200n;
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
+    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_SCHNORR,
     });
     await issuerWallet.mintTokens(tokenAmount);
@@ -322,128 +336,138 @@ describe("token integration test", () => {
     expect(issuerTokenBalanceAfterBurn).toEqual(0n);
   });
 
-  it("mint, transfer to user, user transfer to issuer, burn with ECDSA", async () => {
-    const tokenAmount: bigint = 1000n;
-
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
-      options: LOCAL_WALLET_CONFIG_ECDSA,
-    });
-
-    const { wallet: userWallet } = await SparkWallet.initialize({
-      options: LOCAL_WALLET_CONFIG_ECDSA,
-    });
-
-    await issuerWallet.mintTokens(tokenAmount);
-
-    const issuerBalanceAfterMint = (await issuerWallet.getIssuerTokenBalance())
-      .balance;
-    expect(issuerBalanceAfterMint).toEqual(tokenAmount);
-
-    const userWalletPublicKey = await userWallet.getSparkAddress();
-
-    await issuerWallet.transferTokens({
-      tokenAmount,
-      tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
-      receiverSparkAddress: userWalletPublicKey,
-    });
-
-    const issuerBalanceAfterTransfer = (
-      await issuerWallet.getIssuerTokenBalance()
-    ).balance;
-    expect(issuerBalanceAfterTransfer).toEqual(0n);
-    const tokenPublicKeyHex = await issuerWallet.getIdentityPublicKey();
-    const userWalletPublicKeyHex = await userWallet.getSparkAddress();
-    const userBalanceObj = await userWallet.getBalance();
-    const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
-      userBalanceObj?.tokenBalances,
-      tokenPublicKeyHex,
-    );
-    expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
-    await userWallet.transferTokens({
-      tokenPublicKey: tokenPublicKeyHex,
-      tokenAmount,
-      receiverSparkAddress: await issuerWallet.getSparkAddress(),
-    });
-
-    const userBalanceObjAfterTransferBack = await userWallet.getBalance();
-    const userBalanceAfterTransferBack = filterTokenBalanceForTokenPublicKey(
-      userBalanceObjAfterTransferBack?.tokenBalances,
-      tokenPublicKeyHex,
-    );
-
-    expect(userBalanceAfterTransferBack.balance).toEqual(0n);
-
-    const issuerTokenBalance = (await issuerWallet.getIssuerTokenBalance())
-      .balance;
-    expect(issuerTokenBalance).toEqual(tokenAmount);
-    await issuerWallet.burnTokens(tokenAmount);
-    const issuerTokenBalanceAfterBurn = (
-      await issuerWallet.getIssuerTokenBalance()
-    ).balance;
-    expect(issuerTokenBalanceAfterBurn).toEqual(0n);
-  });
+  brokenTestFn(
+    "mint, transfer to user, user transfer to issuer, burn with ECDSA",
+    async () => {
+      const tokenAmount: bigint = 1000n;
 
-  it("mint, transfer to user, user transfer to issuer, burn with Schnorr", async () => {
-    const tokenAmount: bigint = 1000n;
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: LOCAL_WALLET_CONFIG_ECDSA,
+        });
 
-    const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
-      options: LOCAL_WALLET_CONFIG_SCHNORR,
-    });
+      const { wallet: userWallet } = await SparkWalletTesting.initialize({
+        options: LOCAL_WALLET_CONFIG_ECDSA,
+      });
 
-    const { wallet: userWallet } = await SparkWallet.initialize({
-      options: LOCAL_WALLET_CONFIG_SCHNORR,
-    });
+      await issuerWallet.mintTokens(tokenAmount);
 
-    const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
-    await issuerWallet.mintTokens(tokenAmount);
+      const issuerBalanceAfterMint = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterMint).toEqual(tokenAmount);
 
-    const issuerBalanceAfterMint = (await issuerWallet.getIssuerTokenBalance())
-      .balance;
-    expect(issuerBalanceAfterMint).toEqual(tokenAmount);
+      const userWalletPublicKey = await userWallet.getSparkAddress();
 
-    const userWalletPublicKey = await userWallet.getSparkAddress();
+      await issuerWallet.transferTokens({
+        tokenAmount,
+        tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
+        receiverSparkAddress: userWalletPublicKey,
+      });
 
-    await issuerWallet.transferTokens({
-      tokenAmount,
-      tokenPublicKey,
-      receiverSparkAddress: userWalletPublicKey,
-    });
+      const issuerBalanceAfterTransfer = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterTransfer).toEqual(0n);
+      const tokenPublicKeyHex = await issuerWallet.getIdentityPublicKey();
+      const userWalletPublicKeyHex = await userWallet.getSparkAddress();
+      const userBalanceObj = await userWallet.getBalance();
+      const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
+        userBalanceObj?.tokenBalances,
+        tokenPublicKeyHex,
+      );
+      expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
+      await userWallet.transferTokens({
+        tokenPublicKey: tokenPublicKeyHex,
+        tokenAmount,
+        receiverSparkAddress: await issuerWallet.getSparkAddress(),
+      });
 
-    const issuerBalanceAfterTransfer = (
-      await issuerWallet.getIssuerTokenBalance()
-    ).balance;
-    expect(issuerBalanceAfterTransfer).toEqual(0n);
+      const userBalanceObjAfterTransferBack = await userWallet.getBalance();
+      const userBalanceAfterTransferBack = filterTokenBalanceForTokenPublicKey(
+        userBalanceObjAfterTransferBack?.tokenBalances,
+        tokenPublicKeyHex,
+      );
+
+      expect(userBalanceAfterTransferBack.balance).toEqual(0n);
+
+      const issuerTokenBalance = (await issuerWallet.getIssuerTokenBalance())
+        .balance;
+      expect(issuerTokenBalance).toEqual(tokenAmount);
+      await issuerWallet.burnTokens(tokenAmount);
+      const issuerTokenBalanceAfterBurn = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerTokenBalanceAfterBurn).toEqual(0n);
+    },
+  );
+
+  brokenTestFn(
+    "mint, transfer to user, user transfer to issuer, burn with Schnorr",
+    async () => {
+      const tokenAmount: bigint = 1000n;
+
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: LOCAL_WALLET_CONFIG_SCHNORR,
+        });
+
+      const { wallet: userWallet } = await SparkWalletTesting.initialize({
+        options: LOCAL_WALLET_CONFIG_SCHNORR,
+      });
 
-    const tokenPublicKeyHex = await issuerWallet.getIdentityPublicKey();
-    const userBalanceObj = await userWallet.getBalance();
-    const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
-      userBalanceObj?.tokenBalances,
-      tokenPublicKeyHex,
-    );
-    expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
+      const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
+      await issuerWallet.mintTokens(tokenAmount);
 
-    await userWallet.transferTokens({
-      tokenPublicKey: tokenPublicKeyHex,
-      tokenAmount,
-      receiverSparkAddress: await issuerWallet.getSparkAddress(),
-    });
+      const issuerBalanceAfterMint = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterMint).toEqual(tokenAmount);
 
-    const userBalanceObjAfterTransferBack = await userWallet.getBalance();
-    const userBalanceAfterTransferBack = filterTokenBalanceForTokenPublicKey(
-      userBalanceObjAfterTransferBack?.tokenBalances,
-      tokenPublicKeyHex,
-    );
-    expect(userBalanceAfterTransferBack.balance).toEqual(0n);
+      const userWalletPublicKey = await userWallet.getSparkAddress();
 
-    const issuerTokenBalance = (await issuerWallet.getIssuerTokenBalance())
-      .balance;
-    expect(issuerTokenBalance).toEqual(tokenAmount);
+      await issuerWallet.transferTokens({
+        tokenAmount,
+        tokenPublicKey,
+        receiverSparkAddress: userWalletPublicKey,
+      });
 
-    await issuerWallet.burnTokens(tokenAmount);
+      const issuerBalanceAfterTransfer = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterTransfer).toEqual(0n);
+
+      const tokenPublicKeyHex = await issuerWallet.getIdentityPublicKey();
+      const userBalanceObj = await userWallet.getBalance();
+      const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
+        userBalanceObj?.tokenBalances,
+        tokenPublicKeyHex,
+      );
+      expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
+
+      await userWallet.transferTokens({
+        tokenPublicKey: tokenPublicKeyHex,
+        tokenAmount,
+        receiverSparkAddress: await issuerWallet.getSparkAddress(),
+      });
 
-    const issuerTokenBalanceAfterBurn = (
-      await issuerWallet.getIssuerTokenBalance()
-    ).balance;
-    expect(issuerTokenBalanceAfterBurn).toEqual(0n);
-  });
+      const userBalanceObjAfterTransferBack = await userWallet.getBalance();
+      const userBalanceAfterTransferBack = filterTokenBalanceForTokenPublicKey(
+        userBalanceObjAfterTransferBack?.tokenBalances,
+        tokenPublicKeyHex,
+      );
+      expect(userBalanceAfterTransferBack.balance).toEqual(0n);
+
+      const issuerTokenBalance = (await issuerWallet.getIssuerTokenBalance())
+        .balance;
+      expect(issuerTokenBalance).toEqual(tokenAmount);
+
+      await issuerWallet.burnTokens(tokenAmount);
+
+      const issuerTokenBalanceAfterBurn = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerTokenBalanceAfterBurn).toEqual(0n);
+    },
+  );
 });

package/src/tests/utils/issuer-test-wallet.ts

@@ -0,0 +1,31 @@
+import { SparkWalletProps } from "@buildonspark/spark-sdk";
+import { IssuerSparkWallet } from "../../issuer-spark-wallet.js";
+
+export class IssuerSparkWalletTesting extends IssuerSparkWallet {
+  private disableEvents: boolean;
+
+  constructor(props: SparkWalletProps, disableEvents = true) {
+    super(props.options);
+    this.disableEvents = disableEvents;
+  }
+
+  static async initialize(props: SparkWalletProps): Promise<{
+    mnemonic?: string;
+    wallet: IssuerSparkWalletTesting;
+  }> {
+    const wallet = new IssuerSparkWalletTesting(props, true);
+
+    const result = await wallet.initWallet(props.mnemonicOrSeed);
+    return {
+      wallet,
+      mnemonic: result?.mnemonic,
+    };
+  }
+
+  protected override async setupBackgroundStream() {
+    if (!this.disableEvents) {
+      return super.setupBackgroundStream();
+    }
+    return;
+  }
+}

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

@@ -0,0 +1,64 @@
+import { SparkWallet, SparkWalletProps } from "@buildonspark/spark-sdk";
+import {
+  QueryTransfersResponse,
+  Transfer,
+} from "@buildonspark/spark-sdk/proto/spark";
+import { ConfigOptions } from "@buildonspark/spark-sdk/services/wallet-config";
+import { SparkSigner } from "@buildonspark/spark-sdk/signer";
+
+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,
+    );
+
+    const initResponse = await wallet.initWallet(props.mnemonicOrSeed);
+    return {
+      wallet,
+      mnemonic: initResponse?.mnemonic,
+    };
+  }
+
+  protected override async setupBackgroundStream() {
+    if (!this.disableEvents) {
+      await super.setupBackgroundStream();
+    }
+    return;
+  }
+
+  public getSigner(): SparkSigner {
+    return this.config.signer;
+  }
+
+  public async queryPendingTransfers(): Promise<QueryTransfersResponse> {
+    return await this.transferService.queryPendingTransfers();
+  }
+
+  public async verifyPendingTransfer(
+    transfer: Transfer,
+  ): Promise<Map<string, Uint8Array>> {
+    return await this.transferService.verifyPendingTransfer(transfer);
+  }
+}