@buildonspark/issuer-sdk 0.0.30 → 0.0.32

package/src/services/token-transactions.ts

@@ -18,14 +18,14 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
   ): Promise<TokenTransaction> {
     return {
       network: this.config.getNetworkProto(),
-      tokenInput: {
+      tokenInputs: {
         $case: "mintInput",
         mintInput: {
           issuerPublicKey: tokenPublicKey,
           issuerProvidedTimestamp: Date.now(),
         },
       },
-      outputLeaves: [
+      tokenOutputs: [
         {
           ownerPublicKey: tokenPublicKey,
           tokenPublicKey: tokenPublicKey,

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

@@ -74,14 +74,14 @@ describe("token integration test", () => {
 
     // Assert token public key info values
     const identityPublicKey = await wallet.getIdentityPublicKey();
-    expect(publicKeyInfo?.announcement?.name).toEqual("TestToken1");
-    expect(publicKeyInfo?.announcement?.symbol).toEqual("TT1");
-    expect(publicKeyInfo?.announcement?.decimal).toEqual(0);
-    expect(publicKeyInfo?.announcement?.maxSupply).toEqual(0);
-    expect(publicKeyInfo?.announcement?.isFreezable).toEqual(false);
+    expect(publicKeyInfo?.tokenName).toEqual("TestToken1");
+    expect(publicKeyInfo?.tokenSymbol).toEqual("TT1");
+    expect(publicKeyInfo?.tokenDecimals).toEqual(0);
+    expect(publicKeyInfo?.maxSupply).toEqual(0);
+    expect(publicKeyInfo?.isFreezable).toEqual(false);
 
     // Compare the public key using bytesToHex
-    const pubKeyHex = publicKeyInfo?.announcement?.tokenPubkey.pubkey;
+    const pubKeyHex = publicKeyInfo?.tokenPublicKey;
     expect(pubKeyHex).toEqual(identityPublicKey);
 
     await wallet.mintTokens(tokenAmount);
@@ -93,78 +93,7 @@ describe("token integration test", () => {
     expect(tokenInfo[0].tokenName).toEqual("TestToken1");
     expect(tokenInfo[0].tokenSymbol).toEqual("TT1");
     expect(tokenInfo[0].tokenDecimals).toEqual(0);
-    expect(tokenInfo[0].tokenSupply).toEqual(tokenAmount);
-  });
-
-  it("should announce, issue, and withdraw a single token", async () => {
-    const tokenAmount: bigint = 1000n;
-    const { wallet } = await IssuerSparkWallet.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));
-    await faucet.mineBlocks(6);
-
-    await new Promise((resolve) => setTimeout(resolve, 5000));
-
-    try {
-      const response = await wallet.announceTokenL1({
-        tokenName: "TestToken2",
-        tokenTicker: "TT2",
-        decimals: 0,
-        maxSupply: 0,
-        isFreezable: false,
-      });
-      console.log("Announce token response: " + response);
-    } catch (error: any) {
-      console.error(
-        "Expected announceTokenL1() to succeed with fauceted funds: " + error,
-      );
-      fail();
-    }
-    await faucet.mineBlocks(6);
-    await wallet.mintTokens(tokenAmount);
-    // Mint a second time to ensure that multiple leaves are handled correctly
-    // (a self transfer should first be broadcast to enable withdrawal in a single TX).
-    await wallet.mintTokens(tokenAmount);
-
-    const sourceBalance = await wallet.getIssuerTokenBalance();
-    expect(sourceBalance.balance).toEqual(tokenAmount * 2n);
-
-    await new Promise((resolve) => setTimeout(resolve, 5000));
-
-    try {
-      const response = await wallet.withdrawTokens(l1WalletPubKey);
-      console.log("Withdraw token txid: " + response?.txid);
-    } catch (error: any) {
-      fail("Expected withdrawTokens() to succeed: " + error);
-    }
-    // Wallet should update balance immediately by marking the leafs as withdrawn in memory in the wallet.
-    // (note that if re-initializing the wallet this will currently revert balance until confirmation).
-    const sourceBalanceImmediatelyAfterWithdrawal =
-      await wallet.getIssuerTokenBalance();
-    expect(sourceBalanceImmediatelyAfterWithdrawal.balance).toEqual(0n);
-
-    // Mine blocks to confirm the transaction and  make LRC20 aware
-    // of the withdrawal.
-    await faucet.mineBlocks(6);
-
-    // Wait for LRC20 processing.
-    await new Promise((resolve) => setTimeout(resolve, 30000));
-
-    // Mine more blocks to trigger SO fetching of withdrawals from LRC.
-    await faucet.mineBlocks(6);
-
-    // Wait for SO processing.
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-
-    // Ensure that after LRC20 processing that balance is still 0.
-    const sourceBalanceAfterWithdrawal = await wallet.getIssuerTokenBalance();
-    expect(sourceBalanceAfterWithdrawal.balance).toEqual(0n);
+    expect(tokenInfo[0].maxSupply).toEqual(tokenAmount);
   });
 
   it("should issue a single token and transfer it with ECDSA", async () => {
@@ -296,13 +225,13 @@ describe("token integration test", () => {
     expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
     // Freeze tokens
     const freezeResponse = await issuerWallet.freezeTokens(userWalletPublicKey);
-    expect(freezeResponse.impactedLeafIds.length).toBeGreaterThan(0);
+    expect(freezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
     expect(freezeResponse.impactedTokenAmount).toEqual(tokenAmount);
 
     // Unfreeze tokens
     const unfreezeResponse =
       await issuerWallet.unfreezeTokens(userWalletPublicKey);
-    expect(unfreezeResponse.impactedLeafIds.length).toBeGreaterThan(0);
+    expect(unfreezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
     expect(unfreezeResponse.impactedTokenAmount).toEqual(tokenAmount);
   });
 
@@ -342,12 +271,12 @@ describe("token integration test", () => {
     expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
 
     const freezeResult = await issuerWallet.freezeTokens(userWalletPublicKey);
-    expect(freezeResult.impactedLeafIds.length).toBe(1);
+    expect(freezeResult.impactedOutputIds.length).toBe(1);
     expect(freezeResult.impactedTokenAmount).toBe(1000n);
 
     const unfreezeResult =
       await issuerWallet.unfreezeTokens(userWalletPublicKey);
-    expect(unfreezeResult.impactedLeafIds.length).toBe(1);
+    expect(unfreezeResult.impactedOutputIds.length).toBe(1);
     expect(unfreezeResult.impactedTokenAmount).toBe(1000n);
   });
 

package/src/tests/stress/transfers.test.ts

@@ -4,7 +4,10 @@ import { LOCAL_WALLET_CONFIG_ECDSA } from "../../../../spark-sdk/src/services/wa
 import { SparkWallet } from "@buildonspark/spark-sdk";
 import { filterTokenBalanceForTokenPublicKey } from "@buildonspark/spark-sdk/utils";
 
-const TEST_TIMEOUT = 80000; // 80 seconds
+const TEST_TIMEOUT = 600_000; // 10 minutes
+const TOKEN_AMOUNT: bigint = 1000n;
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
 describe("Stress test for token transfers", () => {
   jest.setTimeout(TEST_TIMEOUT);
@@ -23,13 +26,10 @@ describe("Stress test for token transfers", () => {
     clearTimeout(timeoutId);
   });
 
-  it("[Spark] wallets should successfully complete multiple token transactions in rapid succession (5 TPS)", async () => {
-    // Iteration: IssuerSparkWallet -> SparkWallet -> IssuerSparkWallet
-    // 2 transactions per iteration
-    // (2 transactions * 200 iterations) / 80 seconds = 5 TPS
-    const MAX_ITERATIONS = 200;
-    const TOKEN_AMOUNT: bigint = 1000n;
+  it("[Spark] wallets should maintain state consistency through repeated token transfer cycles", async () => {
+    const maxTransactionCycles = 50;
 
+    const start_time = Date.now();
     const { wallet: issuerWallet } = await IssuerSparkWallet.initialize({
       options: LOCAL_WALLET_CONFIG_ECDSA,
     });
@@ -38,17 +38,18 @@ describe("Stress test for token transfers", () => {
     });
 
     await issuerWallet.mintTokens(TOKEN_AMOUNT);
+    await sleep(1000);
     const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
     const userWalletSparkAddress = await userWallet.getSparkAddress();
     const issuerWalletSparkAddress = await issuerWallet.getSparkAddress();
 
-    for (let i = 0; i < MAX_ITERATIONS; i++) {
+    for (let i = 0; i < maxTransactionCycles; i++) {
       if (timeoutReached) {
         console.log(
           "Timeout reached, stopping iterations at idx: " +
             i +
             " of " +
-            MAX_ITERATIONS,
+            maxTransactionCycles,
         );
         break;
       }
@@ -59,6 +60,7 @@ describe("Stress test for token transfers", () => {
           tokenAmount: TOKEN_AMOUNT,
           receiverSparkAddress: userWalletSparkAddress,
         });
+        await sleep(1000);
         const issuerBalance = await issuerWallet.getIssuerTokenBalance();
         const userBalanceObj = await userWallet.getBalance();
         const userBalance = filterTokenBalanceForTokenPublicKey(
@@ -74,6 +76,7 @@ describe("Stress test for token transfers", () => {
           tokenAmount: TOKEN_AMOUNT,
           receiverSparkAddress: issuerWalletSparkAddress,
         });
+        await sleep(1000);
         const userBalanceObjAfterTransferBack = await userWallet.getBalance();
         const userBalanceAfterTransferBack =
           filterTokenBalanceForTokenPublicKey(
@@ -85,8 +88,96 @@ describe("Stress test for token transfers", () => {
         expect(userBalanceAfterTransferBack.balance).toEqual(0n);
         expect(issuerBalanceAfterTransferBack.balance).toEqual(TOKEN_AMOUNT);
       } catch (error: any) {
-        throw new Error(`Test failed on iteration ${i}: ${error}`);
+        const end_time = Date.now();
+        const duration_ms = end_time - start_time;
+        const minutes = Math.floor(duration_ms / 60000);
+        const seconds = ((duration_ms % 60000) / 1000).toFixed(2);
+        throw new Error(
+          `Test failed on iteration ${i}: ${error} in ${duration_ms}ms (${minutes}m ${seconds}s)`,
+        );
       }
     }
+    const end_time = Date.now();
+    const duration_ms = end_time - start_time;
+    const minutes = Math.floor(duration_ms / 60000);
+    const seconds = ((duration_ms % 60000) / 1000).toFixed(2);
+    console.log(
+      `Time taken to process ${maxTransactionCycles} transaction cycles: ${duration_ms}ms (${minutes}m ${seconds}s)`,
+    );
+  });
+
+  it("should correctly process a small batch of concurrent transfer requests", async () => {
+    const minTargetTps = 1;
+    const minTargetSuccessPercentage = 50;
+    const concurrentWalletPairs = 30;
+
+    const walletPairs = await Promise.all(
+      Array(concurrentWalletPairs)
+        .fill(0)
+        .map(async () => {
+          const issuer = await IssuerSparkWallet.initialize({
+            options: LOCAL_WALLET_CONFIG_ECDSA,
+          });
+          const user = await SparkWallet.initialize({
+            options: LOCAL_WALLET_CONFIG_ECDSA,
+          });
+
+          await issuer.wallet.mintTokens(TOKEN_AMOUNT);
+          const tokenPublicKey = await issuer.wallet.getIdentityPublicKey();
+          const userAddress = await user.wallet.getSparkAddress();
+
+          return { issuer, tokenPublicKey, userAddress };
+        }),
+    );
+
+    const transactions = walletPairs.map(
+      ({ issuer, tokenPublicKey, userAddress }) =>
+        async () => {
+          const start_time = Date.now();
+          try {
+            await issuer.wallet.transferTokens({
+              tokenPublicKey,
+              tokenAmount: TOKEN_AMOUNT,
+              receiverSparkAddress: userAddress,
+            });
+            const end_time = Date.now();
+            return { success: true, duration: end_time - start_time };
+          } catch (error) {
+            const end_time = Date.now();
+            return { success: false, error, duration: end_time - start_time };
+          }
+        },
+    );
+
+    const startTime = Date.now();
+    const results = await Promise.all(transactions.map((tx) => tx()));
+    const duration = (Date.now() - startTime) / 1000;
+
+    const errors = results.filter((r: { success: boolean }) => !r.success);
+    errors.forEach((e, i) => {
+      console.log(`Error ${i}: ${e.error} occurred in ${e.duration}ms`);
+    });
+
+    const numSuccessfulTransfers = results.filter(
+      (r: { success: boolean }) => r.success,
+    ).length;
+    const averageSuccessDuration =
+      results
+        .filter((r: { success: boolean }) => r.success)
+        .reduce((acc, r) => acc + r.duration, 0) /
+      (numSuccessfulTransfers || 1);
+    const successRate = (numSuccessfulTransfers / transactions.length) * 100;
+    const transfersPerSecond = numSuccessfulTransfers / duration;
+
+    console.log(`Total transfers: ${transactions.length}`);
+    console.log(`Duration: ${duration.toFixed(2)}s`);
+    console.log(`Actual transfers/second: ${transfersPerSecond.toFixed(2)}`);
+    console.log(
+      `Average successful transfer duration: ${averageSuccessDuration}ms`,
+    );
+    console.log(`Success rate: ${successRate.toFixed(2)}%`);
+
+    expect(transfersPerSecond).toBeGreaterThanOrEqual(minTargetTps);
+    expect(successRate).toBeGreaterThanOrEqual(minTargetSuccessPercentage);
   });
 });

package/src/types.ts

@@ -2,107 +2,110 @@ import { Lrc20Protos } from "@buildonspark/lrc20-sdk";
 
 // String enums to replace numeric enums
 export enum LayerType {
-    L1 = "L1",
-    SPARK = "SPARK"
+  L1 = "L1",
+  SPARK = "SPARK",
 }
 
 export enum OperationType {
-    USER_TRANSFER = "USER_TRANSFER",
-    USER_BURN = "USER_BURN",
-    ISSUER_ANNOUNCE = "ISSUER_ANNOUNCE",
-    ISSUER_MINT = "ISSUER_MINT",
-    ISSUER_TRANSFER = "ISSUER_TRANSFER",
-    ISSUER_FREEZE = "ISSUER_FREEZE",
-    ISSUER_UNFREEZE = "ISSUER_UNFREEZE",
-    ISSUER_BURN = "ISSUER_BURN"
+  USER_TRANSFER = "USER_TRANSFER",
+  USER_BURN = "USER_BURN",
+  ISSUER_ANNOUNCE = "ISSUER_ANNOUNCE",
+  ISSUER_MINT = "ISSUER_MINT",
+  ISSUER_TRANSFER = "ISSUER_TRANSFER",
+  ISSUER_FREEZE = "ISSUER_FREEZE",
+  ISSUER_UNFREEZE = "ISSUER_UNFREEZE",
+  ISSUER_BURN = "ISSUER_BURN",
 }
 
 export enum OnChainTransactionStatus {
-    PENDING = "PENDING",
-    CONFIRMED = "CONFIRMED",
-    WAITING_MINED = "WAITING_MINED",
-    MINED = "MINED",
-    ATTACHING = "ATTACHING",
-    ATTACHED = "ATTACHED"
+  PENDING = "PENDING",
+  CONFIRMED = "CONFIRMED",
+  WAITING_MINED = "WAITING_MINED",
+  MINED = "MINED",
+  ATTACHING = "ATTACHING",
+  ATTACHED = "ATTACHED",
 }
 
 export enum SparkTransactionStatus {
-    STARTED = "STARTED",
-    SIGNED = "SIGNED",
-    FINALIZED = "FINALIZED"
+  STARTED = "STARTED",
+  SIGNED = "SIGNED",
+  FINALIZED = "FINALIZED",
 }
 
 export type GetTokenActivityResponse = {
-    transactions: Transaction[];
-    nextCursor?: ListAllTokenTransactionsCursor | undefined;
-}
+  transactions: Transaction[];
+  nextCursor?: ListAllTokenTransactionsCursor | undefined;
+};
 
 export interface Transaction {
-    transaction?: {
+  transaction?:
+    | {
         $case: "onChain";
         onChain: OnChainTransaction;
-    } | {
+      }
+    | {
         $case: "spark";
         spark: SparkTransaction;
-    } | undefined;
+      }
+    | undefined;
 }
 
 export interface TokenPubKeyInfoResponse {
-    announcement: {
-        tokenPubkey: {
-            pubkey: string;
-        };
-        name: string;
-        symbol: string;
-        decimal: number;
-        maxSupply: bigint;
-        isFreezable: boolean;
-    } | null;
-    totalSupply: bigint;
+  announcement: {
+    tokenPubkey: {
+      pubkey: string;
+    };
+    name: string;
+    symbol: string;
+    decimal: number;
+    maxSupply: bigint;
+    isFreezable: boolean;
+  } | null;
+  totalSupply: bigint;
 }
 
 export interface OnChainTokenOutput {
-    rawTx: string;
-    vout: number;
-    amountSats: number;
-    tokenPublicKey?: string | undefined;
-    tokenAmount?: string | undefined;
+  rawTx: string;
+  vout: number;
+  amountSats: number;
+  tokenPublicKey?: string | undefined;
+  tokenAmount?: string | undefined;
 }
 export interface OnChainTransaction {
-    operationType: OperationType;
-    transactionHash: string;
-    rawtx: string;
-    status: OnChainTransactionStatus;
-    inputs: OnChainTokenOutput[];
-    outputs: OnChainTokenOutput[];
-    broadcastedAt: Date | undefined;
-    confirmedAt: Date | undefined;
+  operationType: OperationType;
+  transactionHash: string;
+  rawtx: string;
+  status: OnChainTransactionStatus;
+  inputs: OnChainTokenOutput[];
+  outputs: OnChainTokenOutput[];
+  broadcastedAt: Date | undefined;
+  confirmedAt: Date | undefined;
 }
 export interface SparkTransaction {
-    operationType: OperationType;
-    transactionHash: string;
-    status: SparkTransactionStatus;
-    confirmedAt: Date | undefined;
-    leavesToCreate: SparkLeaf[];
-    leavesToSpend: SparkLeaf[];
-    sparkOperatorIdentityPublicKeys: string[];
+  operationType: OperationType;
+  transactionHash: string;
+  status: SparkTransactionStatus;
+  confirmedAt: Date | undefined;
+  leavesToCreate: SparkLeaf[];
+  leavesToSpend: SparkLeaf[];
+  sparkOperatorIdentityPublicKeys: string[];
 }
 export interface SparkLeaf {
-    tokenPublicKey: string;
-    id: string;
-    ownerPublicKey: string;
-    revocationPublicKey: string;
-    withdrawalBondSats: number;
-    withdrawalLocktime: number;
-    tokenAmount: string;
-    createTxHash: string;
-    createTxVoutIndex: number;
-    spendTxHash?: string | undefined;
-    spendTxVoutIndex?: number | undefined;
-    isFrozen?: boolean | undefined;
+  tokenPublicKey: string;
+  id: string;
+  ownerPublicKey: string;
+  revocationPublicKey: string;
+  withdrawalBondSats: number;
+  withdrawalLocktime: number;
+  tokenAmount: string;
+  createTxHash: string;
+  createTxVoutIndex: number;
+  spendTxHash?: string | undefined;
+  spendTxVoutIndex?: number | undefined;
+  isFrozen?: boolean | undefined;
 }
 
 export interface ListAllTokenTransactionsCursor {
-    lastTransactionHash: string;
-    layer: LayerType;
+  lastTransactionHash: string;
+  layer: LayerType;
 }

package/src/utils/enum-mappers.ts

@@ -1,8 +1,15 @@
 import { Lrc20Protos } from "@buildonspark/lrc20-sdk";
-import { OperationType, OnChainTransactionStatus, SparkTransactionStatus, LayerType } from "../types.js";
+import {
+  OperationType,
+  OnChainTransactionStatus,
+  SparkTransactionStatus,
+  LayerType,
+} from "../types.js";
 
 // Helper functions to map from numeric enums to string enums
-export function mapOperationType(type: Lrc20Protos.OperationType): OperationType {
+export function mapOperationType(
+  type: Lrc20Protos.OperationType,
+): OperationType {
   switch (type) {
     case Lrc20Protos.OperationType.USER_TRANSFER:
       return OperationType.USER_TRANSFER;
@@ -25,7 +32,9 @@ export function mapOperationType(type: Lrc20Protos.OperationType): OperationType
   }
 }
 
-export function mapOnChainTransactionStatus(status: Lrc20Protos.OnChainTransactionStatus): OnChainTransactionStatus {
+export function mapOnChainTransactionStatus(
+  status: Lrc20Protos.OnChainTransactionStatus,
+): OnChainTransactionStatus {
   switch (status) {
     case Lrc20Protos.OnChainTransactionStatus.PENDING:
       return OnChainTransactionStatus.PENDING;
@@ -44,7 +53,9 @@ export function mapOnChainTransactionStatus(status: Lrc20Protos.OnChainTransacti
   }
 }
 
-export function mapSparkTransactionStatus(status: Lrc20Protos.SparkTransactionStatus): SparkTransactionStatus {
+export function mapSparkTransactionStatus(
+  status: Lrc20Protos.SparkTransactionStatus,
+): SparkTransactionStatus {
   switch (status) {
     case Lrc20Protos.SparkTransactionStatus.STARTED:
       return SparkTransactionStatus.STARTED;
@@ -66,4 +77,4 @@ export function mapLayer(layer: number): LayerType {
     default:
       return LayerType.L1; // Default case
   }
-} 
+}

package/src/utils/token-hashing.ts

@@ -2,7 +2,7 @@ import { sha256 } from "@scure/btc-signer/utils";
 import { FreezeTokensPayload } from "@buildonspark/spark-sdk/proto/spark";
 
 export function hashFreezeTokensPayload(
-  payload: FreezeTokensPayload
+  payload: FreezeTokensPayload,
 ): Uint8Array {
   if (!payload) {
     throw new Error("freeze tokens payload cannot be nil");
@@ -36,7 +36,7 @@ export function hashFreezeTokensPayload(
     new DataView(timestampBytes.buffer).setBigUint64(
       0,
       BigInt(payload.issuerProvidedTimestamp),
-      true // true for little-endian
+      true, // true for little-endian
     );
     timestampHash.update(timestampBytes);
   }