@buildonspark/issuer-sdk 0.0.86 → 0.0.87

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @buildonspark/issuer-sdk
 
+## 0.0.87
+
+### Patch Changes
+
+- -- Added spark invoice support for token transfers
+  -- Added support for initialization SparkWallet with pre-existing keys
+  -- Return bare info in x-client-env
+  -- Improved test coverage for multiple coordinators
+  -- Improved retry mechanism for transfer claim
+  -- Improved error handling for alreaday exists
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.2.8
+
 ## 0.0.86
 
 ### Patch Changes

package/dist/{chunk-NRKE2XKD.js → chunk-ZMLVOUPB.js}

@@ -177,7 +177,7 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
   }
   async constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
     return {
-      version: 1,
+      version: 2,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "mintInput",
@@ -195,12 +195,13 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
       ],
       clientCreatedTimestamp: /* @__PURE__ */ new Date(),
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
-      expiryTime: void 0
+      expiryTime: void 0,
+      invoiceAttachments: []
     };
   }
   async constructCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable) {
     return {
-      version: 1,
+      version: 2,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "createInput",
@@ -216,7 +217,8 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
       tokenOutputs: [],
       clientCreatedTimestamp: /* @__PURE__ */ new Date(),
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
-      expiryTime: void 0
+      expiryTime: void 0,
+      invoiceAttachments: []
     };
   }
 };
@@ -315,6 +317,12 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
   }) {
     const wallet = new _IssuerSparkWallet(options, signer);
     wallet.initializeTracer(wallet);
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+      return {
+        wallet
+      };
+    }
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
     return {
       wallet,

package/dist/index.cjs

@@ -199,7 +199,7 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
   }
   async constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
     return {
-      version: 1,
+      version: 2,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "mintInput",
@@ -217,12 +217,13 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
       ],
       clientCreatedTimestamp: /* @__PURE__ */ new Date(),
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
-      expiryTime: void 0
+      expiryTime: void 0,
+      invoiceAttachments: []
     };
   }
   async constructCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable) {
     return {
-      version: 1,
+      version: 2,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "createInput",
@@ -238,7 +239,8 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
       tokenOutputs: [],
       clientCreatedTimestamp: /* @__PURE__ */ new Date(),
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
-      expiryTime: void 0
+      expiryTime: void 0,
+      invoiceAttachments: []
     };
   }
 };
@@ -335,6 +337,12 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
   }) {
     const wallet = new _IssuerSparkWallet(options, signer);
     wallet.initializeTracer(wallet);
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+      return {
+        wallet
+      };
+    }
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
     return {
       wallet,
@@ -636,6 +644,12 @@ var IssuerSparkWalletBrowser = class _IssuerSparkWalletBrowser extends IssuerSpa
   }) {
     const wallet = new _IssuerSparkWalletBrowser(options, signer);
     wallet.initializeTracer(wallet);
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+      return {
+        wallet
+      };
+    }
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
     return {
       wallet,

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   IssuerSparkWallet
-} from "./chunk-NRKE2XKD.js";
+} from "./chunk-ZMLVOUPB.js";
 import "./chunk-7B4B24XF.js";
 
 // src/issuer-wallet/issuer-spark-wallet.browser.ts
@@ -16,6 +16,12 @@ var IssuerSparkWalletBrowser = class _IssuerSparkWalletBrowser extends IssuerSpa
   }) {
     const wallet = new _IssuerSparkWalletBrowser(options, signer);
     wallet.initializeTracer(wallet);
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+      return {
+        wallet
+      };
+    }
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
     return {
       wallet,

package/dist/index.node.cjs

@@ -199,7 +199,7 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
   }
   async constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
     return {
-      version: 1,
+      version: 2,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "mintInput",
@@ -217,12 +217,13 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
       ],
       clientCreatedTimestamp: /* @__PURE__ */ new Date(),
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
-      expiryTime: void 0
+      expiryTime: void 0,
+      invoiceAttachments: []
     };
   }
   async constructCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable) {
     return {
-      version: 1,
+      version: 2,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "createInput",
@@ -238,7 +239,8 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
       tokenOutputs: [],
       clientCreatedTimestamp: /* @__PURE__ */ new Date(),
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
-      expiryTime: void 0
+      expiryTime: void 0,
+      invoiceAttachments: []
     };
   }
 };
