@buildonspark/issuer-sdk 0.1.2 → 0.1.4

package/dist/index.node.cjs

@@ -20,10 +20,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.node.ts
 var index_node_exports = {};
 __export(index_node_exports, {
-  DefaultSparkSigner: () => import_spark_sdk7.DefaultSparkSigner,
+  DefaultSparkSigner: () => import_spark_sdk8.DefaultSparkSigner,
   IssuerSparkWallet: () => IssuerSparkWalletNodeJS,
-  UnsafeStatelessSparkSigner: () => import_spark_sdk7.UnsafeStatelessSparkSigner,
-  WalletConfig: () => import_spark_sdk8.WalletConfig
+  UnsafeStatelessSparkSigner: () => import_spark_sdk8.UnsafeStatelessSparkSigner,
+  WalletConfig: () => import_spark_sdk9.WalletConfig
 });
 module.exports = __toCommonJS(index_node_exports);
 
@@ -275,6 +275,9 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
   }
 };
 
+// src/issuer-wallet/issuer-spark-wallet.ts
+var import_spark_sdk6 = require("@buildonspark/spark-sdk");
+
 // src/utils/create-validation.ts
 var import_spark_sdk4 = require("@buildonspark/spark-sdk");
 function isNfcNormalized(value) {
@@ -382,49 +385,70 @@ var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
   }
   /**
    * Gets the token balance for the issuer's token.
+   * @deprecated Use getIssuerTokenBalances() instead. This method will be removed in a future version.
    * @returns An object containing the token balance as a bigint
+   *
+   * @throws {SparkValidationError} If multiple tokens are found for this issuer
    */
   async getIssuerTokenBalance() {
     const publicKey = await super.getIdentityPublicKey();
     const balanceObj = await this.getBalance();
-    const issuerBalance = [...balanceObj.tokenBalances.entries()].find(
+    const issuerBalance = [...balanceObj.tokenBalances.entries()].filter(
       ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey
     );
-    if (!balanceObj.tokenBalances || issuerBalance === void 0) {
+    if (issuerBalance.length > 1) {
+      throw new import_spark_sdk5.SparkValidationError(
+        "Multiple tokens found for this issuer. Use getIssuerTokenBalances() instead.",
+        {
+          field: "issuerTokenBalance",
+          expected: "single token",
+          actual: `${issuerBalance.length} tokens`
+        }
+      );
+    }
+    if (issuerBalance.length === 0) {
       return {
         tokenIdentifier: void 0,
         balance: 0n
       };
     }
     return {
-      tokenIdentifier: issuerBalance[0] ?? void 0,
-      balance: issuerBalance[1].balance
+      tokenIdentifier: issuerBalance[0][0],
+      balance: issuerBalance[0][1].balance
     };
   }
+  /**
+   * Gets the token balances for the tokens that were issued by this user.
+   * @returns An array of objects containing the token identifier and balance
+   */
+  async getIssuerTokenBalances() {
+    const publicKey = await super.getIdentityPublicKey();
+    const balanceObj = await this.getBalance();
+    const issuerBalance = [...balanceObj.tokenBalances.entries()].filter(
+      ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey
+    );
+    if (issuerBalance.length === 0) {
+      return [
+        {
+          tokenIdentifier: void 0,
+          balance: 0n
+        }
+      ];
+    }
+    return issuerBalance.map(([tokenIdentifier, { balance }]) => ({
+      tokenIdentifier,
+      balance
+    }));
+  }
   /**
    * Retrieves information about the issuer's token.
-   * @returns An object containing token information including public key, name, symbol, decimals, max supply, and freeze status
+   * @deprecated Use getIssuerTokensMetadata() instead. This method will be removed in a future version.
+   * @returns An object containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
    * @throws {SparkRequestError} If the token metadata cannot be retrieved
+   * @throws {SparkValidationError} If multiple tokens are found for this issuer
    */
   async getIssuerTokenMetadata() {
     const issuerPublicKey = await super.getIdentityPublicKey();
-    const tokenMetadata = this.tokenMetadata;
-    const cachedIssuerTokenMetadata = [...tokenMetadata.entries()].find(
-      ([, metadata]) => (0, import_utils4.bytesToHex)(metadata.issuerPublicKey) === issuerPublicKey
-    );
-    if (cachedIssuerTokenMetadata !== void 0) {
-      const metadata = cachedIssuerTokenMetadata[1];
-      return {
-        tokenPublicKey: (0, import_utils4.bytesToHex)(metadata.issuerPublicKey),
-        rawTokenIdentifier: metadata.tokenIdentifier,
-        tokenName: metadata.tokenName,
-        tokenTicker: metadata.tokenTicker,
-        decimals: metadata.decimals,
-        maxSupply: (0, import_utils4.bytesToNumberBE)(metadata.maxSupply),
-        isFreezable: metadata.isFreezable,
-        extraMetadata: metadata.extraMetadata ? new Uint8Array(metadata.extraMetadata) : void 0
-      };
-    }
     const sparkTokenClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
     );
@@ -444,12 +468,21 @@ var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
           }
         );
       }
