@buildonspark/issuer-sdk 0.0.96 → 0.0.97

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @buildonspark/issuer-sdk
 
+## 0.0.97
+
+### Patch Changes
+
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.3.4
+
 ## 0.0.96
 
 ### Patch Changes

package/dist/{chunk-HQI3Y4QH.js → chunk-GKBNEYTU.js}

@@ -153,26 +153,6 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
   constructor(config, connectionManager) {
     super(config, connectionManager);
   }
-  async constructMintTokenTransactionV0(tokenPublicKey, tokenAmount) {
-    return {
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "mintInput",
-        mintInput: {
-          issuerPublicKey: tokenPublicKey,
-          issuerProvidedTimestamp: Date.now()
-        }
-      },
-      tokenOutputs: [
-        {
-          ownerPublicKey: tokenPublicKey,
-          tokenPublicKey,
-          tokenAmount: numberToBytesBE(tokenAmount, 16)
-        }
-      ],
-      sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys()
-    };
-  }
   async constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
     return {
       version: 2,
@@ -472,23 +452,15 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
    * @returns The transaction ID of the mint operation
    */
   async mintTokens(tokenAmount) {
-    let tokenTransaction;
     const issuerTokenPublicKey = await super.getIdentityPublicKey();
     const issuerTokenPublicKeyBytes = hexToBytes2(issuerTokenPublicKey);
     const tokenMetadata = await this.getIssuerTokenMetadata();
     const rawTokenIdentifier = tokenMetadata.rawTokenIdentifier;
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransactionV0(
-        issuerTokenPublicKeyBytes,
-        tokenAmount
-      );
-    } else {
-      tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-        rawTokenIdentifier,
-        issuerTokenPublicKeyBytes,
-        tokenAmount
-      );
-    }
+    const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
+      rawTokenIdentifier,
+      issuerTokenPublicKeyBytes,
+      tokenAmount
+    );
     return await this.issuerTokenTransactionService.broadcastTokenTransaction(
       tokenTransaction
     );

package/dist/index.cjs

@@ -175,26 +175,6 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
   constructor(config, connectionManager) {
     super(config, connectionManager);
   }
-  async constructMintTokenTransactionV0(tokenPublicKey, tokenAmount) {
-    return {
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "mintInput",
-        mintInput: {
-          issuerPublicKey: tokenPublicKey,
-          issuerProvidedTimestamp: Date.now()
-        }
-      },
-      tokenOutputs: [
-        {
-          ownerPublicKey: tokenPublicKey,
-          tokenPublicKey,
-          tokenAmount: (0, import_utils3.numberToBytesBE)(tokenAmount, 16)
-        }
-      ],
-      sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys()
-    };
-  }
   async constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
     return {
       version: 2,
@@ -494,23 +474,15 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
    * @returns The transaction ID of the mint operation
    */
   async mintTokens(tokenAmount) {
-    let tokenTransaction;
     const issuerTokenPublicKey = await super.getIdentityPublicKey();
     const issuerTokenPublicKeyBytes = (0, import_utils4.hexToBytes)(issuerTokenPublicKey);
     const tokenMetadata = await this.getIssuerTokenMetadata();
     const rawTokenIdentifier = tokenMetadata.rawTokenIdentifier;
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransactionV0(
-        issuerTokenPublicKeyBytes,
-        tokenAmount
-      );
-    } else {
-      tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-        rawTokenIdentifier,
-        issuerTokenPublicKeyBytes,
-        tokenAmount
-      );
-    }
+    const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
+      rawTokenIdentifier,
+      issuerTokenPublicKeyBytes,
+      tokenAmount
+    );
     return await this.issuerTokenTransactionService.broadcastTokenTransaction(
       tokenTransaction
     );

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   IssuerSparkWallet
-} from "./chunk-HQI3Y4QH.js";
+} from "./chunk-GKBNEYTU.js";
 import "./chunk-7B4B24XF.js";
 
 // src/issuer-wallet/issuer-spark-wallet.browser.ts

