@buildonspark/issuer-sdk 0.0.78 → 0.0.80

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 {
@@ -157,20 +159,21 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
       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: numberToBytesBE(tokenAmount, 16)
         }
       ],
@@ -179,10 +182,105 @@ 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";
 var BURN_ADDRESS = "02".repeat(33);
 var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
   issuerTokenTransactionService;
@@ -218,6 +316,10 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
       "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)
@@ -266,22 +368,28 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
     );
     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]) => bytesToHex(metadata.issuerPublicKey) === issuerPublicKey
+    );
+    if (cachedIssuerTokenMetadata !== void 0) {
+      const metadata = cachedIssuerTokenMetadata[1];
       return {
         tokenPublicKey: bytesToHex(metadata.issuerPublicKey),
         rawTokenIdentifier: metadata.tokenIdentifier,
@@ -300,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",
@@ -312,7 +420,11 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
         );
       }
       const metadata = response.tokenMetadata[0];
-      this.tokenMetadata.set(issuerPublicKey, metadata);
+      const tokenIdentifier = encodeBech32mTokenIdentifier({
+        tokenIdentifier: metadata.tokenIdentifier,
+        network: this.config.getNetworkType()
+      });
+      this.tokenMetadata.set(tokenIdentifier, metadata);
       return {
         tokenPublicKey: bytesToHex(metadata.issuerPublicKey),
         rawTokenIdentifier: metadata.tokenIdentifier,
@@ -329,22 +441,74 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
       });
     }
   }