+      if (response.tokenMetadata.length > 1) {
+        throw new import_spark_sdk5.SparkValidationError(
+          "Multiple tokens found for this issuer. Please migrate to getIssuerTokensMetadata() instead.",
+          {
+            field: "tokenMetadata",
+            value: response.tokenMetadata
+          }
+        );
+      }
       const metadata = response.tokenMetadata[0];
-      const tokenIdentifier = (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
+      const bech32mTokenIdentifier = (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
         tokenIdentifier: metadata.tokenIdentifier,
         network: this.config.getNetworkType()
       });
-      this.tokenMetadata.set(tokenIdentifier, metadata);
+      this.tokenMetadata.set(bech32mTokenIdentifier, metadata);
       return {
         tokenPublicKey: (0, import_utils4.bytesToHex)(metadata.issuerPublicKey),
         rawTokenIdentifier: metadata.tokenIdentifier,
@@ -458,47 +491,110 @@ var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
         decimals: metadata.decimals,
         maxSupply: (0, import_utils4.bytesToNumberBE)(metadata.maxSupply),
         isFreezable: metadata.isFreezable,
-        extraMetadata: metadata.extraMetadata
+        extraMetadata: metadata.extraMetadata ? new Uint8Array(metadata.extraMetadata) : void 0,
+        bech32mTokenIdentifier
       };
     } catch (error) {
       throw new import_spark_sdk5.SparkRequestError("Failed to fetch token metadata", { error });
     }
   }
