@buildonspark/issuer-sdk 0.0.39 → 0.0.40

package/dist/index.cjs

@@ -35,7 +35,7 @@ if (typeof global === "undefined") {
 
 // src/issuer-spark-wallet.ts
 var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
-var import_spark_sdk = require("@buildonspark/spark-sdk");
+var import_spark_sdk3 = require("@buildonspark/spark-sdk");
 var import_address = require("@buildonspark/spark-sdk/address");
 var import_utils5 = require("@noble/curves/abstract/utils");
 
@@ -44,9 +44,14 @@ var import_utils2 = require("@buildonspark/spark-sdk/utils");
 
 // src/utils/token-hashing.ts
 var import_utils = require("@scure/btc-signer/utils");
+var import_spark_sdk = require("@buildonspark/spark-sdk");
 function hashFreezeTokensPayload(payload) {
   if (!payload) {
-    throw new Error("freeze tokens payload cannot be nil");
+    throw new import_spark_sdk.ValidationError("Freeze tokens payload cannot be nil", {
+      field: "payload",
+      value: payload,
+      expected: "valid freeze tokens payload"
+    });
   }
   let allHashes = [];
   const ownerPubKeyHash = import_utils.sha256.create();
@@ -87,6 +92,7 @@ function hashFreezeTokensPayload(payload) {
 }
 
 // src/services/freeze.ts
+var import_spark_sdk2 = require("@buildonspark/spark-sdk");
 var TokenFreezeService = class {
   config;
   connectionManager;
@@ -115,14 +121,26 @@ var TokenFreezeService = class {
         };
         const hashedPayload = hashFreezeTokensPayload(freezeTokensPayload);
         const issuerSignature = await this.config.signer.signMessageWithIdentityKey(hashedPayload);
-        const response = await internalSparkClient.freeze_tokens({
-          freezeTokensPayload,
-          issuerSignature
-        });
-        return {
-          identifier,
-          response
-        };
+        try {
+          const response = await internalSparkClient.freeze_tokens({
+            freezeTokensPayload,
+            issuerSignature
+          });
+          return {
+            identifier,
+            response
+          };
+        } catch (error) {
+          throw new import_spark_sdk2.NetworkError(
+            "Failed to send a freeze/unfreeze operation",
+            {
+              operation: "freeze_tokens",
+              errorCount: 1,
+              errors: error instanceof Error ? error.message : String(error)
+            },
+            error instanceof Error ? error : void 0
+          );
+        }
       })
     );
     const successfulResponses = (0, import_utils2.collectResponses)(freezeResponses);
@@ -321,8 +339,9 @@ function convertTokenActivityToHexEncoded(rawTransactions) {
 }
 
 // src/issuer-spark-wallet.ts
+var import_spark_sdk4 = require("@buildonspark/spark-sdk");
 var BURN_ADDRESS = "02".repeat(33);