package/dist/index.node.cjs

@@ -175,26 +175,6 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
   constructor(config, connectionManager) {
     super(config, connectionManager);
   }
-  async constructMintTokenTransactionV0(tokenPublicKey, tokenAmount) {
-    return {
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "mintInput",
-        mintInput: {
-          issuerPublicKey: tokenPublicKey,
-          issuerProvidedTimestamp: Date.now()
-        }
-      },
-      tokenOutputs: [
-        {
-          ownerPublicKey: tokenPublicKey,
-          tokenPublicKey,
-          tokenAmount: (0, import_utils3.numberToBytesBE)(tokenAmount, 16)
-        }
-      ],
-      sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys()
-    };
-  }
   async constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
     return {
       version: 2,
@@ -494,23 +474,15 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
    * @returns The transaction ID of the mint operation
    */
   async mintTokens(tokenAmount) {
-    let tokenTransaction;
     const issuerTokenPublicKey = await super.getIdentityPublicKey();
     const issuerTokenPublicKeyBytes = (0, import_utils4.hexToBytes)(issuerTokenPublicKey);
     const tokenMetadata = await this.getIssuerTokenMetadata();
     const rawTokenIdentifier = tokenMetadata.rawTokenIdentifier;
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransactionV0(
-        issuerTokenPublicKeyBytes,
-        tokenAmount
-      );
-    } else {
-      tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-        rawTokenIdentifier,
-        issuerTokenPublicKeyBytes,
-        tokenAmount
-      );
-    }
+    const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
+      rawTokenIdentifier,
+      issuerTokenPublicKeyBytes,
+      tokenAmount
+    );
     return await this.issuerTokenTransactionService.broadcastTokenTransaction(
       tokenTransaction
     );

package/dist/index.node.js

@@ -1,6 +1,6 @@
 import {
   IssuerSparkWallet
-} from "./chunk-HQI3Y4QH.js";
+} from "./chunk-GKBNEYTU.js";
 import "./chunk-7B4B24XF.js";
 
 // src/issuer-wallet/issuer-spark-wallet.node.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/issuer-sdk",
-  "version": "0.0.96",
+  "version": "0.0.97",
   "description": "Spark Issuer SDK for token issuance",
   "license": "Apache-2.0",
   "module": "./dist/index.js",