+  /**
+   * 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 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(
+      hexToBytes2(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 = hexToBytes2(issuerTokenPublicKey);
+    const tokenMetadata = await this.getIssuerTokenMetadata();
+    const rawTokenIdentifier = tokenMetadata.rawTokenIdentifier;
     if (this.config.getTokenTransactionVersion() === "V0") {
       tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransactionV0(
-        hexToBytes2(tokenPublicKey),
+        issuerTokenPublicKeyBytes,
         tokenAmount
       );
     } else {
       tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-        hexToBytes2(tokenPublicKey),
+        rawTokenIdentifier,
+        issuerTokenPublicKeyBytes,
         tokenAmount
       );
     }
@@ -363,8 +527,12 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
       identityPublicKey: BURN_ADDRESS,
       network: this.config.getNetworkType()
     });
+    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new ValidationError3("Issuer token identifier not found");
+    }
     return await this.transferTokens({
-      tokenPublicKey: await super.getIdentityPublicKey(),
+      tokenIdentifier: issuerTokenIdentifier,
       tokenAmount,
       receiverSparkAddress: burnAddress,
       selectedOutputs
@@ -434,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.78",
+  "version": "0.0.80",
   "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.1.47",
+    "@buildonspark/lrc20-sdk": "0.0.60",
+    "@buildonspark/spark-sdk": "0.2.1",
     "@lightsparkdev/core": "^1.4.2",
     "@noble/curves": "^1.8.0",
     "@scure/btc-signer": "^1.5.0",

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

@@ -26,6 +26,11 @@ 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,
+} from "@buildonspark/spark-sdk";
 
 const BURN_ADDRESS = "02".repeat(33);
 
@@ -73,6 +78,10 @@ export class IssuerSparkWallet extends SparkWallet {
       "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),
@@ -116,6 +125,7 @@ export class IssuerSparkWallet extends SparkWallet {
    * @returns An object containing the token balance as a bigint
    */
   public async getIssuerTokenBalance(): Promise<{
+    tokenIdentifier: Bech32mTokenIdentifier | undefined;
     balance: bigint;
   }> {
     const publicKey = await super.getIdentityPublicKey();
@@ -126,24 +136,31 @@ export class IssuerSparkWallet extends SparkWallet {
 
     if (!balanceObj.tokenBalances || issuerBalance === undefined) {
       return {
+        tokenIdentifier: undefined,
         balance: 0n,
       };
     }
     return {
+      tokenIdentifier: issuerBalance[0] ?? undefined,
       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
    */
   public async getIssuerTokenMetadata(): Promise<IssuerTokenMetadata> {
     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]) =>
+        bytesToHex(metadata.issuerPublicKey) === issuerPublicKey,
+    );
+    if (cachedIssuerTokenMetadata !== undefined) {
+      const metadata = cachedIssuerTokenMetadata[1];
       return {
         tokenPublicKey: bytesToHex(metadata.issuerPublicKey),
         rawTokenIdentifier: metadata.tokenIdentifier,
@@ -163,7 +180,6 @@ export class IssuerSparkWallet extends SparkWallet {
       const response = await sparkTokenClient.query_token_metadata({
         issuerPublicKeys: Array.of(hexToBytes(issuerPublicKey)),
       });
-
       if (response.tokenMetadata.length === 0) {
         throw new 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.",
@@ -176,9 +192,12 @@ export class IssuerSparkWallet extends SparkWallet {
           },
         );
       }
-
       const metadata = response.tokenMetadata[0];
-      this.tokenMetadata.set(issuerPublicKey, metadata);
+      const tokenIdentifier = encodeBech32mTokenIdentifier({
+        tokenIdentifier: metadata.tokenIdentifier,
+        network: this.config.getNetworkType(),
+      });
+      this.tokenMetadata.set(tokenIdentifier, metadata);
 
       return {
         tokenPublicKey: bytesToHex(metadata.issuerPublicKey),
@@ -197,25 +216,91 @@ export class IssuerSparkWallet extends SparkWallet {
     }
   }
 
+  /**
+   * 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
+   */
+  public async getIssuerTokenIdentifier(): Promise<Bech32mTokenIdentifier | null> {
+    const tokenMetadata = await this.getIssuerTokenMetadata();
+
+    return 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.
+   */
+  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
    * @returns The transaction ID of the mint operation
    */
   public async mintTokens(tokenAmount: bigint): Promise<string> {
-    const tokenPublicKey = await super.getIdentityPublicKey();
     let tokenTransaction: TokenTransactionV0 | TokenTransaction;
+    const issuerTokenPublicKey = await super.getIdentityPublicKey();
+    const issuerTokenPublicKeyBytes = hexToBytes(issuerTokenPublicKey);
+
+    const tokenMetadata = await this.getIssuerTokenMetadata();
+    const rawTokenIdentifier: Uint8Array = tokenMetadata.rawTokenIdentifier;
 
     if (this.config.getTokenTransactionVersion() === "V0") {
       tokenTransaction =
         await this.issuerTokenTransactionService.constructMintTokenTransactionV0(
-          hexToBytes(tokenPublicKey),
+          issuerTokenPublicKeyBytes,
           tokenAmount,
         );
     } else {
       tokenTransaction =
         await this.issuerTokenTransactionService.constructMintTokenTransaction(
-          hexToBytes(tokenPublicKey),
+          rawTokenIdentifier,
+          issuerTokenPublicKeyBytes,
           tokenAmount,
         );
     }
@@ -239,8 +324,14 @@ export class IssuerSparkWallet extends SparkWallet {
       identityPublicKey: BURN_ADDRESS,
       network: this.config.getNetworkType(),
     });
+    const issuerTokenIdentifier: Bech32mTokenIdentifier | null =
+      await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new ValidationError("Issuer token identifier not found");
+    }
+
     return await this.transferTokens({
-      tokenPublicKey: await super.getIdentityPublicKey(),
+      tokenIdentifier: issuerTokenIdentifier,
       tokenAmount,
       receiverSparkAddress: burnAddress,
       selectedOutputs,
@@ -329,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

@@ -39,7 +39,8 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
   }
 
   async constructMintTokenTransaction(
-    tokenPublicKey: Uint8Array,
+    rawTokenIdentifierBytes: Uint8Array,
+    issuerTokenPublicKey: Uint8Array,
     tokenAmount: bigint,
   ): Promise<TokenTransaction> {
     return {
@@ -48,13 +49,14 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
       tokenInputs: {
         $case: "mintInput",
         mintInput: {
-          issuerPublicKey: tokenPublicKey,
+          issuerPublicKey: issuerTokenPublicKey,
+          tokenIdentifier: rawTokenIdentifierBytes,
         },
       },
       tokenOutputs: [
         {
-          ownerPublicKey: tokenPublicKey,
-          tokenPublicKey: tokenPublicKey,
+          ownerPublicKey: issuerTokenPublicKey,
+          tokenIdentifier: rawTokenIdentifierBytes,
           tokenAmount: numberToBytesBE(tokenAmount, 16),
         },
       ],
@@ -64,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,
+    };
+  }
 }