-var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk.SparkWallet {
+var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk3.SparkWallet {
   issuerTokenTransactionService;
   tokenFreezeService;
   static async initialize(options) {
@@ -358,18 +377,26 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk.SparkW
   }
   async getIssuerTokenInfo() {
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
-    const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
-      publicKeys: [(0, import_utils5.hexToBytes)(await super.getIdentityPublicKey())]
-    });
-    const info = tokenInfo.tokenPubkeyInfos[0];
-    return {
-      tokenPublicKey: (0, import_utils5.bytesToHex)(info.announcement.publicKey.publicKey),
-      tokenName: info.announcement.name,
-      tokenSymbol: info.announcement.symbol,
-      tokenDecimals: Number((0, import_utils5.bytesToNumberBE)(info.announcement.decimal)),
-      isFreezable: info.announcement.isFreezable,
-      maxSupply: (0, import_utils5.bytesToNumberBE)(info.announcement.maxSupply)
-    };
+    try {
+      const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
+        publicKeys: [(0, import_utils5.hexToBytes)(await super.getIdentityPublicKey())]
+      });
+      const info = tokenInfo.tokenPubkeyInfos[0];
+      return {
+        tokenPublicKey: (0, import_utils5.bytesToHex)(info.announcement.publicKey.publicKey),
+        tokenName: info.announcement.name,
+        tokenSymbol: info.announcement.symbol,
+        tokenDecimals: Number((0, import_utils5.bytesToNumberBE)(info.announcement.decimal)),
+        isFreezable: info.announcement.isFreezable,
+        maxSupply: (0, import_utils5.bytesToNumberBE)(info.announcement.maxSupply)
+      };
+    } catch (error) {
+      throw new import_spark_sdk3.NetworkError("Failed to get token info", {
+        operation: "getIssuerTokenInfo",
+        errorCount: 1,
+        errors: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
   async mintTokens(tokenAmount) {
     var tokenPublicKey = await super.getIdentityPublicKey();
@@ -429,27 +456,28 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk.SparkW
   }
   async getIssuerTokenActivity(pageSize = 100, cursor, operationTypes, beforeTimestamp, afterTimestamp) {
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
-    const transactions = await lrc20Client.listTransactions({
-      tokenPublicKey: (0, import_utils5.hexToBytes)(await super.getIdentityPublicKey()),
-      cursor,
-      pageSize,
-      beforeTimestamp,
-      afterTimestamp,
-      operationTypes
-    });
-    return convertTokenActivityToHexEncoded(transactions);
+    try {
+      const transactions = await lrc20Client.listTransactions({
+        tokenPublicKey: (0, import_utils5.hexToBytes)(await super.getIdentityPublicKey()),
+        cursor,
+        pageSize,
+        beforeTimestamp,
+        afterTimestamp,
+        operationTypes
+      });
+      return convertTokenActivityToHexEncoded(transactions);
+    } catch (error) {
+      throw new import_spark_sdk3.NetworkError("Failed to get token activity", {
+        operation: "listTransactions",
+        errorCount: 1,
+        errors: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
   async getIssuerTokenDistribution() {
-    throw new Error("Not implemented");
+    throw new import_spark_sdk4.NotImplementedError("Token distribution is not yet supported");
   }
-  async announceTokenL1({
-    tokenName,
-    tokenTicker,
-    decimals,
-    maxSupply,
-    isFreezable,
-    feeRateSatsPerVb = 2
-  }) {
+  async announceTokenL1(tokenName, tokenTicker, decimals, maxSupply, isFreezable, feeRateSatsPerVb = 2) {
     await this.lrc20Wallet.syncWallet();
     const tokenPublicKey = new import_lrc20_sdk2.TokenPubkey(this.lrc20Wallet.pubkey);
     const announcement = new import_lrc20_sdk2.TokenPubkeyAnnouncement(
@@ -460,13 +488,24 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk.SparkW
       maxSupply,
       isFreezable
     );
-    const tx = await this.lrc20Wallet.prepareAnnouncement(
-      announcement,
-      feeRateSatsPerVb
-    );
-    return await this.lrc20Wallet.broadcastRawBtcTransaction(
-      tx.bitcoin_tx.toHex()
-    );
+    try {
+      const tx = await this.lrc20Wallet.prepareAnnouncement(
+        announcement,
+        feeRateSatsPerVb
+      );
+      return await this.lrc20Wallet.broadcastRawBtcTransaction(
+        tx.bitcoin_tx.toHex()
+      );
+    } catch (error) {
+      throw new import_spark_sdk3.NetworkError(
+        "Failed to broadcast announcement transaction on L1",
+        {
+          operation: "broadcastRawBtcTransaction",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.d.cts

@@ -36,14 +36,7 @@ declare class IssuerSparkWallet extends SparkWallet {
     }>;
     getIssuerTokenActivity(pageSize?: number, cursor?: ListAllTokenTransactionsCursor, operationTypes?: OperationType[], beforeTimestamp?: Date, afterTimestamp?: Date): Promise<GetTokenActivityResponse>;
     getIssuerTokenDistribution(): Promise<TokenDistribution>;
-    announceTokenL1({ tokenName, tokenTicker, decimals, maxSupply, isFreezable, feeRateSatsPerVb, }: {
-        tokenName: any;
-        tokenTicker: any;
-        decimals: any;
-        maxSupply: any;
-        isFreezable: any;
-        feeRateSatsPerVb?: number | undefined;
-    }): Promise<string>;
+    announceTokenL1(tokenName: string, tokenTicker: string, decimals: number, maxSupply: bigint, isFreezable: boolean, feeRateSatsPerVb?: number): Promise<string>;
 }
 
 export { IssuerSparkWallet, type IssuerTokenInfo };

package/dist/index.d.ts

@@ -36,14 +36,7 @@ declare class IssuerSparkWallet extends SparkWallet {
     }>;
     getIssuerTokenActivity(pageSize?: number, cursor?: ListAllTokenTransactionsCursor, operationTypes?: OperationType[], beforeTimestamp?: Date, afterTimestamp?: Date): Promise<GetTokenActivityResponse>;
     getIssuerTokenDistribution(): Promise<TokenDistribution>;
-    announceTokenL1({ tokenName, tokenTicker, decimals, maxSupply, isFreezable, feeRateSatsPerVb, }: {
-        tokenName: any;
-        tokenTicker: any;
-        decimals: any;
-        maxSupply: any;
-        isFreezable: any;
-        feeRateSatsPerVb?: number | undefined;
-    }): Promise<string>;
+    announceTokenL1(tokenName: string, tokenTicker: string, decimals: number, maxSupply: bigint, isFreezable: boolean, feeRateSatsPerVb?: number): Promise<string>;
 }
 
 export { IssuerSparkWallet, type IssuerTokenInfo };

package/dist/index.js

@@ -2,7 +2,10 @@ import "./chunk-GB7N6I5O.js";
 
 // src/issuer-spark-wallet.ts
 import { TokenPubkey, TokenPubkeyAnnouncement } from "@buildonspark/lrc20-sdk";
-import { SparkWallet } from "@buildonspark/spark-sdk";
+import {
+  NetworkError as NetworkError2,
+  SparkWallet
+} from "@buildonspark/spark-sdk";
 import {
   decodeSparkAddress,
   encodeSparkAddress
@@ -18,9 +21,14 @@ import { collectResponses } from "@buildonspark/spark-sdk/utils";
 
 // src/utils/token-hashing.ts
 import { sha256 } from "@scure/btc-signer/utils";
+import { ValidationError } from "@buildonspark/spark-sdk";
 function hashFreezeTokensPayload(payload) {
   if (!payload) {
-    throw new Error("freeze tokens payload cannot be nil");
+    throw new ValidationError("Freeze tokens payload cannot be nil", {
+      field: "payload",
+      value: payload,
+      expected: "valid freeze tokens payload"
+    });
   }
   let allHashes = [];
   const ownerPubKeyHash = sha256.create();
@@ -61,6 +69,7 @@ function hashFreezeTokensPayload(payload) {
 }
 
 // src/services/freeze.ts
+import { NetworkError } from "@buildonspark/spark-sdk";
 var TokenFreezeService = class {
   config;
   connectionManager;
@@ -89,14 +98,26 @@ var TokenFreezeService = class {
         };
         const hashedPayload = hashFreezeTokensPayload(freezeTokensPayload);
         const issuerSignature = await this.config.signer.signMessageWithIdentityKey(hashedPayload);
-        const response = await internalSparkClient.freeze_tokens({
-          freezeTokensPayload,
-          issuerSignature
-        });
-        return {
-          identifier,
-          response
-        };
+        try {
+          const response = await internalSparkClient.freeze_tokens({
+            freezeTokensPayload,
+            issuerSignature
+          });
+          return {
+            identifier,
+            response
+          };
+        } catch (error) {
+          throw new NetworkError(
+            "Failed to send a freeze/unfreeze operation",
+            {
+              operation: "freeze_tokens",
+              errorCount: 1,
+              errors: error instanceof Error ? error.message : String(error)
+            },
+            error instanceof Error ? error : void 0
+          );
+        }
       })
     );
     const successfulResponses = collectResponses(freezeResponses);
@@ -295,6 +316,7 @@ function convertTokenActivityToHexEncoded(rawTransactions) {
 }
 
 // src/issuer-spark-wallet.ts
+import { NotImplementedError } from "@buildonspark/spark-sdk";
 var BURN_ADDRESS = "02".repeat(33);
 var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
   issuerTokenTransactionService;
@@ -332,18 +354,26 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
   }
   async getIssuerTokenInfo() {
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
-    const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
-      publicKeys: [hexToBytes(await super.getIdentityPublicKey())]
-    });
-    const info = tokenInfo.tokenPubkeyInfos[0];
-    return {
-      tokenPublicKey: bytesToHex2(info.announcement.publicKey.publicKey),
-      tokenName: info.announcement.name,
-      tokenSymbol: info.announcement.symbol,
-      tokenDecimals: Number(bytesToNumberBE2(info.announcement.decimal)),
-      isFreezable: info.announcement.isFreezable,
-      maxSupply: bytesToNumberBE2(info.announcement.maxSupply)
-    };
+    try {
+      const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
+        publicKeys: [hexToBytes(await super.getIdentityPublicKey())]
+      });
+      const info = tokenInfo.tokenPubkeyInfos[0];
+      return {
+        tokenPublicKey: bytesToHex2(info.announcement.publicKey.publicKey),
+        tokenName: info.announcement.name,
+        tokenSymbol: info.announcement.symbol,
+        tokenDecimals: Number(bytesToNumberBE2(info.announcement.decimal)),
+        isFreezable: info.announcement.isFreezable,
+        maxSupply: bytesToNumberBE2(info.announcement.maxSupply)
+      };
+    } catch (error) {
+      throw new NetworkError2("Failed to get token info", {
+        operation: "getIssuerTokenInfo",
+        errorCount: 1,
+        errors: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
   async mintTokens(tokenAmount) {
     var tokenPublicKey = await super.getIdentityPublicKey();
@@ -403,27 +433,28 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
   }
   async getIssuerTokenActivity(pageSize = 100, cursor, operationTypes, beforeTimestamp, afterTimestamp) {
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
-    const transactions = await lrc20Client.listTransactions({
-      tokenPublicKey: hexToBytes(await super.getIdentityPublicKey()),
-      cursor,
-      pageSize,
-      beforeTimestamp,
-      afterTimestamp,
-      operationTypes
-    });
-    return convertTokenActivityToHexEncoded(transactions);
+    try {
+      const transactions = await lrc20Client.listTransactions({
+        tokenPublicKey: hexToBytes(await super.getIdentityPublicKey()),
+        cursor,
+        pageSize,
+        beforeTimestamp,
+        afterTimestamp,
+        operationTypes
+      });
+      return convertTokenActivityToHexEncoded(transactions);
+    } catch (error) {
+      throw new NetworkError2("Failed to get token activity", {
+        operation: "listTransactions",
+        errorCount: 1,
+        errors: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
   async getIssuerTokenDistribution() {
-    throw new Error("Not implemented");
+    throw new NotImplementedError("Token distribution is not yet supported");
   }
-  async announceTokenL1({
-    tokenName,
-    tokenTicker,
-    decimals,
-    maxSupply,
-    isFreezable,
-    feeRateSatsPerVb = 2
-  }) {
+  async announceTokenL1(tokenName, tokenTicker, decimals, maxSupply, isFreezable, feeRateSatsPerVb = 2) {
     await this.lrc20Wallet.syncWallet();
     const tokenPublicKey = new TokenPubkey(this.lrc20Wallet.pubkey);
     const announcement = new TokenPubkeyAnnouncement(
@@ -434,13 +465,24 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
       maxSupply,
       isFreezable
     );
-    const tx = await this.lrc20Wallet.prepareAnnouncement(
-      announcement,
-      feeRateSatsPerVb
-    );
-    return await this.lrc20Wallet.broadcastRawBtcTransaction(
-      tx.bitcoin_tx.toHex()
-    );
+    try {
+      const tx = await this.lrc20Wallet.prepareAnnouncement(
+        announcement,
+        feeRateSatsPerVb
+      );
+      return await this.lrc20Wallet.broadcastRawBtcTransaction(
+        tx.bitcoin_tx.toHex()
+      );
+    } catch (error) {
+      throw new NetworkError2(
+        "Failed to broadcast announcement transaction on L1",
+        {
+          operation: "broadcastRawBtcTransaction",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
   }
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/issuer-sdk",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "description": "Spark Issuer SDK for token issuance",
   "license": "Apache-2.0",
   "module": "./dist/index.js",
@@ -54,8 +54,8 @@
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.2.5",
-    "@buildonspark/lrc20-sdk": "0.0.36",
-    "@buildonspark/spark-sdk": "0.1.8",
+    "@buildonspark/lrc20-sdk": "0.0.37",
+    "@buildonspark/spark-sdk": "0.1.9",
     "@noble/curves": "^1.8.0",
     "@scure/btc-signer": "^1.5.0",
     "bitcoinjs-lib": "^6.1.5",

package/src/issuer-spark-wallet.ts

@@ -3,7 +3,11 @@ import {
   ListAllTokenTransactionsCursor,
   OperationType,
 } from "@buildonspark/lrc20-sdk/proto/rpc/v1/types";
-import { SparkWallet, SparkWalletProps } from "@buildonspark/spark-sdk";
+import {
+  NetworkError,
+  SparkWallet,
+  SparkWalletProps,
+} from "@buildonspark/spark-sdk";
 import {
   decodeSparkAddress,
   encodeSparkAddress,
@@ -19,6 +23,7 @@ import { TokenFreezeService } from "./services/freeze.js";
 import { IssuerTokenTransactionService } from "./services/token-transactions.js";
 import { GetTokenActivityResponse, TokenDistribution } from "./types.js";
 import { convertTokenActivityToHexEncoded } from "./utils/type-mappers.js";
+import { NotImplementedError } from "@buildonspark/spark-sdk";
 
 const BURN_ADDRESS = "02".repeat(33);
 
@@ -76,19 +81,27 @@ export class IssuerSparkWallet extends SparkWallet {
   public async getIssuerTokenInfo(): Promise<IssuerTokenInfo | null> {
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
 
-    const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
-      publicKeys: [hexToBytes(await super.getIdentityPublicKey())],
-    });
+    try {
+      const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
+        publicKeys: [hexToBytes(await super.getIdentityPublicKey())],
+      });
 
-    const info = tokenInfo.tokenPubkeyInfos[0];
-    return {
-      tokenPublicKey: bytesToHex(info.announcement!.publicKey!.publicKey),
-      tokenName: info.announcement!.name,
-      tokenSymbol: info.announcement!.symbol,
-      tokenDecimals: Number(bytesToNumberBE(info.announcement!.decimal)),
-      isFreezable: info.announcement!.isFreezable,
-      maxSupply: bytesToNumberBE(info.announcement!.maxSupply),
-    };
+      const info = tokenInfo.tokenPubkeyInfos[0];
+      return {
+        tokenPublicKey: bytesToHex(info.announcement!.publicKey!.publicKey),
+        tokenName: info.announcement!.name,
+        tokenSymbol: info.announcement!.symbol,
+        tokenDecimals: Number(bytesToNumberBE(info.announcement!.decimal)),
+        isFreezable: info.announcement!.isFreezable,
+        maxSupply: bytesToNumberBE(info.announcement!.maxSupply),
+      };
+    } catch (error) {
+      throw new NetworkError("Failed to get token info", {
+        operation: "getIssuerTokenInfo",
+        errorCount: 1,
+        errors: error instanceof Error ? error.message : String(error),
+      });
+    }
   }
 
   public async mintTokens(tokenAmount: bigint): Promise<string> {
@@ -174,30 +187,38 @@ export class IssuerSparkWallet extends SparkWallet {
   ): Promise<GetTokenActivityResponse> {
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
 
-    const transactions = await lrc20Client.listTransactions({
-      tokenPublicKey: hexToBytes(await super.getIdentityPublicKey()),
-      cursor,
-      pageSize,
-      beforeTimestamp,
-      afterTimestamp,
-      operationTypes,
-    });
-
-    return convertTokenActivityToHexEncoded(transactions);
+    try {
+      const transactions = await lrc20Client.listTransactions({
+        tokenPublicKey: hexToBytes(await super.getIdentityPublicKey()),
+        cursor,
+        pageSize,
+        beforeTimestamp,
+        afterTimestamp,
+        operationTypes,
+      });
+
+      return convertTokenActivityToHexEncoded(transactions);
+    } catch (error) {
+      throw new NetworkError("Failed to get token activity", {
+        operation: "listTransactions",
+        errorCount: 1,
+        errors: error instanceof Error ? error.message : String(error),
+      });
+    }
   }
 
   public async getIssuerTokenDistribution(): Promise<TokenDistribution> {
-    throw new Error("Not implemented");
+    throw new NotImplementedError("Token distribution is not yet supported");
   }
 
-  public async announceTokenL1({
-    tokenName,
-    tokenTicker,
-    decimals,
-    maxSupply,
-    isFreezable,
-    feeRateSatsPerVb = 2.0,
-  }): Promise<string> {
+  public async announceTokenL1(
+    tokenName: string,
+    tokenTicker: string,
+    decimals: number,
+    maxSupply: bigint,
+    isFreezable: boolean,
+    feeRateSatsPerVb: number = 2.0,
+  ): Promise<string> {
     await this.lrc20Wallet!.syncWallet();
 
     const tokenPublicKey = new TokenPubkey(this.lrc20Wallet!.pubkey);
@@ -211,13 +232,24 @@ export class IssuerSparkWallet extends SparkWallet {
       isFreezable,
     );
 
-    const tx = await this.lrc20Wallet!.prepareAnnouncement(
-      announcement,
-      feeRateSatsPerVb,
-    );
+    try {
+      const tx = await this.lrc20Wallet!.prepareAnnouncement(
+        announcement,
+        feeRateSatsPerVb,
+      );
 
-    return await this.lrc20Wallet!.broadcastRawBtcTransaction(
-      tx.bitcoin_tx.toHex(),
-    );
+      return await this.lrc20Wallet!.broadcastRawBtcTransaction(
+        tx.bitcoin_tx.toHex(),
+      );
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to broadcast announcement transaction on L1",
+        {
+          operation: "broadcastRawBtcTransaction",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error),
+        },
+      );
+    }
   }
 }

package/src/services/freeze.ts

@@ -6,6 +6,7 @@ import {
 } from "@buildonspark/spark-sdk/proto/spark";
 import { collectResponses } from "@buildonspark/spark-sdk/utils";
 import { hashFreezeTokensPayload } from "../utils/token-hashing.js";
+import { NetworkError } from "@buildonspark/spark-sdk";
 
 export class TokenFreezeService {
   private readonly config: WalletConfigService;
@@ -61,14 +62,27 @@ export class TokenFreezeService {
         const issuerSignature =
           await this.config.signer.signMessageWithIdentityKey(hashedPayload);
 
-        const response = await internalSparkClient.freeze_tokens({
-          freezeTokensPayload,
-          issuerSignature,
-        });
-        return {
-          identifier,
-          response,
-        };
+        try {
+          const response = await internalSparkClient.freeze_tokens({
+            freezeTokensPayload,
+            issuerSignature,
+          });
+
+          return {
+            identifier,
+            response,
+          };
+        } catch (error) {
+          throw new NetworkError(
+            "Failed to send a freeze/unfreeze operation",
+            {
+              operation: "freeze_tokens",
+              errorCount: 1,
+              errors: error instanceof Error ? error.message : String(error),
+            },
+            error instanceof Error ? error : undefined,
+          );
+        }
       }),
     );
 

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

@@ -8,96 +8,79 @@ import {
 import { BitcoinFaucet } from "../../../../spark-sdk/src/tests/utils/test-faucet.js";
 import { IssuerSparkWalletTesting } from "../utils/issuer-test-wallet.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
+import { SparkWallet } from "@buildonspark/spark-sdk";
+import { IssuerSparkWallet } from "../../index.js";
 
 const brokenTestFn = process.env.GITHUB_ACTIONS ? it.skip : it;
-describe("token integration test", () => {
+describe("token integration tests", () => {
   jest.setTimeout(80000);
 
-  brokenTestFn("should issue a single token with ECDSA", async () => {
-    const tokenAmount: bigint = 1000n;
-    const { wallet } = await IssuerSparkWalletTesting.initialize({
-      options: LOCAL_WALLET_CONFIG_ECDSA,
-    });
+  brokenTestFn(
+    "should fail when minting tokens without announcement",
+    async () => {
+      const tokenAmount: bigint = 1000n;
+      const { wallet } = await IssuerSparkWalletTesting.initialize({
+        options: LOCAL_WALLET_CONFIG_ECDSA,
+      });
 
-    await wallet.mintTokens(tokenAmount);
+      await wallet.mintTokens(tokenAmount);
 
-    const tokenBalance = (await wallet.getIssuerTokenBalance()).balance;
-    expect(tokenBalance).toEqual(tokenAmount);
-  });
+      const tokenBalance = (await wallet.getIssuerTokenBalance()).balance;
+      expect(tokenBalance).toEqual(tokenAmount);
+    },
+  );
 
-  brokenTestFn("should issue a single token with Schnorr", async () => {
+  brokenTestFn("should fail when minting more than max supply", async () => {
     const tokenAmount: bigint = 1000n;
     const { wallet } = await IssuerSparkWalletTesting.initialize({
       options: LOCAL_WALLET_CONFIG_SCHNORR,
     });
 
-    await wallet.mintTokens(tokenAmount);
-
-    const tokenBalance = (await wallet.getIssuerTokenBalance()).balance;
-    expect(tokenBalance).toEqual(tokenAmount);
+    await fundAndAnnounce(wallet, 2n, "MaxSupplyToken", "MST");
+    await expect(wallet.mintTokens(tokenAmount)).rejects.toThrow();
   });
 
-  brokenTestFn("should announce and issue a single token", async () => {
-    const tokenAmount: bigint = 1000n;
-    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 = BitcoinFaucet.getInstance();
-    const l1WalletPubKey = await wallet.getTokenL1Address();
-    await faucet.sendToAddress(l1WalletPubKey, 100_000n);
-    await faucet.mineBlocks(6);
-
-    await new Promise((resolve) => setTimeout(resolve, 5000));
-
-    try {
-      const response = await wallet.announceTokenL1({
-        tokenName: "TestToken1",
-        tokenTicker: "TT1",
-        decimals: 0,
-        maxSupply: 0n,
-        isFreezable: false,
+  brokenTestFn(
+    "should announce token and issue tokens successfully",
+    async () => {
+      const tokenAmount: bigint = 1000n;
+      const tokenName = "AnnounceIssueToken";
+      const tokenSymbol = "AIT";
+      const { wallet } = await IssuerSparkWalletTesting.initialize({
+        options: LOCAL_WALLET_CONFIG_SCHNORR,
       });
-      console.log("Announce token response:", response);
-    } catch (error: any) {
-      console.error("Error when announcing token on L1:", error);
-      expect(error).toBeUndefined();
-    }
-    await faucet.mineBlocks(6);
 
-    // Wait for LRC20 processing.
-    await new Promise((resolve) => setTimeout(resolve, 50000));
+      await fundAndAnnounce(wallet, 100000n, tokenName, tokenSymbol);
 
-    const publicKeyInfo = await wallet.getIssuerTokenInfo();
+      const publicKeyInfo = await wallet.getIssuerTokenInfo();
 
-    // Assert token public key info values
-    const identityPublicKey = await wallet.getIdentityPublicKey();
-    expect(publicKeyInfo?.tokenName).toEqual("TestToken1");
-    expect(publicKeyInfo?.tokenSymbol).toEqual("TT1");
-    expect(publicKeyInfo?.tokenDecimals).toEqual(0);
-    expect(publicKeyInfo?.maxSupply).toEqual(0n);
-    expect(publicKeyInfo?.isFreezable).toEqual(false);
+      // Assert token public key info values
+      const identityPublicKey = await wallet.getIdentityPublicKey();
+      expect(publicKeyInfo?.tokenName).toEqual(tokenName);
+      expect(publicKeyInfo?.tokenSymbol).toEqual(tokenSymbol);
+      expect(publicKeyInfo?.tokenDecimals).toEqual(0);
+      expect(publicKeyInfo?.maxSupply).toEqual(0n);
+      expect(publicKeyInfo?.isFreezable).toEqual(false);
 
-    // Compare the public key using bytesToHex
-    const pubKeyHex = publicKeyInfo?.tokenPublicKey;
-    expect(pubKeyHex).toEqual(identityPublicKey);
+      // Compare the public key using bytesToHex
+      const pubKeyHex = publicKeyInfo?.tokenPublicKey;
+      expect(pubKeyHex).toEqual(identityPublicKey);
 
-    await wallet.mintTokens(tokenAmount);
+      await wallet.mintTokens(tokenAmount);
 
-    const sourceBalance = (await wallet.getIssuerTokenBalance()).balance;
-    expect(sourceBalance).toEqual(tokenAmount);
+      const sourceBalance = (await wallet.getIssuerTokenBalance()).balance;
+      expect(sourceBalance).toEqual(tokenAmount);
 
-    const tokenInfo = await wallet.getTokenInfo();
-    expect(tokenInfo[0].tokenName).toEqual("TestToken1");
-    expect(tokenInfo[0].tokenSymbol).toEqual("TT1");
-    expect(tokenInfo[0].tokenDecimals).toEqual(0);
-    expect(tokenInfo[0].maxSupply).toEqual(tokenAmount);
-  });
+      const tokenInfo = await wallet.getTokenInfo();
+      expect(tokenInfo[0].tokenName).toEqual(tokenName);
+      expect(tokenInfo[0].tokenSymbol).toEqual(tokenSymbol);
+      expect(tokenInfo[0].tokenDecimals).toEqual(0);
+      expect(tokenInfo[0].maxSupply).toEqual(tokenAmount);
+    },
+  );
 
   brokenTestFn(
-    "should issue a single token and transfer it with ECDSA",
+    "should announce, mint, and transfer tokens with ECDSA",
     async () => {
       const tokenAmount: bigint = 1000n;
 
@@ -112,6 +95,8 @@ describe("token integration test", () => {
         },
       );
 
+      await fundAndAnnounce(issuerWallet, 100000n, "ECDSATransferToken", "ETT");
+
       await issuerWallet.mintTokens(tokenAmount);
       await issuerWallet.transferTokens({
         tokenAmount,
@@ -132,7 +117,7 @@ describe("token integration test", () => {
     },
   );
 
-  brokenTestFn("monitoring operations", async () => {
+  brokenTestFn("should track token operations in monitoring", async () => {
     const tokenAmount: bigint = 1000n;
 
     const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
@@ -143,6 +128,8 @@ describe("token integration test", () => {
       options: LOCAL_WALLET_CONFIG_ECDSA,
     });
 
+    await fundAndAnnounce(issuerWallet, 100000n, "MonitoringToken", "MOT");
+
     await issuerWallet.mintTokens(tokenAmount);
     await issuerWallet.transferTokens({
       tokenAmount,
@@ -170,7 +157,7 @@ describe("token integration test", () => {
   });
 
   brokenTestFn(
-    "should issue a single token and transfer it with Schnorr",
+    "should announce, mint, and transfer tokens with Schnorr",
     async () => {
       const tokenAmount: bigint = 1000n;
 
@@ -185,6 +172,13 @@ describe("token integration test", () => {
         },
       );
 
+      await fundAndAnnounce(
+        issuerWallet,
+        100000n,
+        "SchnorrTransferToken",
+        "STT",
+      );
+
       await issuerWallet.mintTokens(tokenAmount);
       await issuerWallet.transferTokens({
         tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
@@ -204,140 +198,166 @@ describe("token integration test", () => {
     },
   );
 
-  brokenTestFn("should freeze tokens with ECDSA", async () => {
-    const tokenAmount: bigint = 1000n;
-    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
-      options: LOCAL_WALLET_CONFIG_ECDSA,
-    });
+  brokenTestFn(
+    "should announce, mint, freeze and unfreeze tokens with ECDSA",
+    async () => {
+      const tokenAmount: bigint = 1000n;
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: LOCAL_WALLET_CONFIG_ECDSA,
+        });
 
-    await issuerWallet.mintTokens(tokenAmount);
+      await fundAndAnnounce(issuerWallet, 100000n, "ECDSAFreezeToken", "EFT");
+      await issuerWallet.mintTokens(tokenAmount);
 
-    // Check issuer balance after minting
-    const issuerBalanceAfterMint = (await issuerWallet.getIssuerTokenBalance())
-      .balance;
-    expect(issuerBalanceAfterMint).toEqual(tokenAmount);
+      // Check issuer balance after minting
+      const issuerBalanceAfterMint = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterMint).toEqual(tokenAmount);
 
-    const { wallet: userWallet } = await SparkWalletTesting.initialize({
-      options: LOCAL_WALLET_CONFIG_ECDSA,
-    });
-    const userWalletPublicKey = await userWallet.getSparkAddress();
+      const { wallet: userWallet } = await SparkWalletTesting.initialize({
+        options: LOCAL_WALLET_CONFIG_ECDSA,
+      });
+      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);
+      await issuerWallet.transferTokens({
+        tokenAmount,
+        tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
+        receiverSparkAddress: userWalletPublicKey,
+      });
+      const issuerBalanceAfterTransfer = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterTransfer).toEqual(0n);
 
-    const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
-    const userBalanceObj = await userWallet.getBalance();
-    const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
-      userBalanceObj?.tokenBalances,
-      tokenPublicKey,
-    );
-    expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
-    // Freeze tokens
-    const freezeResponse = await issuerWallet.freezeTokens(userWalletPublicKey);
-    expect(freezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
-    expect(freezeResponse.impactedTokenAmount).toEqual(tokenAmount);
-
-    // Unfreeze tokens
-    const unfreezeResponse =
-      await issuerWallet.unfreezeTokens(userWalletPublicKey);
-    expect(unfreezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
-    expect(unfreezeResponse.impactedTokenAmount).toEqual(tokenAmount);
-  });
+      const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
+      const userBalanceObj = await userWallet.getBalance();
+      const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
+        userBalanceObj?.tokenBalances,
+        tokenPublicKey,
+      );
+      expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
+      // Freeze tokens
+      const freezeResponse =
+        await issuerWallet.freezeTokens(userWalletPublicKey);
+      expect(freezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
+      expect(freezeResponse.impactedTokenAmount).toEqual(tokenAmount);
+
+      // Unfreeze tokens
+      const unfreezeResponse =
+        await issuerWallet.unfreezeTokens(userWalletPublicKey);
+      expect(unfreezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
+      expect(unfreezeResponse.impactedTokenAmount).toEqual(tokenAmount);
+    },
+  );
 
-  brokenTestFn("should freeze tokens with Schnorr", async () => {
-    const tokenAmount: bigint = 1000n;
-    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
-      options: LOCAL_WALLET_CONFIG_SCHNORR,
-    });
+  brokenTestFn(
+    "should announce, mint, freeze and unfreeze tokens with Schnorr",
+    async () => {
+      const tokenAmount: bigint = 1000n;
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: LOCAL_WALLET_CONFIG_SCHNORR,
+        });
 
-    await issuerWallet.mintTokens(tokenAmount);
+      await fundAndAnnounce(issuerWallet, 100000n, "SchnorrFreezeToken", "SFT");
 
-    // Check issuer balance after minting
-    const issuerBalanceAfterMint = (await issuerWallet.getIssuerTokenBalance())
-      .balance;
-    expect(issuerBalanceAfterMint).toEqual(tokenAmount);
+      await issuerWallet.mintTokens(tokenAmount);
 
-    const { wallet: userWallet } = await SparkWalletTesting.initialize({
-      options: LOCAL_WALLET_CONFIG_SCHNORR,
-    });
-    const userWalletPublicKey = await userWallet.getSparkAddress();
+      // Check issuer balance after minting
+      const issuerBalanceAfterMint = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterMint).toEqual(tokenAmount);
 
-    await issuerWallet.transferTokens({
-      tokenAmount,
-      tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
-      receiverSparkAddress: userWalletPublicKey,
-    });
+      const { wallet: userWallet } = await SparkWalletTesting.initialize({
+        options: LOCAL_WALLET_CONFIG_SCHNORR,
+      });
+      const userWalletPublicKey = await userWallet.getSparkAddress();
 
-    const issuerBalanceAfterTransfer = (
-      await issuerWallet.getIssuerTokenBalance()
-    ).balance;
-    expect(issuerBalanceAfterTransfer).toEqual(0n);
+      await issuerWallet.transferTokens({
+        tokenAmount,
+        tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
+        receiverSparkAddress: userWalletPublicKey,
+      });
 
-    const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
-    const userBalanceObj = await userWallet.getBalance();
-    const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
-      userBalanceObj?.tokenBalances,
-      tokenPublicKey,
-    );
-    expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
+      const issuerBalanceAfterTransfer = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterTransfer).toEqual(0n);
 
-    const freezeResult = await issuerWallet.freezeTokens(userWalletPublicKey);
-    expect(freezeResult.impactedOutputIds.length).toBe(1);
-    expect(freezeResult.impactedTokenAmount).toBe(1000n);
+      const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
+      const userBalanceObj = await userWallet.getBalance();
+      const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
+        userBalanceObj?.tokenBalances,
+        tokenPublicKey,
+      );
+      expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
 
-    const unfreezeResult =
-      await issuerWallet.unfreezeTokens(userWalletPublicKey);
-    expect(unfreezeResult.impactedOutputIds.length).toBe(1);
-    expect(unfreezeResult.impactedTokenAmount).toBe(1000n);
-  });
+      const freezeResult = await issuerWallet.freezeTokens(userWalletPublicKey);
+      expect(freezeResult.impactedOutputIds.length).toBe(1);
+      expect(freezeResult.impactedTokenAmount).toBe(1000n);
 
-  brokenTestFn("should burn tokens with ECDSA", async () => {
-    const tokenAmount: bigint = 200n;
-    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
-      options: LOCAL_WALLET_CONFIG_ECDSA,
-    });
-    await issuerWallet.mintTokens(tokenAmount);
+      const unfreezeResult =
+        await issuerWallet.unfreezeTokens(userWalletPublicKey);
+      expect(unfreezeResult.impactedOutputIds.length).toBe(1);
+      expect(unfreezeResult.impactedTokenAmount).toBe(1000n);
+    },
+  );
 
-    const issuerTokenBalance = (await issuerWallet.getIssuerTokenBalance())
-      .balance;
-    expect(issuerTokenBalance).toEqual(tokenAmount);
+  brokenTestFn(
+    "should announce, mint, and burn tokens with ECDSA",
+    async () => {
+      const tokenAmount: bigint = 200n;
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: LOCAL_WALLET_CONFIG_ECDSA,
+        });
 
-    await issuerWallet.burnTokens(tokenAmount);
+      await fundAndAnnounce(issuerWallet, 100000n, "ECDSABurnToken", "EBT");
+      await issuerWallet.mintTokens(tokenAmount);
 
-    const issuerTokenBalanceAfterBurn = (
-      await issuerWallet.getIssuerTokenBalance()
-    ).balance;
-    expect(issuerTokenBalanceAfterBurn).toEqual(0n);
-  });
+      const issuerTokenBalance = (await issuerWallet.getIssuerTokenBalance())
+        .balance;
+      expect(issuerTokenBalance).toEqual(tokenAmount);
 
-  brokenTestFn("should burn tokens with Schnorr", async () => {
-    const tokenAmount: bigint = 200n;
-    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
-      options: LOCAL_WALLET_CONFIG_SCHNORR,
-    });
-    await issuerWallet.mintTokens(tokenAmount);
+      await issuerWallet.burnTokens(tokenAmount);
 
-    const issuerTokenBalance = (await issuerWallet.getIssuerTokenBalance())
-      .balance;
-    expect(issuerTokenBalance).toEqual(tokenAmount);
+      const issuerTokenBalanceAfterBurn = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerTokenBalanceAfterBurn).toEqual(0n);
+    },
+  );
 
-    await issuerWallet.burnTokens(tokenAmount);
+  brokenTestFn(
+    "should announce, mint, and burn tokens with Schnorr",
+    async () => {
+      const tokenAmount: bigint = 200n;
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: LOCAL_WALLET_CONFIG_SCHNORR,
+        });
 
-    const issuerTokenBalanceAfterBurn = (
-      await issuerWallet.getIssuerTokenBalance()
-    ).balance;
-    expect(issuerTokenBalanceAfterBurn).toEqual(0n);
-  });
+      await fundAndAnnounce(issuerWallet, 100000n, "SchnorrBurnToken", "SBT");
+      await issuerWallet.mintTokens(tokenAmount);
+
+      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",
+    "should complete full token lifecycle with ECDSA: announce, mint, transfer, return, burn",
     async () => {
       const tokenAmount: bigint = 1000n;
 
@@ -350,6 +370,12 @@ describe("token integration test", () => {
         options: LOCAL_WALLET_CONFIG_ECDSA,
       });
 
+      await fundAndAnnounce(
+        issuerWallet,
+        100000n,
+        "ECDSAFullCycleToken",
+        "EFCT",
+      );
       await issuerWallet.mintTokens(tokenAmount);
 
       const issuerBalanceAfterMint = (
@@ -403,7 +429,7 @@ describe("token integration test", () => {
   );
 
   brokenTestFn(
-    "mint, transfer to user, user transfer to issuer, burn with Schnorr",
+    "should complete full token lifecycle with Schnorr: announce, mint, transfer, return, burn",
     async () => {
       const tokenAmount: bigint = 1000n;
 
@@ -416,7 +442,12 @@ describe("token integration test", () => {
         options: LOCAL_WALLET_CONFIG_SCHNORR,
       });
 
-      const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
+      await fundAndAnnounce(
+        issuerWallet,
+        100000n,
+        "SchnorrFullCycleToken",
+        "SFCT",
+      );
       await issuerWallet.mintTokens(tokenAmount);
 
       const issuerBalanceAfterMint = (
@@ -428,7 +459,7 @@ describe("token integration test", () => {
 
       await issuerWallet.transferTokens({
         tokenAmount,
-        tokenPublicKey,
+        tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
         receiverSparkAddress: userWalletPublicKey,
       });
 
@@ -471,3 +502,37 @@ describe("token integration test", () => {
     },
   );
 });
+
+async function fundAndAnnounce(
+  wallet: IssuerSparkWallet,
+  maxSupply: bigint = 100000n,
+  tokenName: string = "TestToken1",
+  tokenSymbol: string = "TT1",
+) {
+  // Faucet funds to the Issuer wallet because announcing a token
+  // requires ownership of an L1 UTXO.
+  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, 3000));
+
+  try {
+    const response = await wallet.announceTokenL1(
+      tokenName,
+      tokenSymbol,
+      0,
+      maxSupply,
+      false,
+    );
+    console.log("Announce token response:", response);
+  } catch (error: any) {
+    console.error("Error when announcing token on L1:", error);
+    expect(error).toBeUndefined();
+  }
+  await faucet.mineBlocks(1);
+
+  // Wait for LRC20 processing.
+  await new Promise((resolve) => setTimeout(resolve, 30000));
+}

package/src/types.ts

@@ -1,5 +1,3 @@
-import { Lrc20Protos } from "@buildonspark/lrc20-sdk";
-
 // String enums to replace numeric enums
 export enum LayerType {
   L1 = "L1",

package/src/utils/token-hashing.ts

@@ -1,11 +1,16 @@
 import { sha256 } from "@scure/btc-signer/utils";
 import { FreezeTokensPayload } from "@buildonspark/spark-sdk/proto/spark";
+import { ValidationError } from "@buildonspark/spark-sdk";
 
 export function hashFreezeTokensPayload(
   payload: FreezeTokensPayload,
 ): Uint8Array {
   if (!payload) {
-    throw new Error("freeze tokens payload cannot be nil");
+    throw new ValidationError("Freeze tokens payload cannot be nil", {
+      field: "payload",
+      value: payload,
+      expected: "valid freeze tokens payload",
+    });
   }
 
   let allHashes: Uint8Array[] = [];

package/src/utils/type-mappers.ts

@@ -1,16 +1,8 @@
 import {
   ListAllTokenTransactionsResponse,
   TokenPubkeyInfo,
-  Lrc20Protos,
 } from "@buildonspark/lrc20-sdk";
-import {
-  GetTokenActivityResponse,
-  TokenPubKeyInfoResponse,
-  OperationType,
-  OnChainTransactionStatus,
-  SparkTransactionStatus,
-  LayerType,
-} from "../types.js";
+import { GetTokenActivityResponse, TokenPubKeyInfoResponse } from "../types.js";
 import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
 import {
   mapOperationType,