@buildonspark/issuer-sdk 0.0.79 → 0.0.81

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @buildonspark/issuer-sdk
 
+## 0.0.81
+
+### Patch Changes
+
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.2.2
+
+## 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

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
@@ -204,13 +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";
@@ -336,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",
@@ -348,7 +440,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
         );
       }
       const metadata = response.tokenMetadata[0];
-      const tokenIdentifier = (0, import_spark_sdk7.encodeBech32mTokenIdentifier)({
+      const tokenIdentifier = (0, import_spark_sdk8.encodeBech32mTokenIdentifier)({
         tokenIdentifier: metadata.tokenIdentifier,
         network: this.config.getNetworkType()
       });
@@ -363,7 +455,7 @@ 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)
       });
@@ -376,11 +468,47 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk4.Spark
    */
   async getIssuerTokenIdentifier() {
     const tokenMetadata = await this.getIssuerTokenMetadata();
-    return (0, import_spark_sdk7.encodeBech32mTokenIdentifier)({
+    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
@@ -415,13 +543,13 @@ 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_sdk4.ValidationError("Issuer token identifier not found");
+      throw new import_spark_sdk5.ValidationError("Issuer token identifier not found");
     }
     return await this.transferTokens({
       tokenIdentifier: issuerTokenIdentifier,
@@ -438,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()
     );
@@ -460,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()
     );
@@ -479,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.
@@ -494,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
@@ -521,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

@@ -86,6 +86,28 @@ declare class IssuerSparkWallet extends SparkWallet {
      * @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

@@ -86,6 +86,28 @@ declare class IssuerSparkWallet extends SparkWallet {
      * @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.js

@@ -1,11 +1,13 @@
-import "./chunk-5MYKP7NN.js";
+import {
+  Buffer
+} from "./chunk-7B4B24XF.js";
 
 // src/issuer-wallet/issuer-spark-wallet.ts
 import { TokenPubkey, TokenPubkeyAnnouncement } from "@buildonspark/lrc20-sdk";
 import {
   NetworkError as NetworkError2,
   SparkWallet,
-  ValidationError as ValidationError2
+  ValidationError as ValidationError3
 } from "@buildonspark/spark-sdk";
 import { isNode } from "@lightsparkdev/core";
 import {
@@ -180,10 +182,102 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
       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: numberToBytesBE(maxSupply, 16),
+          isFreezable
+        }
+      },
+      tokenOutputs: [],
+      clientCreatedTimestamp: /* @__PURE__ */ new Date(),
+      sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
+      expiryTime: void 0
+    };
+  }
 };
 
 // src/issuer-wallet/issuer-spark-wallet.ts
 import { NotImplementedError } from "@buildonspark/spark-sdk";
