@buildonspark/issuer-sdk 0.0.39 → 0.0.41

package/dist/index.cjs

@@ -35,18 +35,23 @@ 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");
+var import_utils6 = require("@noble/curves/abstract/utils");
 
 // src/services/freeze.ts
 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,8 @@ function hashFreezeTokensPayload(payload) {
 }
 
 // src/services/freeze.ts
+var import_spark_sdk2 = require("@buildonspark/spark-sdk");
+var import_utils3 = require("@noble/curves/abstract/utils");
 var TokenFreezeService = class {
   config;
   connectionManager;
@@ -111,18 +118,30 @@ var TokenFreezeService = class {
           tokenPublicKey,
           shouldUnfreeze,
           issuerProvidedTimestamp,
-          operatorIdentityPublicKey: operator.identityPublicKey
+          operatorIdentityPublicKey: (0, import_utils3.hexToBytes)(operator.identityPublicKey)
         };
         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);
@@ -132,7 +151,7 @@ var TokenFreezeService = class {
 
 // src/services/token-transactions.ts
 var import_token_transactions = require("@buildonspark/spark-sdk/token-transactions");
-var import_utils3 = require("@noble/curves/abstract/utils");
+var import_utils4 = require("@noble/curves/abstract/utils");
 var IssuerTokenTransactionService = class extends import_token_transactions.TokenTransactionService {
   constructor(config, connectionManager) {
     super(config, connectionManager);
@@ -151,7 +170,7 @@ var IssuerTokenTransactionService = class extends import_token_transactions.Toke
         {
           ownerPublicKey: tokenPublicKey,
           tokenPublicKey,
-          tokenAmount: (0, import_utils3.numberToBytesBE)(tokenAmount, 16)
+          tokenAmount: (0, import_utils4.numberToBytesBE)(tokenAmount, 16)
         }
       ],
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys()
@@ -160,7 +179,7 @@ var IssuerTokenTransactionService = class extends import_token_transactions.Toke
 };
 
 // src/utils/type-mappers.ts
-var import_utils4 = require("@noble/curves/abstract/utils");
+var import_utils5 = require("@noble/curves/abstract/utils");
 
 // src/utils/enum-mappers.ts
 var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
@@ -241,22 +260,22 @@ function convertTokenActivityToHexEncoded(rawTransactions) {
             $case: "onChain",
             onChain: {
               operationType: mapOperationType(onChain.operationType),
-              transactionHash: (0, import_utils4.bytesToHex)(onChain.transactionHash),
-              rawtx: (0, import_utils4.bytesToHex)(onChain.rawtx),
+              transactionHash: (0, import_utils5.bytesToHex)(onChain.transactionHash),
+              rawtx: (0, import_utils5.bytesToHex)(onChain.rawtx),
               status: mapOnChainTransactionStatus(onChain.status),
               inputs: onChain.inputs.map((input) => ({
-                rawTx: (0, import_utils4.bytesToHex)(input.rawTx),
+                rawTx: (0, import_utils5.bytesToHex)(input.rawTx),
                 vout: input.vout,
                 amountSats: input.amountSats,
                 tokenPublicKey: input.tokenPublicKey,
-                tokenAmount: input.tokenAmount ? (0, import_utils4.bytesToNumberBE)(input.tokenAmount).toString() : void 0
+                tokenAmount: input.tokenAmount ? (0, import_utils5.bytesToNumberBE)(input.tokenAmount).toString() : void 0
               })),
               outputs: onChain.outputs.map((output) => ({
-                rawTx: (0, import_utils4.bytesToHex)(output.rawTx),
+                rawTx: (0, import_utils5.bytesToHex)(output.rawTx),
                 vout: output.vout,
                 amountSats: output.amountSats,
                 tokenPublicKey: output.tokenPublicKey,
-                tokenAmount: output.tokenAmount ? (0, import_utils4.bytesToNumberBE)(output.tokenAmount).toString() : void 0
+                tokenAmount: output.tokenAmount ? (0, import_utils5.bytesToNumberBE)(output.tokenAmount).toString() : void 0
               })),
               broadcastedAt: onChain.broadcastedAt,
               confirmedAt: onChain.confirmedAt
@@ -270,39 +289,39 @@ function convertTokenActivityToHexEncoded(rawTransactions) {
             $case: "spark",
             spark: {
               operationType: mapOperationType(spark.operationType),
-              transactionHash: (0, import_utils4.bytesToHex)(spark.transactionHash),
+              transactionHash: (0, import_utils5.bytesToHex)(spark.transactionHash),
               status: mapSparkTransactionStatus(spark.status),
               confirmedAt: spark.confirmedAt,
               leavesToCreate: spark.leavesToCreate.map((leaf) => ({
-                tokenPublicKey: (0, import_utils4.bytesToHex)(leaf.tokenPublicKey),
+                tokenPublicKey: (0, import_utils5.bytesToHex)(leaf.tokenPublicKey),
                 id: leaf.id,
-                ownerPublicKey: (0, import_utils4.bytesToHex)(leaf.ownerPublicKey),
-                revocationPublicKey: (0, import_utils4.bytesToHex)(leaf.revocationPublicKey),
+                ownerPublicKey: (0, import_utils5.bytesToHex)(leaf.ownerPublicKey),
+                revocationPublicKey: (0, import_utils5.bytesToHex)(leaf.revocationPublicKey),
                 withdrawalBondSats: leaf.withdrawalBondSats,
                 withdrawalLocktime: leaf.withdrawalLocktime,
-                tokenAmount: (0, import_utils4.bytesToNumberBE)(leaf.tokenAmount).toString(),
-                createTxHash: (0, import_utils4.bytesToHex)(leaf.createTxHash),
+                tokenAmount: (0, import_utils5.bytesToNumberBE)(leaf.tokenAmount).toString(),
+                createTxHash: (0, import_utils5.bytesToHex)(leaf.createTxHash),
                 createTxVoutIndex: leaf.createTxVoutIndex,
-                spendTxHash: leaf.spendTxHash ? (0, import_utils4.bytesToHex)(leaf.spendTxHash) : void 0,
+                spendTxHash: leaf.spendTxHash ? (0, import_utils5.bytesToHex)(leaf.spendTxHash) : void 0,
                 spendTxVoutIndex: leaf.spendTxVoutIndex,
                 isFrozen: leaf.isFrozen
               })),
               leavesToSpend: spark.leavesToSpend.map((leaf) => ({
-                tokenPublicKey: (0, import_utils4.bytesToHex)(leaf.tokenPublicKey),
+                tokenPublicKey: (0, import_utils5.bytesToHex)(leaf.tokenPublicKey),
                 id: leaf.id,
-                ownerPublicKey: (0, import_utils4.bytesToHex)(leaf.ownerPublicKey),
-                revocationPublicKey: (0, import_utils4.bytesToHex)(leaf.revocationPublicKey),
+                ownerPublicKey: (0, import_utils5.bytesToHex)(leaf.ownerPublicKey),
+                revocationPublicKey: (0, import_utils5.bytesToHex)(leaf.revocationPublicKey),
                 withdrawalBondSats: leaf.withdrawalBondSats,
                 withdrawalLocktime: leaf.withdrawalLocktime,
-                tokenAmount: (0, import_utils4.bytesToNumberBE)(leaf.tokenAmount).toString(),
-                createTxHash: (0, import_utils4.bytesToHex)(leaf.createTxHash),
+                tokenAmount: (0, import_utils5.bytesToNumberBE)(leaf.tokenAmount).toString(),
+                createTxHash: (0, import_utils5.bytesToHex)(leaf.createTxHash),
                 createTxVoutIndex: leaf.createTxVoutIndex,
-                spendTxHash: leaf.spendTxHash ? (0, import_utils4.bytesToHex)(leaf.spendTxHash) : void 0,
+                spendTxHash: leaf.spendTxHash ? (0, import_utils5.bytesToHex)(leaf.spendTxHash) : void 0,
                 spendTxVoutIndex: leaf.spendTxVoutIndex,
                 isFrozen: leaf.isFrozen
               })),
               sparkOperatorIdentityPublicKeys: spark.sparkOperatorIdentityPublicKeys.map(
-                (key) => (0, import_utils4.bytesToHex)(key)
+                (key) => (0, import_utils5.bytesToHex)(key)
               )
             }
           }
@@ -311,7 +330,7 @@ function convertTokenActivityToHexEncoded(rawTransactions) {
       return { transaction: void 0 };
     }),
     nextCursor: rawTransactions.nextCursor ? {
-      lastTransactionHash: (0, import_utils4.bytesToHex)(
+      lastTransactionHash: (0, import_utils5.bytesToHex)(
         rawTransactions.nextCursor.lastTransactionHash
       ),
       layer: mapLayer(rawTransactions.nextCursor.layer)
@@ -321,8 +340,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,23 +378,31 @@ 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_utils6.hexToBytes)(await super.getIdentityPublicKey())]
+      });
+      const info = tokenInfo.tokenPubkeyInfos[0];
+      return {
+        tokenPublicKey: (0, import_utils6.bytesToHex)(info.announcement.publicKey.publicKey),
+        tokenName: info.announcement.name,
+        tokenSymbol: info.announcement.symbol,
+        tokenDecimals: Number((0, import_utils6.bytesToNumberBE)(info.announcement.decimal)),
+        isFreezable: info.announcement.isFreezable,
+        maxSupply: (0, import_utils6.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();
     const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-      (0, import_utils5.hexToBytes)(tokenPublicKey),
+      (0, import_utils6.hexToBytes)(tokenPublicKey),
       tokenAmount
     );
     return await this.issuerTokenTransactionService.broadcastTokenTransaction(
@@ -401,10 +429,10 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk.SparkW
       this.config.getNetworkType()
     );
     const response = await this.tokenFreezeService.freezeTokens(
-      (0, import_utils5.hexToBytes)(decodedOwnerPubkey),
-      (0, import_utils5.hexToBytes)(tokenPublicKey)
+      (0, import_utils6.hexToBytes)(decodedOwnerPubkey),
+      (0, import_utils6.hexToBytes)(tokenPublicKey)
     );
-    const tokenAmount = (0, import_utils5.bytesToNumberBE)(response.impactedTokenAmount);
+    const tokenAmount = (0, import_utils6.bytesToNumberBE)(response.impactedTokenAmount);
     return {
       impactedOutputIds: response.impactedOutputIds,
       impactedTokenAmount: tokenAmount
@@ -418,10 +446,10 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk.SparkW
       this.config.getNetworkType()
     );
     const response = await this.tokenFreezeService.unfreezeTokens(
-      (0, import_utils5.hexToBytes)(decodedOwnerPubkey),
-      (0, import_utils5.hexToBytes)(tokenPublicKey)
+      (0, import_utils6.hexToBytes)(decodedOwnerPubkey),
+      (0, import_utils6.hexToBytes)(tokenPublicKey)
     );
-    const tokenAmount = (0, import_utils5.bytesToNumberBE)(response.impactedTokenAmount);
+    const tokenAmount = (0, import_utils6.bytesToNumberBE)(response.impactedTokenAmount);
     return {
       impactedOutputIds: response.impactedOutputIds,
       impactedTokenAmount: tokenAmount
@@ -429,27 +457,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_utils6.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 = 4) {
     await this.lrc20Wallet.syncWallet();
     const tokenPublicKey = new import_lrc20_sdk2.TokenPubkey(this.lrc20Wallet.pubkey);
     const announcement = new import_lrc20_sdk2.TokenPubkeyAnnouncement(
@@ -460,13 +489,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
@@ -10,7 +13,7 @@ import {
 import {
   bytesToHex as bytesToHex2,
   bytesToNumberBE as bytesToNumberBE2,
-  hexToBytes
+  hexToBytes as hexToBytes2
 } from "@noble/curves/abstract/utils";
 
 // src/services/freeze.ts
@@ -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,8 @@ function hashFreezeTokensPayload(payload) {
 }
 
 // src/services/freeze.ts
+import { NetworkError } from "@buildonspark/spark-sdk";
+import { hexToBytes } from "@noble/curves/abstract/utils";
 var TokenFreezeService = class {
   config;
   connectionManager;
@@ -85,18 +95,30 @@ var TokenFreezeService = class {
           tokenPublicKey,
           shouldUnfreeze,
           issuerProvidedTimestamp,
-          operatorIdentityPublicKey: operator.identityPublicKey
+          operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
         };
         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 +317,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,23 +355,31 @@ 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: [hexToBytes2(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();
     const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-      hexToBytes(tokenPublicKey),
+      hexToBytes2(tokenPublicKey),
       tokenAmount
     );
     return await this.issuerTokenTransactionService.broadcastTokenTransaction(
@@ -375,8 +406,8 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
       this.config.getNetworkType()
     );
     const response = await this.tokenFreezeService.freezeTokens(
-      hexToBytes(decodedOwnerPubkey),
-      hexToBytes(tokenPublicKey)
+      hexToBytes2(decodedOwnerPubkey),
+      hexToBytes2(tokenPublicKey)
     );
     const tokenAmount = bytesToNumberBE2(response.impactedTokenAmount);
     return {
@@ -392,8 +423,8 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
       this.config.getNetworkType()
     );
     const response = await this.tokenFreezeService.unfreezeTokens(
-      hexToBytes(decodedOwnerPubkey),
-      hexToBytes(tokenPublicKey)
+      hexToBytes2(decodedOwnerPubkey),
+      hexToBytes2(tokenPublicKey)
     );
     const tokenAmount = bytesToNumberBE2(response.impactedTokenAmount);
     return {
@@ -403,27 +434,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: hexToBytes2(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 = 4) {
     await this.lrc20Wallet.syncWallet();
     const tokenPublicKey = new TokenPubkey(this.lrc20Wallet.pubkey);
     const announcement = new TokenPubkeyAnnouncement(
@@ -434,13 +466,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.41",
   "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.38",
+    "@buildonspark/spark-sdk": "0.1.10",
     "@noble/curves": "^1.8.0",
     "@scure/btc-signer": "^1.5.0",
     "bitcoinjs-lib": "^6.1.5",