@@ -72,7 +72,7 @@
     "types": "tsc"
   },
   "dependencies": {
-    "@buildonspark/spark-sdk": "0.3.3",
+    "@buildonspark/spark-sdk": "0.3.4",
     "@noble/curves": "^1.8.0",
     "@scure/btc-signer": "^1.5.0",
     "buffer": "^6.0.3"

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

@@ -12,11 +12,7 @@ import {
   ValidationError,
   type ConfigOptions,
 } from "@buildonspark/spark-sdk";
-import {
-  OutputWithPreviousTransactionData,
-  TokenTransaction as TokenTransactionV0,
-} from "@buildonspark/spark-sdk/proto/spark";
-import { TokenTransaction } from "@buildonspark/spark-sdk/proto/spark_token";
+import { OutputWithPreviousTransactionData } from "@buildonspark/spark-sdk/proto/spark";
 import { bytesToHex, bytesToNumberBE, hexToBytes } from "@noble/curves/utils";
 import { TokenFreezeService } from "../services/freeze.js";
 import { IssuerTokenTransactionService } from "../services/token-transactions.js";
@@ -241,27 +237,18 @@ export class IssuerSparkWallet extends SparkWallet {
    * @returns The transaction ID of the mint operation
    */
   public async mintTokens(tokenAmount: bigint): Promise<string> {
-    let tokenTransaction: TokenTransactionV0 | TokenTransaction;
     const issuerTokenPublicKey = await super.getIdentityPublicKey();
     const issuerTokenPublicKeyBytes = hexToBytes(issuerTokenPublicKey);
 
     const tokenMetadata = await this.getIssuerTokenMetadata();
     const rawTokenIdentifier: Uint8Array = tokenMetadata.rawTokenIdentifier;
 
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      tokenTransaction =
-        await this.issuerTokenTransactionService.constructMintTokenTransactionV0(
-          issuerTokenPublicKeyBytes,
-          tokenAmount,
-        );
-    } else {
-      tokenTransaction =
-        await this.issuerTokenTransactionService.constructMintTokenTransaction(
-          rawTokenIdentifier,
-          issuerTokenPublicKeyBytes,
-          tokenAmount,
-        );
-    }
+    const tokenTransaction =
+      await this.issuerTokenTransactionService.constructMintTokenTransaction(
+        rawTokenIdentifier,
+        issuerTokenPublicKeyBytes,
+        tokenAmount,
+      );
 
     return await this.issuerTokenTransactionService.broadcastTokenTransaction(
       tokenTransaction,

package/src/services/token-transactions.ts

@@ -3,7 +3,6 @@ import {
   WalletConfigService,
   type ConnectionManager,
 } from "@buildonspark/spark-sdk";
-import { TokenTransaction as TokenTransactionV0 } from "@buildonspark/spark-sdk/proto/spark";
 import { TokenTransaction } from "@buildonspark/spark-sdk/proto/spark_token";
 import { numberToBytesBE } from "@noble/curves/utils";
 
@@ -15,31 +14,6 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
     super(config, connectionManager);
   }
 
-  async constructMintTokenTransactionV0(
-    tokenPublicKey: Uint8Array,
-    tokenAmount: bigint,
-  ): Promise<TokenTransactionV0> {
-    return {
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "mintInput",
-        mintInput: {
-          issuerPublicKey: tokenPublicKey,
-          issuerProvidedTimestamp: Date.now(),
-        },
-      },
-      tokenOutputs: [
-        {
-          ownerPublicKey: tokenPublicKey,
-          tokenPublicKey: tokenPublicKey,
-          tokenAmount: numberToBytesBE(tokenAmount, 16),
-        },
-      ],
-      sparkOperatorIdentityPublicKeys:
-        super.collectOperatorIdentityPublicKeys(),
-    };
-  }
-
   async constructMintTokenTransaction(
     rawTokenIdentifierBytes: Uint8Array,
     issuerTokenPublicKey: Uint8Array,

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

@@ -5,40 +5,25 @@ import {
   WalletConfig,
 } from "@buildonspark/spark-sdk";
 import { jest } from "@jest/globals";
-import { hexToBytes, bytesToHex } from "@noble/curves/utils";
+import { bytesToHex } from "@noble/curves/utils";
 import { IssuerSparkWalletTesting } from "../utils/issuer-test-wallet.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { BitcoinFaucet } from "@buildonspark/spark-sdk/test-utils";
+import { InvoiceStatus } from "@buildonspark/spark-sdk/proto/spark";
 
-export const TOKENS_V0_SCHNORR_CONFIG: Required<ConfigOptions> = {
+export const TOKENS_SCHNORR_CONFIG: Required<ConfigOptions> = {
   ...WalletConfig.LOCAL,
-  tokenTransactionVersion: "V0",
   tokenSignatures: "SCHNORR",
 };
 
-export const TOKENS_V1_SCHNORR_CONFIG: Required<ConfigOptions> = {
-  ...WalletConfig.LOCAL,
-  tokenTransactionVersion: "V1",
-  tokenSignatures: "SCHNORR",
-};
-
-export const TOKENS_V0_ECDSA_CONFIG: Required<ConfigOptions> = {
-  ...WalletConfig.LOCAL,
-  tokenSignatures: "ECDSA",
-  tokenTransactionVersion: "V0",
-};
-
-export const TOKENS_V1_ECDSA_CONFIG: Required<ConfigOptions> = {
+export const TOKENS_ECDSA_CONFIG: Required<ConfigOptions> = {
   ...WalletConfig.LOCAL,
   tokenSignatures: "ECDSA",
-  tokenTransactionVersion: "V1",
 };
 
 const TEST_CONFIGS = [
-  { name: "TV0E", config: TOKENS_V0_ECDSA_CONFIG },
-  { name: "TV0S", config: TOKENS_V0_SCHNORR_CONFIG },
-  { name: "TV1E", config: TOKENS_V1_ECDSA_CONFIG },
-  { name: "TV1S", config: TOKENS_V1_SCHNORR_CONFIG },
+  { name: "TE", config: TOKENS_ECDSA_CONFIG },
+  { name: "TS", config: TOKENS_SCHNORR_CONFIG },
 ];
 
 const brokenTestFn = process.env.GITHUB_ACTIONS ? it.skip : it;
@@ -198,8 +183,10 @@ describe.each(TEST_CONFIGS)(
       expect(userBalance.balance).toBeGreaterThanOrEqual(tokenAmount);
     });
 
-    const tv1It = name.startsWith("TV1") ? it.skip : it.skip;
-    tv1It("should transfer tokens using spark invoices", async () => {
+    // const tv1It = name.startsWith("TV1") ? it.skip : it.skip;
+    // TODO: (CNT-493) Re-enable invoice functionality once spark address migration is complete
+    const skipInvoiceTest = it.skip;
+    skipInvoiceTest("should transfer tokens using spark invoices", async () => {
       const tokenAmount: bigint = 777n;
       const initialIssuerBalance = 100000n;
 
@@ -254,201 +241,217 @@ describe.each(TEST_CONFIGS)(
       expect(receiverBalance.balance).toEqual(tokenAmount);
     });
 
-    tv1It("should transfer tokens using multiple spark invoices", async () => {
-      const amount1: bigint = 111n;
-      const amount2: bigint = 222n;
-      const amount3: bigint = 333n;
-      const totalAmount: bigint = amount1 + amount2 + amount3;
-      const initialIssuerBalance = 100000n;
+    skipInvoiceTest(
+      "should transfer tokens using multiple spark invoices",
+      async () => {
+        const amount1: bigint = 111n;
+        const amount2: bigint = 222n;
+        const amount3: bigint = 333n;
+        const totalAmount: bigint = amount1 + amount2 + amount3;
+        const initialIssuerBalance = 100000n;
 
-      const { wallet: issuerWallet } =
-        await IssuerSparkWalletTesting.initialize({
-          options: config,
-        });
-      const { wallet: receiverWallet1 } = await SparkWalletTesting.initialize({
-        options: config,
-      });
-      const { wallet: receiverWallet2 } = await SparkWalletTesting.initialize({
-        options: config,
-      });
+        const { wallet: issuerWallet } =
+          await IssuerSparkWalletTesting.initialize({
+            options: config,
+          });
+        const { wallet: receiverWallet1 } = await SparkWalletTesting.initialize(
+          {
+            options: config,
+          },
+        );
+        const { wallet: receiverWallet2 } = await SparkWalletTesting.initialize(
+          {
+            options: config,
+          },
+        );
 
-      await issuerWallet.createToken({
-        tokenName: `${name}INVM`,
-        tokenTicker: "INM",
-        decimals: 0,
-        isFreezable: false,
-        maxSupply: 1_000_000n,
-      });
+        await issuerWallet.createToken({
+          tokenName: `${name}INVM`,
+          tokenTicker: "INM",
+          decimals: 0,
+          isFreezable: false,
+          maxSupply: 1_000_000n,
+        });
 
-      await issuerWallet.mintTokens(initialIssuerBalance);
+        await issuerWallet.mintTokens(initialIssuerBalance);
 
-      const issuerBalanceAfterMint = await issuerWallet.getIssuerTokenBalance();
-      expect(issuerBalanceAfterMint).toBeDefined();
-      expect(issuerBalanceAfterMint.balance).toBe(initialIssuerBalance);
-      const tokenIdentifier = issuerBalanceAfterMint.tokenIdentifier!;
-      const issuerBalanceBeforeTransfer = issuerBalanceAfterMint.balance;
+        const issuerBalanceAfterMint =
+          await issuerWallet.getIssuerTokenBalance();
+        expect(issuerBalanceAfterMint).toBeDefined();
+        expect(issuerBalanceAfterMint.balance).toBe(initialIssuerBalance);
+        const tokenIdentifier = issuerBalanceAfterMint.tokenIdentifier!;
+        const issuerBalanceBeforeTransfer = issuerBalanceAfterMint.balance;
 
-      const invoice1 = await receiverWallet1.createTokensInvoice({
-        amount: amount1,
-        tokenIdentifier,
-        memo: "Invoice #1",
-        expiryTime: new Date(Date.now() + 1000 * 60 * 60 * 24),
-      });
+        const invoice1 = await receiverWallet1.createTokensInvoice({
+          amount: amount1,
+          tokenIdentifier,
+          memo: "Invoice #1",
+          expiryTime: new Date(Date.now() + 1000 * 60 * 60 * 24),
+        });
 
-      const invoice2 = await receiverWallet1.createTokensInvoice({
-        amount: amount2,
-        tokenIdentifier,
-        memo: "Invoice #2",
-        expiryTime: new Date(Date.now() + 1000 * 60 * 60 * 24),
-      });
+        const invoice2 = await receiverWallet1.createTokensInvoice({
+          amount: amount2,
+          tokenIdentifier,
+          memo: "Invoice #2",
+          expiryTime: new Date(Date.now() + 1000 * 60 * 60 * 24),
+        });
 
-      const invoice3 = await receiverWallet2.createTokensInvoice({
-        amount: amount3,
-        tokenIdentifier,
-        memo: "Invoice #3",
-        expiryTime: new Date(Date.now() + 1000 * 60 * 60 * 24),
-      });
+        const invoice3 = await receiverWallet2.createTokensInvoice({
+          amount: amount3,
+          tokenIdentifier,
+          memo: "Invoice #3",
+          expiryTime: new Date(Date.now() + 1000 * 60 * 60 * 24),
+        });
 
-      const { tokenTransactionSuccess } =
-        await issuerWallet.fulfillSparkInvoice([
-          { invoice: invoice1 },
-          { invoice: invoice2 },
-          { invoice: invoice3 },
-        ]);
-      expect(tokenTransactionSuccess.length).toBe(1);
-      expect(tokenTransactionSuccess[0].txid).toBeDefined();
-      expect(tokenTransactionSuccess[0].txid.length).toBeGreaterThan(0);
+        const { tokenTransactionSuccess } =
+          await issuerWallet.fulfillSparkInvoice([
+            { invoice: invoice1 },
+            { invoice: invoice2 },
+            { invoice: invoice3 },
+          ]);
+        expect(tokenTransactionSuccess.length).toBe(1);
+        expect(tokenTransactionSuccess[0].txid).toBeDefined();
+        expect(tokenTransactionSuccess[0].txid.length).toBeGreaterThan(0);
 
-      const issuerBalanceAfter = (await issuerWallet.getIssuerTokenBalance())
-        .balance;
-      expect(issuerBalanceAfter).toEqual(
-        issuerBalanceBeforeTransfer - totalAmount,
-      );
+        const issuerBalanceAfter = (await issuerWallet.getIssuerTokenBalance())
+          .balance;
+        expect(issuerBalanceAfter).toEqual(
+          issuerBalanceBeforeTransfer - totalAmount,
+        );
 
-      const receiver1BalanceObj = await receiverWallet1.getBalance();
-      const receiver1Balance = filterTokenBalanceForTokenIdentifier(
-        receiver1BalanceObj?.tokenBalances,
-        tokenIdentifier!,
-      );
-      expect(receiver1Balance.balance).toEqual(amount1 + amount2);
+        const receiver1BalanceObj = await receiverWallet1.getBalance();
+        const receiver1Balance = filterTokenBalanceForTokenIdentifier(
+          receiver1BalanceObj?.tokenBalances,
+          tokenIdentifier!,
+        );
+        expect(receiver1Balance.balance).toEqual(amount1 + amount2);
 
-      const receiver2BalanceObj = await receiverWallet2.getBalance();
-      const receiver2Balance = filterTokenBalanceForTokenIdentifier(
-        receiver2BalanceObj?.tokenBalances,
-        tokenIdentifier!,
-      );
-      expect(receiver2Balance.balance).toEqual(amount3);
-    });
+        const receiver2BalanceObj = await receiverWallet2.getBalance();
+        const receiver2Balance = filterTokenBalanceForTokenIdentifier(
+          receiver2BalanceObj?.tokenBalances,
+          tokenIdentifier!,
+        );
+        expect(receiver2Balance.balance).toEqual(amount3);
+      },
+    );
 
-    tv1It("should fail to fulfill an expired spark invoice", async () => {
-      const tokenAmount: bigint = 123n;
-      const initialIssuerBalance = 100000n;
+    skipInvoiceTest(
+      "should fail to fulfill an expired spark invoice",
+      async () => {
+        const tokenAmount: bigint = 123n;
+        const initialIssuerBalance = 100000n;
 
-      const { wallet: issuerWallet } =
-        await IssuerSparkWalletTesting.initialize({
+        const { wallet: issuerWallet } =
+          await IssuerSparkWalletTesting.initialize({
+            options: config,
+          });
+        const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
           options: config,
         });
-      const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
-        options: config,
-      });
 
-      await issuerWallet.createToken({
-        tokenName: `${name}INVEXP`,
-        tokenTicker: "INVX",
-        decimals: 0,
-        isFreezable: false,
-        maxSupply: 1_000_000n,
-      });
+        await issuerWallet.createToken({
+          tokenName: `${name}INVEXP`,
+          tokenTicker: "INVX",
+          decimals: 0,
+          isFreezable: false,
+          maxSupply: 1_000_000n,
+        });
 
-      await issuerWallet.mintTokens(initialIssuerBalance);
+        await issuerWallet.mintTokens(initialIssuerBalance);
 
-      const issuerBalanceAfterMint = await issuerWallet.getIssuerTokenBalance();
-      expect(issuerBalanceAfterMint).toBeDefined();
-      expect(issuerBalanceAfterMint.balance).toBe(initialIssuerBalance);
-      const tokenIdentifier = issuerBalanceAfterMint.tokenIdentifier!;
-      const issuerBalanceBefore = issuerBalanceAfterMint.balance;
+        const issuerBalanceAfterMint =
+          await issuerWallet.getIssuerTokenBalance();
+        expect(issuerBalanceAfterMint).toBeDefined();
+        expect(issuerBalanceAfterMint.balance).toBe(initialIssuerBalance);
+        const tokenIdentifier = issuerBalanceAfterMint.tokenIdentifier!;
+        const issuerBalanceBefore = issuerBalanceAfterMint.balance;
 
-      const expiredInvoice = await receiverWallet.createTokensInvoice({
-        amount: tokenAmount,
-        tokenIdentifier,
-        memo: "Expired invoice",
-        expiryTime: new Date(Date.now() - 60_000),
-      });
+        const expiredInvoice = await receiverWallet.createTokensInvoice({
+          amount: tokenAmount,
+          tokenIdentifier,
+          memo: "Expired invoice",
+          expiryTime: new Date(Date.now() - 60_000),
+        });
 
-      const { invalidInvoices } = await issuerWallet.fulfillSparkInvoice([
-        { invoice: expiredInvoice },
-      ]);
-      expect(invalidInvoices.length).toBe(1);
-      expect(invalidInvoices[0].invoice).toBe(expiredInvoice);
+        const { invalidInvoices } = await issuerWallet.fulfillSparkInvoice([
+          { invoice: expiredInvoice },
+        ]);
+        expect(invalidInvoices.length).toBe(1);
+        expect(invalidInvoices[0].invoice).toBe(expiredInvoice);
 
-      const issuerBalanceAfter = (await issuerWallet.getIssuerTokenBalance())
-        .balance;
-      expect(issuerBalanceAfter).toEqual(issuerBalanceBefore);
+        const issuerBalanceAfter = (await issuerWallet.getIssuerTokenBalance())
+          .balance;
+        expect(issuerBalanceAfter).toEqual(issuerBalanceBefore);
 
-      const receiverBalanceObj = await receiverWallet.getBalance();
-      const receiverBalance = filterTokenBalanceForTokenIdentifier(
-        receiverBalanceObj?.tokenBalances,
-        tokenIdentifier!,
-      );
-      expect(receiverBalance.balance).toEqual(0n);
-    });
+        const receiverBalanceObj = await receiverWallet.getBalance();
+        const receiverBalance = filterTokenBalanceForTokenIdentifier(
+          receiverBalanceObj?.tokenBalances,
+          tokenIdentifier!,
+        );
+        expect(receiverBalance.balance).toEqual(0n);
+      },
+    );
 
-    tv1It("should fulfill a spark invoice with null expiry", async () => {
-      const tokenAmount: bigint = 321n;
-      const initialIssuerBalance = 100000n;
+    skipInvoiceTest(
+      "should fulfill a spark invoice with null expiry",
+      async () => {
+        const tokenAmount: bigint = 321n;
+        const initialIssuerBalance = 100000n;
 
-      const { wallet: issuerWallet } =
-        await IssuerSparkWalletTesting.initialize({
+        const { wallet: issuerWallet } =
+          await IssuerSparkWalletTesting.initialize({
+            options: config,
+          });
+        const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
           options: config,
         });
-      const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
-        options: config,
-      });
 
-      await issuerWallet.createToken({
-        tokenName: `${name}INVNULL`,
-        tokenTicker: "INVN",
-        decimals: 0,
-        isFreezable: false,
-        maxSupply: 1_000_000n,
-      });
+        await issuerWallet.createToken({
+          tokenName: `${name}INVNULL`,
+          tokenTicker: "INVN",
+          decimals: 0,
+          isFreezable: false,
+          maxSupply: 1_000_000n,
+        });
 
-      await issuerWallet.mintTokens(initialIssuerBalance);
+        await issuerWallet.mintTokens(initialIssuerBalance);
 
-      const issuerBalanceAfterMint = await issuerWallet.getIssuerTokenBalance();
-      expect(issuerBalanceAfterMint).toBeDefined();
-      expect(issuerBalanceAfterMint.balance).toBe(initialIssuerBalance);
-      const tokenIdentifier = issuerBalanceAfterMint.tokenIdentifier!;
-      const issuerBalanceBefore = issuerBalanceAfterMint.balance;
+        const issuerBalanceAfterMint =
+          await issuerWallet.getIssuerTokenBalance();
+        expect(issuerBalanceAfterMint).toBeDefined();
+        expect(issuerBalanceAfterMint.balance).toBe(initialIssuerBalance);
+        const tokenIdentifier = issuerBalanceAfterMint.tokenIdentifier!;
+        const issuerBalanceBefore = issuerBalanceAfterMint.balance;
 
-      const nullExpiryInvoice = await receiverWallet.createTokensInvoice({
-        amount: tokenAmount,
-        tokenIdentifier,
-        memo: "Null expiry invoice",
-        expiryTime: null as unknown as Date,
-      });
+        const nullExpiryInvoice = await receiverWallet.createTokensInvoice({
+          amount: tokenAmount,
+          tokenIdentifier,
+          memo: "Null expiry invoice",
+          expiryTime: null as unknown as Date,
+        });
 
-      const { tokenTransactionSuccess } =
-        await issuerWallet.fulfillSparkInvoice([
-          { invoice: nullExpiryInvoice },
-        ]);
-      expect(tokenTransactionSuccess.length).toBe(1);
-      expect(tokenTransactionSuccess[0].txid).toBeDefined();
-      expect(tokenTransactionSuccess[0].txid.length).toBeGreaterThan(0);
+        const { tokenTransactionSuccess } =
+          await issuerWallet.fulfillSparkInvoice([
+            { invoice: nullExpiryInvoice },
+          ]);
+        expect(tokenTransactionSuccess.length).toBe(1);
+        expect(tokenTransactionSuccess[0].txid).toBeDefined();
+        expect(tokenTransactionSuccess[0].txid.length).toBeGreaterThan(0);
 
-      const issuerBalanceAfter = (await issuerWallet.getIssuerTokenBalance())
-        .balance;
-      expect(issuerBalanceAfter).toEqual(issuerBalanceBefore - tokenAmount);
+        const issuerBalanceAfter = (await issuerWallet.getIssuerTokenBalance())
+          .balance;
+        expect(issuerBalanceAfter).toEqual(issuerBalanceBefore - tokenAmount);
 
-      const receiverBalanceObj = await receiverWallet.getBalance();
-      const receiverBalance = filterTokenBalanceForTokenIdentifier(
-        receiverBalanceObj?.tokenBalances,
-        tokenIdentifier!,
-      );
-      expect(receiverBalance.balance).toEqual(tokenAmount);
-    });
+        const receiverBalanceObj = await receiverWallet.getBalance();
+        const receiverBalance = filterTokenBalanceForTokenIdentifier(
+          receiverBalanceObj?.tokenBalances,
+          tokenIdentifier!,
+        );
+        expect(receiverBalance.balance).toEqual(tokenAmount);
+      },
+    );
 
-    tv1It(
+    skipInvoiceTest(
       "should fulfill a tokens invoice without amount by passing amount parameter",
       async () => {
         const tokenAmount: bigint = 555n;
@@ -508,7 +511,7 @@ describe.each(TEST_CONFIGS)(
       },
     );
 
-    tv1It(
+    skipInvoiceTest(
       `fulfillSparkInvoice successfully handles multiple mixed tokens and sats invoices`,
       async () => {
         const faucet = BitcoinFaucet.getInstance();
@@ -639,6 +642,26 @@ describe.each(TEST_CONFIGS)(
         expect(tokenTransactionSuccess.length).toBe(2); // two token assets - divided into two token transactions
         expect(tokenTransactionErrors.length).toBe(0);
         expect(invalidInvoices.length).toBe(0);
+        const invoicesToQuery = [
+          invoice1000,
+          invoice2000,
+          invoiceNilAmount,
+          sdkOneTokenInvoiceA,
+          sdkOneTokenInvoiceB,
+          sdkTwoTokenInvoiceA,
+          sdkTwoTokenNilAmountInvoiceB,
+        ];
+        const queryInvoiceResponse = await (sdk as any).querySparkInvoices(
+          invoicesToQuery,
+        );
+        expect(queryInvoiceResponse.invoiceStatuses.length).toBe(7);
+        for (let i = 0; i < queryInvoiceResponse.invoiceStatuses.length; i++) {
+          const response = queryInvoiceResponse.invoiceStatuses[i];
+          const invoiceStatus = response.status;
+          expect(invoiceStatus).toBeDefined();
+          expect(invoiceStatus).toBe(InvoiceStatus.FINALIZED);
+          expect(response.invoice).toBe(invoicesToQuery[i]);
+        }
       },
     );