+  /**
+   * Retrieves information about the tokens that were issued by this user.
+   * @returns An array of objects containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
+   * @throws {SparkRequestError} If the token metadata cannot be retrieved
+   */
+  async getIssuerTokensMetadata() {
+    const issuerPublicKey = await super.getIdentityPublicKey();
+    const sparkTokenClient = await this.connectionManager.createSparkTokenClient(
+      this.config.getCoordinatorAddress()
+    );
+    try {
+      const response = await sparkTokenClient.query_token_metadata({
+        issuerPublicKeys: Array.of((0, import_utils4.hexToBytes)(issuerPublicKey))
+      });
+      if (response.tokenMetadata.length === 0) {
+        throw new import_spark_sdk5.SparkValidationError(
+          "Token metadata not found - If a token has not yet been created, please create it first. Try again in a few seconds.",
+          {
+            field: "tokenMetadata",
+            value: response.tokenMetadata,
+            expected: "non-empty array",
+            actualLength: response.tokenMetadata.length,
+            expectedLength: 1
+          }
+        );
+      }
+      const tokenMetadata = [];
+      for (const metadata of response.tokenMetadata) {
+        const bech32mTokenIdentifier = (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
+          tokenIdentifier: metadata.tokenIdentifier,
+          network: this.config.getNetworkType()
+        });
+        this.tokenMetadata.set(bech32mTokenIdentifier, metadata);
+        tokenMetadata.push({
+          tokenPublicKey: (0, import_utils4.bytesToHex)(metadata.issuerPublicKey),
+          rawTokenIdentifier: metadata.tokenIdentifier,
+          tokenName: metadata.tokenName,
+          tokenTicker: metadata.tokenTicker,
+          decimals: metadata.decimals,
+          maxSupply: (0, import_utils4.bytesToNumberBE)(metadata.maxSupply),
+          isFreezable: metadata.isFreezable,
+          extraMetadata: metadata.extraMetadata ? new Uint8Array(metadata.extraMetadata) : void 0,
+          bech32mTokenIdentifier
+        });
+      }
+      return tokenMetadata;
+    } catch (error) {
+      throw new import_spark_sdk5.SparkRequestError("Failed to fetch token metadata", { error });
+    }
+  }
   /**
    * Retrieves the bech32m encoded token identifier for the issuer's token.
+   * @deprecated Use getIssuerTokenIdentifiers() instead. This method will be removed in a future version.
    * @returns The bech32m encoded token identifier for the issuer's token
    * @throws {SparkRequestError} If the token identifier cannot be retrieved
+   * @throws {SparkValidationError} If multiple tokens are found for this issuer
    */
   async getIssuerTokenIdentifier() {
-    const tokenMetadata = await this.getIssuerTokenMetadata();
-    return (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
-      tokenIdentifier: tokenMetadata.rawTokenIdentifier,
-      network: this.config.getNetworkType()
-    });
+    const tokensMetadata = await this.getIssuerTokensMetadata();
+    if (tokensMetadata.length > 1) {
+      throw new import_spark_sdk5.SparkValidationError(
+        "Multiple tokens found. Use getIssuerTokenIdentifiers() instead.",
+        {
+          method: "getIssuerTokenIdentifier",
+          availableTokens: tokensMetadata.map((t) => ({
+            tokenName: t.tokenName,
+            tokenTicker: t.tokenTicker,
+            bech32mTokenIdentifier: (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
+              tokenIdentifier: t.rawTokenIdentifier,
+              network: this.config.getNetworkType()
+            })
+          }))
+        }
+      );
+    }
+    if (tokensMetadata.length === 0) {
+      throw new import_spark_sdk5.SparkValidationError("No tokens found. Create a token first.");
+    }
+    return tokensMetadata[0].bech32mTokenIdentifier;
   }
   /**
-   * Create a new token on Spark.
-   *
-   * @param params - Object containing token creation parameters.
-   * @param params.tokenName - The name of the token.
-   * @param params.tokenTicker - The ticker symbol for the token.
-   * @param params.decimals - The number of decimal places for the token.
-   * @param params.isFreezable - Whether the token can be frozen.
-   * @param [params.maxSupply=0n] - (Optional) The maximum supply of the token. Defaults to <code>0n</code>.
-   * @param params.extraMetadata - (Optional) This can be used to store additional bytes data to be associated with a token, like image data.
-   *
-   * @returns The transaction ID of the announcement.
-   *
-   * @throws {SparkValidationError} If `decimals` is not a safe integer or other validation fails.
-   * @throws {SparkRequestError} If the announcement transaction cannot be broadcast.
+   * Retrieves the bech32m encoded token identifier for the issuer's token.
+   * @returns The bech32m encoded token identifier for the issuer's token
+   * @throws {SparkRequestError} If the token identifier cannot be retrieved
    */