+
+// src/utils/create-validation.ts
+import { ValidationError as ValidationError2 } from "@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 ValidationError2("Token name must be NFC-normalised UTF-8", {
+      field: "tokenName",
+      value: tokenName,
+      expected: "NFC normalised string"
+    });
+  }
+  if (!isNfcNormalized(tokenTicker)) {
+    throw new ValidationError2("Token ticker must be NFC-normalised UTF-8", {
+      field: "tokenTicker",
+      value: tokenTicker,
+      expected: "NFC normalised string"
+    });
+  }
+  const nameBytes = Buffer.from(tokenName, "utf-8").length;
+  if (nameBytes < MIN_NAME_SIZE || nameBytes > MAX_NAME_SIZE) {
+    throw new ValidationError2(
+      `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 = Buffer.from(tokenTicker, "utf-8").length;
+  if (tickerBytes < MIN_SYMBOL_SIZE || tickerBytes > MAX_SYMBOL_SIZE) {
+    throw new ValidationError2(
+      `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 ValidationError2(
+      `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 ValidationError2(`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
 import {
   encodeBech32mTokenIdentifier
 } from "@buildonspark/spark-sdk";
@@ -314,7 +408,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
         issuerPublicKeys: Array.of(hexToBytes2(issuerPublicKey))
       });
       if (response.tokenMetadata.length === 0) {
-        throw new ValidationError2(
+        throw new ValidationError3(
           "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",
@@ -359,6 +453,42 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
       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(
+      hexToBytes2(issuerPublicKey),
+      tokenName,
+      tokenTicker,
+      decimals,
+      maxSupply,
+      isFreezable
+    );
+    return await this.issuerTokenTransactionService.broadcastTokenTransaction(
+      tokenTransaction
+    );
+  }
   /**
    * Mints new tokens
    * @param tokenAmount - The amount of tokens to mint
@@ -399,7 +529,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
     });
     const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
     if (issuerTokenIdentifier === null) {
-      throw new ValidationError2("Issuer token identifier not found");
+      throw new ValidationError3("Issuer token identifier not found");
     }
     return await this.transferTokens({
       tokenIdentifier: issuerTokenIdentifier,
@@ -472,8 +602,9 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
    * @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 ValidationError2("Decimals must be less than 2^53", {
+      throw new ValidationError3("Decimals must be less than 2^53", {
         field: "decimals",
         value: decimals,
         expected: "smaller or equal to " + Number.MAX_SAFE_INTEGER

package/dist/proto/spark.js

@@ -1,4 +1,4 @@
-import "../chunk-5MYKP7NN.js";
+import "../chunk-7B4B24XF.js";
 
 // src/proto/spark.ts
 export * from "@buildonspark/spark-sdk/proto/spark";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/issuer-sdk",
-  "version": "0.0.79",
+  "version": "0.0.81",
   "description": "Spark Issuer SDK for token issuance",
   "license": "Apache-2.0",
   "module": "./dist/index.js",
@@ -47,15 +47,15 @@
     "package:checks": "yarn depcheck && yarn attw --pack . && echo \"\nPackage checks passed successfully!\"",
     "postversion": "yarn build",
     "test-cmd": "node --experimental-vm-modules $(yarn bin jest) --no-cache --runInBand --detectOpenHandles --forceExit",
-    "test": "echo \"Error: no tests yet\"",
+    "test": "yarn test-cmd src/tests/*.test.ts",
     "test:integration": "HERMETIC_TEST=true yarn test-cmd src/tests/integration/*.test.ts",
     "test:stress": "yarn test-cmd src/tests/stress/*.test.ts",
     "types:watch": "tsc-absolute --watch",
     "types": "tsc"
   },
   "dependencies": {
-    "@buildonspark/lrc20-sdk": "0.0.59",
-    "@buildonspark/spark-sdk": "0.2.0",
+    "@buildonspark/lrc20-sdk": "0.0.60",
+    "@buildonspark/spark-sdk": "0.2.2",
     "@lightsparkdev/core": "^1.4.2",
     "@noble/curves": "^1.8.0",
     "@scure/btc-signer": "^1.5.0",

package/src/issuer-wallet/issuer-spark-wallet.ts

@@ -3,7 +3,6 @@ import {
   NetworkError,
   SparkWallet,
   SparkWalletProps,
-  UserTokenMetadata,
   ValidationError,
 } from "@buildonspark/spark-sdk";
 import { isNode } from "@lightsparkdev/core";
@@ -27,6 +26,7 @@ import { IssuerTokenTransactionService } from "../services/token-transactions.js
 import { TokenDistribution, IssuerTokenMetadata } from "./types.js";
 import { NotImplementedError } from "@buildonspark/spark-sdk";
 import { SparkSigner } from "@buildonspark/spark-sdk";
+import { validateTokenParameters } from "../utils/create-validation.js";
 import {
   encodeBech32mTokenIdentifier,
   Bech32mTokenIdentifier,
@@ -230,6 +230,53 @@ export class IssuerSparkWallet extends SparkWallet {
     });
   }
 
+  /**
+   * 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.
+   */
+  public async createToken({
+    tokenName,
+    tokenTicker,
+    decimals,
+    isFreezable,
+    maxSupply = 0n,
+  }: {
+    tokenName: string;
+    tokenTicker: string;
+    decimals: number;
+    isFreezable: boolean;
+    maxSupply?: bigint;
+  }): Promise<string> {
+    validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply);
+
+    const issuerPublicKey = await super.getIdentityPublicKey();
+
+    const tokenTransaction =
+      await this.issuerTokenTransactionService.constructCreateTokenTransaction(
+        hexToBytes(issuerPublicKey),
+        tokenName,
+        tokenTicker,
+        decimals,
+        maxSupply,
+        isFreezable,
+      );
+
+    return await this.issuerTokenTransactionService.broadcastTokenTransaction(
+      tokenTransaction,
+    );
+  }
+
   /**
    * Mints new tokens
    * @param tokenAmount - The amount of tokens to mint
@@ -373,6 +420,8 @@ export class IssuerSparkWallet extends SparkWallet {
     isFreezable: boolean,
     feeRateSatsPerVb: number = 4.0,
   ): Promise<string> {
+    validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply);
+
     if (!Number.isSafeInteger(decimals)) {
       throw new ValidationError("Decimals must be less than 2^53", {
         field: "decimals",

package/src/services/token-transactions.ts

@@ -66,4 +66,34 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
       expiryTime: undefined,
     };
   }
+
+  async constructCreateTokenTransaction(
+    tokenPublicKey: Uint8Array,
+    tokenName: string,
+    tokenTicker: string,
+    decimals: number,
+    maxSupply: bigint,
+    isFreezable: boolean,
+  ): Promise<TokenTransaction> {
+    return {
+      version: 1,
+      network: this.config.getNetworkProto(),
+      tokenInputs: {
+        $case: "createInput",
+        createInput: {
+          issuerPublicKey: tokenPublicKey,
+          tokenName: tokenName,
+          tokenTicker: tokenTicker,
+          decimals: decimals,
+          maxSupply: numberToBytesBE(maxSupply, 16),
+          isFreezable: isFreezable,
+        },
+      },
+      tokenOutputs: [],
+      clientCreatedTimestamp: new Date(),
+      sparkOperatorIdentityPublicKeys:
+        super.collectOperatorIdentityPublicKeys(),
+      expiryTime: undefined,
+    };
+  }
 }

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

@@ -675,6 +675,37 @@ describe.each(TEST_CONFIGS)(
     //   expect(transferBackTransaction).toBeDefined();
     //   expect(userBurnTransaction).toBeDefined();
     // });
+
+    (config.tokenTransactionVersion === "V0" ? it.skip : it)(
+      "should create a token using createToken API",
+      async () => {
+        const { wallet: issuerWallet } =
+          await IssuerSparkWalletTesting.initialize({
+            options: config,
+          });
+
+        const tokenName = `${name}Creatable`;
+        const tokenTicker = "CRT";
+        const maxSupply = 5000n;
+        const decimals = 0;
+        const txId = await issuerWallet.createToken({
+          tokenName,
+          tokenTicker,
+          decimals,
+          isFreezable: false,
+          maxSupply,
+        });
+
+        expect(typeof txId).toBe("string");
+        expect(txId.length).toBeGreaterThan(0);
+
+        const metadata = await issuerWallet.getIssuerTokenMetadata();
+        expect(metadata.tokenName).toEqual(tokenName);
+        expect(metadata.tokenTicker).toEqual(tokenTicker);
+        expect(metadata.maxSupply).toEqual(maxSupply);
+        expect(metadata.decimals).toEqual(decimals);
+      },
+    );
   },
 );
 

package/src/tests/token-create.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "@jest/globals";
+import { validateTokenParameters } from "../utils/create-validation.js";
+
+const MAX_SUPPLY_128 = (1n << 128n) - 1n;
+
+describe("validateTokenParameters (V1)", () => {
+  describe("valid inputs", () => {
+    it("accepts minimum & maximum byte length for name", () => {
+      expect(() => validateTokenParameters("abc", "AAA", 0, 1n)).not.toThrow();
+      expect(() =>
+        validateTokenParameters("12345678901234567890", "AAA", 0, 1n),
+      ).not.toThrow();
+    });
+
+    it("accepts minimum & maximum byte length for symbol", () => {
+      expect(() =>
+        validateTokenParameters("Token", "ABC", 0, 1n),
+      ).not.toThrow();
+      expect(() =>
+        validateTokenParameters("Token", "ABCDEF", 0, 1n),
+      ).not.toThrow();
+    });
+
+    it("accepts combined length exactly at upper bound", () => {
+      // name 17 bytes + symbol 3 bytes = 20 bytes
+      expect(() =>
+        validateTokenParameters("ABCDEFGHIJKLMNOPQ", "AAA", 0, 1n),
+      ).not.toThrow();
+    });
+
+    it("accepts decimals within 0-255 and maxSupply within u128", () => {
+      expect(() =>
+        validateTokenParameters("Token", "TOK", 255, MAX_SUPPLY_128),
+      ).not.toThrow();
+    });
+
+    it("handles multi-byte UTF-8 characters correctly", () => {
+      // "🚀" is 4 bytes in UTF-8
+      expect(() =>
+        validateTokenParameters("Tok🚀n", "TOK", 8, 1000n),
+      ).not.toThrow();
+    });
+  });
+
+  describe("invalid inputs", () => {
+    it("rejects name too short or too long", () => {
+      expect(() => validateTokenParameters("ab", "AAA", 0, 1n)).toThrow();
+      expect(() =>
+        validateTokenParameters("123456789012345678901", "AAA", 0, 1n),
+      ).toThrow();
+    });
+
+    it("rejects symbol too short or too long", () => {
+      expect(() => validateTokenParameters("Token", "AB", 0, 1n)).toThrow();
+      expect(() =>
+        validateTokenParameters("Token", "ABCDEFG", 0, 1n),
+      ).toThrow();
+    });
+
+    it("rejects decimals outside 0-255 or non-integer", () => {
+      // >255
+      expect(() => validateTokenParameters("Token", "TOK", 256, 1n)).toThrow();
+      // negative
+      expect(() => validateTokenParameters("Token", "TOK", -1, 1n)).toThrow();
+      // non-integer (should be rejected by safe-integer check)
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore intentional wrong type for test
+      expect(() => validateTokenParameters("Token", "TOK", 1.5, 1n)).toThrow();
+    });
+
+    it("rejects decimals >= 2^53", () => {
+      const hugeDecimal = 2 ** 53;
+      expect(() =>
+        validateTokenParameters("Token", "TOK", hugeDecimal, 1n),
+      ).toThrow();
+    });
+
+    it("rejects maxSupply outside u128 range", () => {
+      expect(() => validateTokenParameters("Token", "TOK", 0, -1n)).toThrow();
+      expect(() =>
+        validateTokenParameters("Token", "TOK", 0, MAX_SUPPLY_128 + 1n),
+      ).toThrow();
+    });
+  });
+});

package/src/utils/create-validation.ts

@@ -0,0 +1,92 @@
+import { ValidationError } from "@buildonspark/spark-sdk";
+
+/**
+ * Returns true when the input is already in NFC normalisation form.
+ * JavaScript strings are UTF-16 encoded, so any JavaScript string is
+ * already valid Unicode.  However, we still need to ensure canonical
+ * equivalence so that, for example, \u00E9 (é) and \u0065\u0301 (é)
+ * are treated identically.  We do this by comparing the original
+ * string to its NFC-normalised representation.
+ */
+function isNfcNormalized(value: string): boolean {
+  return value.normalize("NFC") === value;
+}
+
+const MIN_NAME_SIZE = 3; // bytes
+const MAX_NAME_SIZE = 20; // bytes
+const MIN_SYMBOL_SIZE = 3; // bytes
+const MAX_SYMBOL_SIZE = 6; // bytes
+const MAX_DECIMALS = 255; // fits into single byte
+const MAXIMUM_MAX_SUPPLY = (1n << 128n) - 1n; // fits into 16 bytes (u128)
+
+export function validateTokenParameters(
+  tokenName: string,
+  tokenTicker: string,
+  decimals: number,
+  maxSupply: bigint,
+) {
+  if (!isNfcNormalized(tokenName)) {
+    throw new ValidationError("Token name must be NFC-normalised UTF-8", {
+      field: "tokenName",
+      value: tokenName,
+      expected: "NFC normalised string",
+    });
+  }
+
+  if (!isNfcNormalized(tokenTicker)) {
+    throw new ValidationError("Token ticker must be NFC-normalised UTF-8", {
+      field: "tokenTicker",
+      value: tokenTicker,
+      expected: "NFC normalised string",
+    });
+  }
+
+  const nameBytes = Buffer.from(tokenName, "utf-8").length;
+  if (nameBytes < MIN_NAME_SIZE || nameBytes > MAX_NAME_SIZE) {
+    throw new 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 = Buffer.from(tokenTicker, "utf-8").length;
+  if (tickerBytes < MIN_SYMBOL_SIZE || tickerBytes > MAX_SYMBOL_SIZE) {
+    throw new 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 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 ValidationError(`maxSupply must be between 0 and 2^128-1`, {
+      field: "maxSupply",
+      value: maxSupply.toString(),
+      expected: `>=0 and <=${MAXIMUM_MAX_SUPPLY.toString()}`,
+    });
+  }
+}