@buildonspark/issuer-sdk 0.0.78 → 0.0.80

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @buildonspark/issuer-sdk
 
+## 0.0.80
+
+### Patch Changes
+
+- tokens changes
+  - Bech32mTokenIdentifier prefix change from "btk" -> "btkn"
+
+- Updated dependencies
+  - @buildonspark/lrc20-sdk@0.0.60
+  - @buildonspark/spark-sdk@0.2.1
+
+## 0.0.79
+
+### Patch Changes
+
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.2.0
+
 ## 0.0.78
 
 ### Patch Changes

package/dist/{chunk-5MYKP7NN.js → chunk-7B4B24XF.js}

@@ -11,3 +11,7 @@ if (typeof window !== "undefined") {
     window.globalThis = window;
   }
 }
+
+export {
+  Buffer
+};

package/dist/index.cjs

@@ -40,9 +40,9 @@ if (typeof window !== "undefined") {
 
 // src/issuer-wallet/issuer-spark-wallet.ts
 var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
-var import_spark_sdk4 = require("@buildonspark/spark-sdk");
-var import_core = require("@lightsparkdev/core");
 var import_spark_sdk5 = require("@buildonspark/spark-sdk");
+var import_core = require("@lightsparkdev/core");
+var import_spark_sdk6 = require("@buildonspark/spark-sdk");
 var import_utils4 = require("@noble/curves/abstract/utils");
 
 // src/services/freeze.ts
@@ -181,20 +181,21 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys()
     };
   }
-  async constructMintTokenTransaction(tokenPublicKey, tokenAmount) {
+  async constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
     return {
       version: 1,
       network: this.config.getNetworkProto(),
       tokenInputs: {
         $case: "mintInput",
         mintInput: {
-          issuerPublicKey: tokenPublicKey
+          issuerPublicKey: issuerTokenPublicKey,
+          tokenIdentifier: rawTokenIdentifierBytes
         }
       },
       tokenOutputs: [
         {
-          ownerPublicKey: tokenPublicKey,
-          tokenPublicKey,
+          ownerPublicKey: issuerTokenPublicKey,
+          tokenIdentifier: rawTokenIdentifierBytes,
           tokenAmount: (0, import_utils3.numberToBytesBE)(tokenAmount, 16)
         }
       ],
@@ -203,12 +204,105 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
       expiryTime: void 0
     };
   }
+  async constructCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable) {
+    return {
+      version: 1,
+      network: this.config.getNetworkProto(),
+      tokenInputs: {
+        $case: "createInput",
+        createInput: {
+          issuerPublicKey: tokenPublicKey,
+          tokenName,
+          tokenTicker,
+          decimals,
+          maxSupply: (0, import_utils3.numberToBytesBE)(maxSupply, 16),
+          isFreezable
+        }
+      },
+      tokenOutputs: [],
+      clientCreatedTimestamp: /* @__PURE__ */ new Date(),
+      sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
+      expiryTime: void 0
+    };
+  }
 };
 
 // src/issuer-wallet/issuer-spark-wallet.ts
-var import_spark_sdk6 = require("@buildonspark/spark-sdk");
+var import_spark_sdk7 = require("@buildonspark/spark-sdk");
+
+// src/utils/create-validation.ts
+var import_spark_sdk4 = require("@buildonspark/spark-sdk");
+function isNfcNormalized(value) {
+  return value.normalize("NFC") === value;
+}
+var MIN_NAME_SIZE = 3;
+var MAX_NAME_SIZE = 20;
+var MIN_SYMBOL_SIZE = 3;
+var MAX_SYMBOL_SIZE = 6;
+var MAX_DECIMALS = 255;
+var MAXIMUM_MAX_SUPPLY = (1n << 128n) - 1n;
+function validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply) {
+  if (!isNfcNormalized(tokenName)) {
+    throw new import_spark_sdk4.ValidationError("Token name must be NFC-normalised UTF-8", {
+      field: "tokenName",
+      value: tokenName,
+      expected: "NFC normalised string"
+    });
+  }
+  if (!isNfcNormalized(tokenTicker)) {
+    throw new import_spark_sdk4.ValidationError("Token ticker must be NFC-normalised UTF-8", {
+      field: "tokenTicker",
+      value: tokenTicker,
+      expected: "NFC normalised string"
+    });
+  }
+  const nameBytes = import_buffer.Buffer.from(tokenName, "utf-8").length;
+  if (nameBytes < MIN_NAME_SIZE || nameBytes > MAX_NAME_SIZE) {
+    throw new import_spark_sdk4.ValidationError(
+      `Token name must be between ${MIN_NAME_SIZE} and ${MAX_NAME_SIZE} bytes`,
+      {
+        field: "tokenName",
+        value: tokenName,
+        actualLength: nameBytes,
+        expected: `>=${MIN_NAME_SIZE} and <=${MAX_NAME_SIZE}`
+      }
+    );
+  }
+  const tickerBytes = import_buffer.Buffer.from(tokenTicker, "utf-8").length;
+  if (tickerBytes < MIN_SYMBOL_SIZE || tickerBytes > MAX_SYMBOL_SIZE) {
+    throw new import_spark_sdk4.ValidationError(
+      `Token ticker must be between ${MIN_SYMBOL_SIZE} and ${MAX_SYMBOL_SIZE} bytes`,
+      {
+        field: "tokenTicker",
+        value: tokenTicker,
+        actualLength: tickerBytes,
+        expected: `>=${MIN_SYMBOL_SIZE} and <=${MAX_SYMBOL_SIZE}`
+      }
+    );
+  }
+  if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > MAX_DECIMALS) {
+    throw new import_spark_sdk4.ValidationError(
+      `Decimals must be an integer between 0 and ${MAX_DECIMALS}`,
+      {
+        field: "decimals",
+        value: decimals,
+        expected: `>=0 and <=${MAX_DECIMALS}`
+      }
+    );
+  }
+  if (maxSupply < 0n || maxSupply > MAXIMUM_MAX_SUPPLY) {
+    throw new import_spark_sdk4.ValidationError(`maxSupply must be between 0 and 2^128-1`, {
+      field: "maxSupply",
+      value: maxSupply.toString(),
+      expected: `>=0 and <=${MAXIMUM_MAX_SUPPLY.toString()}`
+    });
+  }
+}
+
+// src/issuer-wallet/issuer-spark-wallet.ts
+var import_spark_sdk8 = require("@buildonspark/spark-sdk");
 var BURN_ADDRESS = "02".repeat(33);