+  async getIssuerTokenIdentifiers() {
+    const tokensMetadata = await this.getIssuerTokensMetadata();
+    return tokensMetadata.map((metadata) => metadata.bech32mTokenIdentifier);
+  }
   async createToken({
     tokenName,
     tokenTicker,
     decimals,
     isFreezable,
     maxSupply = 0n,
-    extraMetadata
+    extraMetadata,
+    returnIdentifierForCreate = false
   }) {
     validateTokenParameters(
       tokenName,
@@ -518,9 +614,30 @@ var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
         isFreezable,
         extraMetadata
       );
-      return await this.issuerTokenTransactionService.broadcastTokenTransaction(
+      const { finalTokenTransactionHash, tokenIdentifier } = await this.issuerTokenTransactionService.broadcastTokenTransactionDetailed(
         tokenTransaction
       );
+      const txHash = (0, import_utils4.bytesToHex)(finalTokenTransactionHash);
+      if (returnIdentifierForCreate) {
+        if (!tokenIdentifier) {
+          throw new import_spark_sdk5.SparkRequestError(
+            "Server response missing expected field: tokenIdentifier",
+            {
+              operation: "broadcast_transaction",
+              field: "tokenIdentifier"
+            }
+          );
+        }
+        const bech32mTokenIdentifier = (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
+          tokenIdentifier,
+          network: this.config.getNetworkType()
+        });
+        return {
+          tokenIdentifier: bech32mTokenIdentifier,
+          transactionHash: txHash
+        };
+      }
+      return txHash;
     } else {
       const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialCreateTokenTransaction(
         (0, import_utils4.hexToBytes)(issuerPublicKey),
@@ -531,21 +648,75 @@ var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
         isFreezable,
         extraMetadata
       );
-      return await this.issuerTokenTransactionService.broadcastTokenTransactionV3(
+      const broadcastResponse = await this.issuerTokenTransactionService.broadcastTokenTransactionV3Detailed(
         partialTokenTransaction
       );
+      const finalHash = await (0, import_spark_sdk6.hashFinalTokenTransaction)(
+        broadcastResponse.finalTokenTransaction
+      );
+      const finalTransactionHash = (0, import_utils4.bytesToHex)(finalHash);
+      if (returnIdentifierForCreate) {
+        if (!broadcastResponse.tokenIdentifier) {
+          throw new import_spark_sdk5.SparkRequestError(
+            "Server response missing expected field: tokenIdentifier",
+            {
+              operation: "broadcast_transaction",
+              field: "tokenIdentifier"
+            }
+          );
+        }
+        const tokenIdentifier = (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
+          tokenIdentifier: broadcastResponse.tokenIdentifier,
+          network: this.config.getNetworkType()
+        });
+        return {
+          tokenIdentifier,
+          transactionHash: finalTransactionHash
+        };
+      }
+      return finalTransactionHash;
     }
   }
-  /**
-   * Mints new tokens
-   * @param tokenAmount - The amount of tokens to mint
-   * @returns The transaction ID of the mint operation
-   */
-  async mintTokens(tokenAmount) {
+  async mintTokens(tokenAmountOrParams) {
+    let tokenAmount;
+    let bech32mTokenIdentifier;
+    if (typeof tokenAmountOrParams === "bigint") {
+      tokenAmount = tokenAmountOrParams;
+      bech32mTokenIdentifier = void 0;
+    } else {
+      tokenAmount = tokenAmountOrParams.tokenAmount;
+      bech32mTokenIdentifier = tokenAmountOrParams.tokenIdentifier;
+    }
     const issuerTokenPublicKey = await super.getIdentityPublicKey();
     const issuerTokenPublicKeyBytes = (0, import_utils4.hexToBytes)(issuerTokenPublicKey);
-    const tokenMetadata = await this.getIssuerTokenMetadata();
-    const rawTokenIdentifier = tokenMetadata.rawTokenIdentifier;
+    const tokensMetadata = await this.getIssuerTokensMetadata();
+    if (bech32mTokenIdentifier === void 0) {
+      if (tokensMetadata.length > 1) {
+        throw new import_spark_sdk5.SparkValidationError(
+          "Multiple tokens found. Please use mintTokens({ tokenAmount, tokenIdentifier }) instead.",
+          {
+            field: "tokenIdentifier",
+            availableTokens: tokensMetadata.map((t) => ({
+              tokenName: t.tokenName,
+              tokenTicker: t.tokenTicker,
+              bech32mTokenIdentifier: (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
+                tokenIdentifier: t.rawTokenIdentifier,
+                network: this.config.getNetworkType()
+              })
+            }))
+          }
+        );
+      }
+      const encodedTokenIdentifier = (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
+        tokenIdentifier: tokensMetadata[0].rawTokenIdentifier,
+        network: this.config.getNetworkType()
+      });
+      bech32mTokenIdentifier = encodedTokenIdentifier;
+    }
+    const rawTokenIdentifier = (0, import_spark_sdk5.decodeBech32mTokenIdentifier)(
+      bech32mTokenIdentifier,
+      this.config.getNetworkType()
+    ).tokenIdentifier;
     if (this.config.getTokenTransactionVersion() === "V2") {
       const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
         rawTokenIdentifier,
@@ -566,39 +737,108 @@ var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
       );
     }
   }