@@ -335,6 +337,12 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
   }) {
     const wallet = new _IssuerSparkWallet(options, signer);
     wallet.initializeTracer(wallet);
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+      return {
+        wallet
+      };
+    }
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
     return {
       wallet,
@@ -636,6 +644,12 @@ var IssuerSparkWalletNodeJS = class _IssuerSparkWalletNodeJS extends IssuerSpark
   }) {
     const wallet = new _IssuerSparkWalletNodeJS(options, signer);
     wallet.initializeTracer(wallet);
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+      return {
+        wallet
+      };
+    }
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
     return {
       wallet,

package/dist/index.node.js

@@ -1,6 +1,6 @@
 import {
   IssuerSparkWallet
-} from "./chunk-NRKE2XKD.js";
+} from "./chunk-ZMLVOUPB.js";
 import "./chunk-7B4B24XF.js";
 
 // src/issuer-wallet/issuer-spark-wallet.node.ts
@@ -16,6 +16,12 @@ var IssuerSparkWalletNodeJS = class _IssuerSparkWalletNodeJS extends IssuerSpark
   }) {
     const wallet = new _IssuerSparkWalletNodeJS(options, signer);
     wallet.initializeTracer(wallet);
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+      return {
+        wallet
+      };
+    }
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
     return {
       wallet,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/issuer-sdk",
-  "version": "0.0.86",
+  "version": "0.0.87",
   "description": "Spark Issuer SDK for token issuance",
   "license": "Apache-2.0",
   "module": "./dist/index.js",
@@ -72,12 +72,10 @@
     "types": "tsc"
   },
   "dependencies": {
-    "@buildonspark/spark-sdk": "0.2.7",
-    "@lightsparkdev/core": "^1.4.3",
+    "@buildonspark/spark-sdk": "0.2.8",
     "@noble/curves": "^1.8.0",
     "@scure/btc-signer": "^1.5.0",
-    "buffer": "^6.0.3",
-    "ts-proto": "^2.6.1"
+    "buffer": "^6.0.3"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.4",

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

@@ -14,6 +14,14 @@ export class IssuerSparkWalletBrowser extends BaseIssuerSparkWallet {
     const wallet = new IssuerSparkWalletBrowser(options, signer);
     wallet.initializeTracer(wallet);
 
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+
+      return {
+        wallet,
+      };
+    }
+
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
 
     return {

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

@@ -14,6 +14,14 @@ export class IssuerSparkWalletNodeJS extends BaseIssuerSparkWallet {
     const wallet = new IssuerSparkWalletNodeJS(options, signer);
     wallet.initializeTracer(wallet);
 
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+
+      return {
+        wallet,
+      };
+    }
+
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
 
     return {

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

@@ -4,7 +4,6 @@ import {
   SparkWalletProps,
   ValidationError,
 } from "@buildonspark/spark-sdk";
-import { isNode } from "@lightsparkdev/core";
 import {
   decodeSparkAddress,
   encodeSparkAddress,
@@ -58,6 +57,14 @@ export class IssuerSparkWallet extends SparkWallet {
     const wallet = new IssuerSparkWallet(options, signer);
     wallet.initializeTracer(wallet);
 
+    if (options && options.signerWithPreExistingKeys) {
+      await wallet.initWalletWithoutSeed();
+
+      return {
+        wallet,
+      };
+    }
+
     const initResponse = await wallet.initWallet(mnemonicOrSeed, accountNumber);
 
     return {

package/src/services/token-transactions.ts

@@ -44,7 +44,7 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
     tokenAmount: bigint,
   ): Promise<TokenTransaction> {
     return {
-      version: 1,
+      version: 2,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "mintInput",
@@ -64,6 +64,7 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
       sparkOperatorIdentityPublicKeys:
         super.collectOperatorIdentityPublicKeys(),
       expiryTime: undefined,
+      invoiceAttachments: [],
     };
   }
 
@@ -76,7 +77,7 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
     isFreezable: boolean,
   ): Promise<TokenTransaction> {
     return {
-      version: 1,
+      version: 2,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "createInput",
@@ -94,6 +95,7 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
       sparkOperatorIdentityPublicKeys:
         super.collectOperatorIdentityPublicKeys(),
       expiryTime: undefined,
+      invoiceAttachments: [],
     };
   }
 }

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

@@ -113,7 +113,7 @@ describe.each(TEST_CONFIGS)(
       await expect(wallet.mintTokens(tokenAmount)).rejects.toThrow();
     });
 
-    it("should create, andfail when minting more than max supply", async () => {
+    it("should create, and fail when minting more than max supply", async () => {
       const tokenAmount: bigint = 1000n;
       const { wallet } = await IssuerSparkWalletTesting.initialize({
         options: config,
@@ -198,6 +198,306 @@ describe.each(TEST_CONFIGS)(
       expect(userBalance.balance).toBeGreaterThanOrEqual(tokenAmount);
     });
 
+    const tv1It = name.startsWith("TV1") ? it : it.skip;
+    tv1It("should transfer tokens using spark invoices", async () => {
+      const tokenAmount: bigint = 777n;
+      const initialIssuerBalance = 100000n;
+
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: config,
+        });
+      const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
+        options: config,
+      });
+
+      await issuerWallet.createToken({
+        tokenName: `${name}INV`,
+        tokenTicker: "INV",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1_000_000n,
+      });
+
+      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 invoice = await receiverWallet.createTokensInvoice({
+        amount: tokenAmount,
+        tokenIdentifier,
+        memo: "Invoice test",
+        expiryTime: new Date(Date.now() + 1000 * 60 * 60 * 24),
+      });
+
+      const txId = await issuerWallet.fulfillSparkInvoice([{ invoice }]);
+      expect(typeof txId).toBe("string");
+      expect(txId.length).toBeGreaterThan(0);
+
+      const issuerBalanceAfter = (await issuerWallet.getIssuerTokenBalance())
+        .balance;
+      expect(issuerBalanceAfter).toEqual(
+        issuerBalanceBeforeTransfer - tokenAmount,
+      );
+
+      const receiverBalanceObj = await receiverWallet.getBalance();
+      const receiverBalance = filterTokenBalanceForTokenIdentifier(
+        receiverBalanceObj?.tokenBalances,
+        tokenIdentifier!,
+      );
+      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;
+
+      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.mintTokens(initialIssuerBalance);
+
+      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 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 txId = await issuerWallet.fulfillSparkInvoice([
+        { invoice: invoice1 },
+        { invoice: invoice2 },
+        { invoice: invoice3 },
+      ]);
+      expect(typeof txId).toBe("string");
+      expect(txId.length).toBeGreaterThan(0);
+
+      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 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;
+
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.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.mintTokens(initialIssuerBalance);
+
+      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),
+      });
+
+      await expect(
+        issuerWallet.fulfillSparkInvoice([{ invoice: expiredInvoice }]),
+      ).rejects.toThrow("expired");
+
+      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);
+    });
+
+    tv1It("should fulfill a spark invoice with null expiry", async () => {
+      const tokenAmount: bigint = 321n;
+      const initialIssuerBalance = 100000n;
+
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.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.mintTokens(initialIssuerBalance);
+
+      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 txId = await issuerWallet.fulfillSparkInvoice([
+        { invoice: nullExpiryInvoice },
+      ]);
+      expect(typeof txId).toBe("string");
+      expect(txId.length).toBeGreaterThan(0);
+
+      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);
+    });
+
+    tv1It(
+      "should fulfill a tokens invoice without amount by passing amount parameter",
+      async () => {
+        const tokenAmount: bigint = 555n;
+        const initialIssuerBalance = 100000n;
+
+        const { wallet: issuerWallet } =
+          await IssuerSparkWalletTesting.initialize({
+            options: config,
+          });
+        const { wallet: receiverWallet } = await SparkWalletTesting.initialize({
+          options: config,
+        });
+
+        await issuerWallet.createToken({
+          tokenName: `${name}INVAOPT`,
+          tokenTicker: "INO",
+          decimals: 0,
+          isFreezable: false,
+          maxSupply: 1_000_000n,
+        });
+
+        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 invoiceWithoutAmount = await receiverWallet.createTokensInvoice({
+          tokenIdentifier,
+          memo: "Invoice without preset amount",
+          expiryTime: new Date(Date.now() + 1000 * 60 * 60 * 24),
+        });
+
+        const txId = await (issuerWallet as any).fulfillSparkInvoice([
+          { invoice: invoiceWithoutAmount, amount: tokenAmount },
+        ]);
+        expect(typeof txId).toBe("string");
+        expect(txId.length).toBeGreaterThan(0);
+
+        const issuerBalanceAfter = (await issuerWallet.getIssuerTokenBalance())
+          .balance;
+        expect(issuerBalanceAfter).toEqual(
+          issuerBalanceBeforeTransfer - tokenAmount,
+        );
+
+        const receiverBalanceObj = await receiverWallet.getBalance();
+        const receiverBalance = filterTokenBalanceForTokenIdentifier(
+          receiverBalanceObj?.tokenBalances,
+          tokenIdentifier!,
+        );
+        expect(receiverBalance.balance).toEqual(tokenAmount);
+      },
+    );
+
     it("should create, mint, and batchtransfer tokens", async () => {
       const tokenAmount: bigint = 999n;