-var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.SparkWallet {
+var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.SparkWallet {
   issuerTokenTransactionService;
   tokenFreezeService;
   tracerId = "issuer-sdk";
@@ -242,6 +336,10 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
       "SparkIssuerWallet.getIssuerTokenMetadata",
       this.getIssuerTokenMetadata.bind(this)
     );
+    this.getIssuerTokenIdentifier = this.wrapWithOtelSpan(
+      "SparkIssuerWallet.getIssuerTokenIdentifier",
+      this.getIssuerTokenIdentifier.bind(this)
+    );
     this.mintTokens = this.wrapWithOtelSpan(
       "SparkIssuerWallet.mintTokens",
       this.mintTokens.bind(this)
@@ -290,22 +388,28 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
     );
     if (!balanceObj.tokenBalances || issuerBalance === void 0) {
       return {
+        tokenIdentifier: void 0,
         balance: 0n
       };
     }
     return {
+      tokenIdentifier: issuerBalance[0] ?? void 0,
       balance: issuerBalance[1].balance
     };
   }
   /**
-   * Retrieves metadata about the issuer's token.
+   * Retrieves information about the issuer's token.
    * @returns An object containing token information including public key, name, symbol, decimals, max supply, and freeze status
    * @throws {NetworkError} If the token metadata cannot be retrieved
    */
   async getIssuerTokenMetadata() {
     const issuerPublicKey = await super.getIdentityPublicKey();
-    if (this.tokenMetadata.has(issuerPublicKey)) {
-      const metadata = this.tokenMetadata.get(issuerPublicKey);
+    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,
@@ -324,7 +428,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
         issuerPublicKeys: Array.of((0, import_utils4.hexToBytes)(issuerPublicKey))
       });
       if (response.tokenMetadata.length === 0) {
-        throw new import_spark_sdk4.ValidationError(
+        throw new import_spark_sdk5.ValidationError(
           "Token metadata not found - If a token has not yet been announced, please announce. If a token was recently announced, it is being confirmed. Try again in a few seconds.",
           {
             field: "tokenMetadata",
@@ -336,7 +440,11 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
         );
       }
       const metadata = response.tokenMetadata[0];
-      this.tokenMetadata.set(issuerPublicKey, metadata);
+      const tokenIdentifier = (0, import_spark_sdk8.encodeBech32mTokenIdentifier)({
+        tokenIdentifier: metadata.tokenIdentifier,
+        network: this.config.getNetworkType()
+      });
+      this.tokenMetadata.set(tokenIdentifier, metadata);
       return {
         tokenPublicKey: (0, import_utils4.bytesToHex)(metadata.issuerPublicKey),
         rawTokenIdentifier: metadata.tokenIdentifier,
@@ -347,28 +455,80 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
         isFreezable: metadata.isFreezable
       };
     } catch (error) {
-      throw new import_spark_sdk4.NetworkError("Failed to fetch token metadata", {
+      throw new import_spark_sdk5.NetworkError("Failed to fetch token metadata", {
         errorCount: 1,
         errors: error instanceof Error ? error.message : String(error)
       });
     }
   }
+  /**
+   * Retrieves the bech32m encoded token identifier for the issuer's token.
+   * @returns The bech32m encoded token identifier for the issuer's token
+   * @throws {NetworkError} If the token identifier cannot be retrieved
+   */
+  async getIssuerTokenIdentifier() {
+    const tokenMetadata = await this.getIssuerTokenMetadata();
+    return (0, import_spark_sdk8.encodeBech32mTokenIdentifier)({
+      tokenIdentifier: tokenMetadata.rawTokenIdentifier,
+      network: this.config.getNetworkType()
+    });
+  }
+  /**
+   * 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>.
+   *
+   * @returns The transaction ID of the announcement.
+   *
+   * @throws {ValidationError} If `decimals` is not a safe integer or other validation fails.
+   * @throws {NetworkError} If the announcement transaction cannot be broadcast.
+   */
+  async createToken({
+    tokenName,
+    tokenTicker,
+    decimals,
+    isFreezable,
+    maxSupply = 0n
+  }) {
+    validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply);
+    const issuerPublicKey = await super.getIdentityPublicKey();
+    const tokenTransaction = await this.issuerTokenTransactionService.constructCreateTokenTransaction(
+      (0, import_utils4.hexToBytes)(issuerPublicKey),
+      tokenName,
+      tokenTicker,
+      decimals,
+      maxSupply,
+      isFreezable
+    );
+    return await this.issuerTokenTransactionService.broadcastTokenTransaction(
+      tokenTransaction
+    );
+  }
   /**
    * Mints new tokens
    * @param tokenAmount - The amount of tokens to mint
    * @returns The transaction ID of the mint operation
    */
   async mintTokens(tokenAmount) {
-    const tokenPublicKey = await super.getIdentityPublicKey();
     let tokenTransaction;
+    const issuerTokenPublicKey = await super.getIdentityPublicKey();
+    const issuerTokenPublicKeyBytes = (0, import_utils4.hexToBytes)(issuerTokenPublicKey);
+    const tokenMetadata = await this.getIssuerTokenMetadata();
+    const rawTokenIdentifier = tokenMetadata.rawTokenIdentifier;
     if (this.config.getTokenTransactionVersion() === "V0") {
       tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransactionV0(
-        (0, import_utils4.hexToBytes)(tokenPublicKey),
+        issuerTokenPublicKeyBytes,
         tokenAmount
       );
     } else {
       tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-        (0, import_utils4.hexToBytes)(tokenPublicKey),
+        rawTokenIdentifier,
+        issuerTokenPublicKeyBytes,
         tokenAmount
       );
     }
@@ -383,12 +543,16 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
    * @returns The transaction ID of the burn operation
    */
   async burnTokens(tokenAmount, selectedOutputs) {
-    const burnAddress = (0, import_spark_sdk5.encodeSparkAddress)({
+    const burnAddress = (0, import_spark_sdk6.encodeSparkAddress)({
       identityPublicKey: BURN_ADDRESS,
       network: this.config.getNetworkType()
     });
+    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new import_spark_sdk5.ValidationError("Issuer token identifier not found");
+    }
     return await this.transferTokens({
-      tokenPublicKey: await super.getIdentityPublicKey(),
+      tokenIdentifier: issuerTokenIdentifier,
       tokenAmount,
       receiverSparkAddress: burnAddress,
       selectedOutputs
@@ -402,7 +566,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
   async freezeTokens(sparkAddress) {
     await this.syncTokenOutputs();
     const tokenPublicKey = await super.getIdentityPublicKey();
-    const decodedOwnerPubkey = (0, import_spark_sdk5.decodeSparkAddress)(
+    const decodedOwnerPubkey = (0, import_spark_sdk6.decodeSparkAddress)(
       sparkAddress,
       this.config.getNetworkType()
     );
@@ -424,7 +588,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
   async unfreezeTokens(sparkAddress) {
     await this.syncTokenOutputs();
     const tokenPublicKey = await super.getIdentityPublicKey();
-    const decodedOwnerPubkey = (0, import_spark_sdk5.decodeSparkAddress)(
+    const decodedOwnerPubkey = (0, import_spark_sdk6.decodeSparkAddress)(
       sparkAddress,
       this.config.getNetworkType()
     );
@@ -443,7 +607,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
    * @throws {NotImplementedError} This feature is not yet supported
    */
   async getIssuerTokenDistribution() {
-    throw new import_spark_sdk6.NotImplementedError("Token distribution is not yet supported");
+    throw new import_spark_sdk7.NotImplementedError("Token distribution is not yet supported");
   }
   /**
    * Announces a new token on the L1 (Bitcoin) network.
@@ -458,8 +622,9 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
    * @throws {NetworkError} If the announcement transaction cannot be broadcast
    */
   async announceTokenL1(tokenName, tokenTicker, decimals, maxSupply, isFreezable, feeRateSatsPerVb = 4) {
+    validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply);
     if (!Number.isSafeInteger(decimals)) {
-      throw new import_spark_sdk4.ValidationError("Decimals must be less than 2^53", {
+      throw new import_spark_sdk5.ValidationError("Decimals must be less than 2^53", {
         field: "decimals",
         value: decimals,
         expected: "smaller or equal to " + Number.MAX_SAFE_INTEGER
@@ -485,7 +650,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
       );
       return txId;
     } catch (error) {
-      throw new import_spark_sdk4.NetworkError(
+      throw new import_spark_sdk5.NetworkError(
         "Failed to broadcast announcement transaction on L1",
         {
           operation: "broadcastRawBtcTransaction",

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { SparkWallet, SparkWalletProps, ConfigOptions, SparkSigner } from '@buildonspark/spark-sdk';
+import { SparkWallet, SparkWalletProps, ConfigOptions, SparkSigner, Bech32mTokenIdentifier } from '@buildonspark/spark-sdk';
 import { OutputWithPreviousTransactionData } from '@buildonspark/spark-sdk/proto/spark';
 
 /**
@@ -71,14 +71,43 @@ declare class IssuerSparkWallet extends SparkWallet {
      * @returns An object containing the token balance as a bigint
      */
     getIssuerTokenBalance(): Promise<{
+        tokenIdentifier: Bech32mTokenIdentifier | undefined;
         balance: bigint;
     }>;
     /**
-     * Retrieves metadata about the issuer's token.
+     * Retrieves information about the issuer's token.
      * @returns An object containing token information including public key, name, symbol, decimals, max supply, and freeze status
      * @throws {NetworkError} If the token metadata cannot be retrieved
      */
     getIssuerTokenMetadata(): Promise<IssuerTokenMetadata>;
+    /**
+     * Retrieves the bech32m encoded token identifier for the issuer's token.
+     * @returns The bech32m encoded token identifier for the issuer's token
+     * @throws {NetworkError} If the token identifier cannot be retrieved
+     */
+    getIssuerTokenIdentifier(): Promise<Bech32mTokenIdentifier | null>;
+    /**
+     * 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>.
+     *
+     * @returns The transaction ID of the announcement.
+     *
+     * @throws {ValidationError} If `decimals` is not a safe integer or other validation fails.
+     * @throws {NetworkError} If the announcement transaction cannot be broadcast.
+     */
+    createToken({ tokenName, tokenTicker, decimals, isFreezable, maxSupply, }: {
+        tokenName: string;
+        tokenTicker: string;
+        decimals: number;
+        isFreezable: boolean;
+        maxSupply?: bigint;
+    }): Promise<string>;
     /**
      * Mints new tokens
      * @param tokenAmount - The amount of tokens to mint

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SparkWallet, SparkWalletProps, ConfigOptions, SparkSigner } from '@buildonspark/spark-sdk';
+import { SparkWallet, SparkWalletProps, ConfigOptions, SparkSigner, Bech32mTokenIdentifier } from '@buildonspark/spark-sdk';
 import { OutputWithPreviousTransactionData } from '@buildonspark/spark-sdk/proto/spark';
 
 /**
@@ -71,14 +71,43 @@ declare class IssuerSparkWallet extends SparkWallet {
      * @returns An object containing the token balance as a bigint
      */
     getIssuerTokenBalance(): Promise<{
+        tokenIdentifier: Bech32mTokenIdentifier | undefined;
         balance: bigint;
     }>;
     /**
-     * Retrieves metadata about the issuer's token.
+     * Retrieves information about the issuer's token.
      * @returns An object containing token information including public key, name, symbol, decimals, max supply, and freeze status
      * @throws {NetworkError} If the token metadata cannot be retrieved
      */
     getIssuerTokenMetadata(): Promise<IssuerTokenMetadata>;
+    /**
+     * Retrieves the bech32m encoded token identifier for the issuer's token.
+     * @returns The bech32m encoded token identifier for the issuer's token
+     * @throws {NetworkError} If the token identifier cannot be retrieved
+     */
+    getIssuerTokenIdentifier(): Promise<Bech32mTokenIdentifier | null>;
+    /**
+     * 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>.
+     *
+     * @returns The transaction ID of the announcement.
+     *
+     * @throws {ValidationError} If `decimals` is not a safe integer or other validation fails.
+     * @throws {NetworkError} If the announcement transaction cannot be broadcast.
+     */
+    createToken({ tokenName, tokenTicker, decimals, isFreezable, maxSupply, }: {
+        tokenName: string;
+        tokenTicker: string;
+        decimals: number;
+        isFreezable: boolean;
+        maxSupply?: bigint;
+    }): Promise<string>;
     /**
      * Mints new tokens
      * @param tokenAmount - The amount of tokens to mint