-  /**
-   * Burns issuer's tokens
-   * @param tokenAmount - The amount of tokens to burn
-   * @param selectedOutputs - Optional array of outputs to use for the burn operation
-   * @returns The transaction ID of the burn operation
-   */
-  async burnTokens(tokenAmount, selectedOutputs) {
+  async burnTokens(tokenAmountOrParams, selectedOutputs) {
+    let bech32mTokenIdentifier;
+    let tokenAmount;
+    let outputs;
+    if (typeof tokenAmountOrParams === "bigint") {
+      tokenAmount = tokenAmountOrParams;
+      outputs = selectedOutputs;
+      const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+      if (tokenIdentifiers.length > 1) {
+        throw new import_spark_sdk5.SparkValidationError(
+          "Multiple tokens found. Use burnTokens({ tokenIdentifier, tokenAmount, selectedOutputs }) to specify which token to burn.",
+          {
+            field: "tokenIdentifier",
+            availableTokens: tokenIdentifiers
+          }
+        );
+      }
+      if (tokenIdentifiers.length === 0) {
+        throw new import_spark_sdk5.SparkValidationError(
+          "No tokens found. Create a token first."
+        );
+      }
+      bech32mTokenIdentifier = tokenIdentifiers[0];
+    } else {
+      tokenAmount = tokenAmountOrParams.tokenAmount;
+      outputs = tokenAmountOrParams.selectedOutputs;
+      if (tokenAmountOrParams.tokenIdentifier) {
+        const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+        const tokenIdentifier = tokenIdentifiers.find(
+          (identifier) => identifier === tokenAmountOrParams.tokenIdentifier
+        );
+        if (!tokenIdentifier) {
+          throw new import_spark_sdk5.SparkValidationError("Token not found for this issuer", {
+            field: "tokenIdentifier",
+            value: tokenAmountOrParams.tokenIdentifier
+          });
+        }
+        bech32mTokenIdentifier = tokenAmountOrParams.tokenIdentifier;
+      } else {
+        const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+        if (tokenIdentifiers.length === 0) {
+          throw new import_spark_sdk5.SparkValidationError(
+            "No tokens found. Create a token first."
+          );
+        }
+        if (tokenIdentifiers.length > 1) {
+          throw new import_spark_sdk5.SparkValidationError(
+            "Multiple tokens found. Please specify tokenIdentifier in parameters.",
+            {
+              field: "tokenIdentifier",
+              availableTokens: tokenIdentifiers
+            }
+          );
+        }
+        bech32mTokenIdentifier = tokenIdentifiers[0];
+      }
+    }
     const burnAddress = (0, import_spark_sdk5.encodeSparkAddress)({
       identityPublicKey: BURN_ADDRESS,
       network: this.config.getNetworkType()
     });
-    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
     return await this.transferTokens({
-      tokenIdentifier: issuerTokenIdentifier,
+      tokenIdentifier: bech32mTokenIdentifier,
       tokenAmount,
       receiverSparkAddress: burnAddress,
-      selectedOutputs
+      selectedOutputs: outputs
     });
   }
-  /**
-   * Freezes tokens associated with a specific Spark address.
-   * @param sparkAddress - The Spark address whose tokens should be frozen
-   * @returns An object containing the IDs of impacted outputs and the total amount of frozen tokens
-   */
-  async freezeTokens(sparkAddress) {
-    await this.syncTokenOutputs();
+  async freezeTokens(sparkAddressOrParams) {
+    let bech32mTokenIdentifier;
+    let sparkAddress;
+    if (typeof sparkAddressOrParams === "string") {
+      sparkAddress = sparkAddressOrParams;
+      bech32mTokenIdentifier = void 0;
+    } else {
+      sparkAddress = sparkAddressOrParams.sparkAddress;
+      bech32mTokenIdentifier = sparkAddressOrParams.tokenIdentifier;
+    }
     const decodedOwnerPubkey = (0, import_spark_sdk5.decodeSparkAddress)(
       sparkAddress,
       this.config.getNetworkType()
     );
-    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (bech32mTokenIdentifier === void 0) {
+      const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+      if (tokenIdentifiers.length === 0) {
+        throw new import_spark_sdk5.SparkValidationError(
+          "No tokens found. Create a token first."
+        );
+      }
+      if (tokenIdentifiers.length > 1) {
+        throw new import_spark_sdk5.SparkValidationError(
+          "Multiple tokens found. Use freezeTokens({ tokenIdentifier, sparkAddress }) instead.",
+          {
+            field: "tokenIdentifier",
+            availableTokens: tokenIdentifiers
+          }
+        );
+      }
+      bech32mTokenIdentifier = tokenIdentifiers[0];
+    }
     const rawTokenIdentifier = (0, import_spark_sdk5.decodeBech32mTokenIdentifier)(
-      issuerTokenIdentifier,
+      bech32mTokenIdentifier,
       this.config.getNetworkType()
     ).tokenIdentifier;
     const response = await this.tokenFreezeService.freezeTokens({
@@ -611,20 +851,35 @@ var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
       impactedTokenAmount: tokenAmount
     };
   }
-  /**
-   * Unfreezes previously frozen tokens associated with a specific Spark address.
-   * @param sparkAddress - The Spark address whose tokens should be unfrozen
-   * @returns An object containing the IDs of impacted outputs and the total amount of unfrozen tokens
-   */
-  async unfreezeTokens(sparkAddress) {
-    await this.syncTokenOutputs();
+  async unfreezeTokens(sparkAddressOrParams) {
+    let bech32mTokenIdentifier;
+    let sparkAddress;
+    if (typeof sparkAddressOrParams === "string") {
+      sparkAddress = sparkAddressOrParams;
+      bech32mTokenIdentifier = void 0;
+    } else {
+      sparkAddress = sparkAddressOrParams.sparkAddress;
+      bech32mTokenIdentifier = sparkAddressOrParams.tokenIdentifier;
+    }
+    if (bech32mTokenIdentifier === void 0) {
+      const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+      if (tokenIdentifiers.length > 1) {
+        throw new import_spark_sdk5.SparkValidationError(
+          "Multiple tokens found. Use unfreezeTokens({ tokenIdentifier, sparkAddress }) instead.",
+          {
+            field: "tokenIdentifier",
+            availableTokens: tokenIdentifiers
+          }
+        );
+      }
+      bech32mTokenIdentifier = tokenIdentifiers[0];
+    }
     const decodedOwnerPubkey = (0, import_spark_sdk5.decodeSparkAddress)(
       sparkAddress,
       this.config.getNetworkType()
     );
-    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
     const rawTokenIdentifier = (0, import_spark_sdk5.decodeBech32mTokenIdentifier)(
-      issuerTokenIdentifier,
+      bech32mTokenIdentifier,
       this.config.getNetworkType()
     ).tokenIdentifier;
     const response = await this.tokenFreezeService.unfreezeTokens({
@@ -670,8 +925,11 @@ var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
 };
 var PUBLIC_ISSUER_SPARK_WALLET_METHODS = [
   "getIssuerTokenBalance",
+  "getIssuerTokenBalances",
   "getIssuerTokenMetadata",
+  "getIssuerTokensMetadata",
   "getIssuerTokenIdentifier",
+  "getIssuerTokenIdentifiers",
   "createToken",
   "mintTokens",
   "burnTokens",
@@ -681,22 +939,22 @@ var PUBLIC_ISSUER_SPARK_WALLET_METHODS = [
 ];
 
 // src/issuer-wallet/issuer-spark-wallet.node.ts
-var import_spark_sdk6 = require("@buildonspark/spark-sdk");
+var import_spark_sdk7 = require("@buildonspark/spark-sdk");
 var IssuerSparkWalletNodeJS = class extends IssuerSparkWallet {
   buildConnectionManager(config) {
-    return new import_spark_sdk6.ConnectionManager(config);
+    return new import_spark_sdk7.ConnectionManager(config);
   }
   initializeTracerEnv({
     spanProcessors,
     traceUrls
   }) {
-    (0, import_spark_sdk6.initializeTracerEnv)({ spanProcessors, traceUrls });
+    (0, import_spark_sdk7.initializeTracerEnv)({ spanProcessors, traceUrls });
   }
 };
 
 // src/index-shared.ts
-var import_spark_sdk7 = require("@buildonspark/spark-sdk");
 var import_spark_sdk8 = require("@buildonspark/spark-sdk");
+var import_spark_sdk9 = require("@buildonspark/spark-sdk");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DefaultSparkSigner,