@buildonspark/issuer-sdk 0.1.34 → 0.1.36

package/dist/native/index.react-native.js

@@ -10,7 +10,7 @@ function hashFreezeTokensPayload(payload) {
 		value: payload,
 		expected: "valid freeze tokens payload"
 	});
-	let allHashes = [];
+	const allHashes = [];
 	const versionHashObj = sha256.create();
 	const versionBytes = new Uint8Array(4);
 	new DataView(versionBytes.buffer).setUint32(0, payload.version, false);
@@ -136,101 +136,109 @@ var IssuerTokenTransactionService = class extends TokenTransactionService {
 	constructor(config, connectionManager) {
 		super(config, connectionManager);
 	}
-	async constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
-		return {
-			version: 2,
-			network: this.config.getNetworkProto(),
-			tokenInputs: {
-				$case: "mintInput",
-				mintInput: {
-					issuerPublicKey: issuerTokenPublicKey,
-					tokenIdentifier: rawTokenIdentifierBytes
-				}
-			},
-			tokenOutputs: [{
-				ownerPublicKey: issuerTokenPublicKey,
-				tokenIdentifier: rawTokenIdentifierBytes,
-				tokenAmount: numberToBytesBE(tokenAmount, 16)
-			}],
-			clientCreatedTimestamp: /* @__PURE__ */ new Date(),
-			sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
-			expiryTime: void 0,
-			invoiceAttachments: []
-		};
-	}
-	async constructPartialMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
-		return {
-			version: 3,
-			tokenTransactionMetadata: {
+	constructMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
+		return new Promise((resolve) => {
+			resolve({
+				version: 2,
 				network: this.config.getNetworkProto(),
-				sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
-				validityDurationSeconds: await this.config.getTokenValidityDurationSeconds(),
-				clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
+				tokenInputs: {
+					$case: "mintInput",
+					mintInput: {
+						issuerPublicKey: issuerTokenPublicKey,
+						tokenIdentifier: rawTokenIdentifierBytes
+					}
+				},
+				tokenOutputs: [{
+					ownerPublicKey: issuerTokenPublicKey,
+					tokenIdentifier: rawTokenIdentifierBytes,
+					tokenAmount: numberToBytesBE(tokenAmount, 16)
+				}],
+				clientCreatedTimestamp: /* @__PURE__ */ new Date(),
+				sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
+				expiryTime: void 0,
 				invoiceAttachments: []
-			},
-			tokenInputs: {
-				$case: "mintInput",
-				mintInput: {
-					issuerPublicKey: issuerTokenPublicKey,
-					tokenIdentifier: rawTokenIdentifierBytes
-				}
-			},
-			partialTokenOutputs: [{
-				ownerPublicKey: issuerTokenPublicKey,
-				tokenIdentifier: rawTokenIdentifierBytes,
-				withdrawBondSats: this.config.getExpectedWithdrawBondSats(),
-				withdrawRelativeBlockLocktime: this.config.getExpectedWithdrawRelativeBlockLocktime(),
-				tokenAmount: numberToBytesBE(tokenAmount, 16)
-			}]
-		};
+			});
+		});
 	}
-	async constructCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata) {
-		return {
-			version: 2,
-			network: this.config.getNetworkProto(),
-			tokenInputs: {
-				$case: "createInput",
-				createInput: {
-					issuerPublicKey: tokenPublicKey,
-					tokenName,
-					tokenTicker,
-					decimals,
-					maxSupply: numberToBytesBE(maxSupply, 16),
-					isFreezable,
-					extraMetadata
-				}
-			},
-			tokenOutputs: [],
-			clientCreatedTimestamp: /* @__PURE__ */ new Date(),
-			sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
-			expiryTime: void 0,
-			invoiceAttachments: []
-		};
+	constructPartialMintTokenTransaction(rawTokenIdentifierBytes, issuerTokenPublicKey, tokenAmount) {
+		return new Promise((resolve) => {
+			resolve({
+				version: 3,
+				tokenTransactionMetadata: {
+					network: this.config.getNetworkProto(),
+					sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
+					validityDurationSeconds: this.config.getTokenValidityDurationSeconds(),
+					clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
+					invoiceAttachments: []
+				},
+				tokenInputs: {
+					$case: "mintInput",
+					mintInput: {
+						issuerPublicKey: issuerTokenPublicKey,
+						tokenIdentifier: rawTokenIdentifierBytes
+					}
+				},
+				partialTokenOutputs: [{
+					ownerPublicKey: issuerTokenPublicKey,
+					tokenIdentifier: rawTokenIdentifierBytes,
+					withdrawBondSats: this.config.getExpectedWithdrawBondSats(),
+					withdrawRelativeBlockLocktime: this.config.getExpectedWithdrawRelativeBlockLocktime(),
+					tokenAmount: numberToBytesBE(tokenAmount, 16)
+				}]
+			});
+		});
 	}
-	async constructPartialCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata) {
-		return {
-			version: 3,
-			tokenTransactionMetadata: {
+	constructCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata) {
+		return new Promise((resolve) => {
+			resolve({
+				version: 2,
 				network: this.config.getNetworkProto(),
-				sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
-				validityDurationSeconds: await this.config.getTokenValidityDurationSeconds(),
-				clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
+				tokenInputs: {
+					$case: "createInput",
+					createInput: {
+						issuerPublicKey: tokenPublicKey,
+						tokenName,
+						tokenTicker,
+						decimals,
+						maxSupply: numberToBytesBE(maxSupply, 16),
+						isFreezable,
+						extraMetadata
+					}
+				},
+				tokenOutputs: [],
+				clientCreatedTimestamp: /* @__PURE__ */ new Date(),
+				sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
+				expiryTime: void 0,
 				invoiceAttachments: []
-			},
-			tokenInputs: {
-				$case: "createInput",
-				createInput: {
-					issuerPublicKey: tokenPublicKey,
-					tokenName,
-					tokenTicker,
-					decimals,
-					maxSupply: numberToBytesBE(maxSupply, 16),
-					isFreezable,
-					extraMetadata
-				}
-			},
-			partialTokenOutputs: []
-		};
+			});
+		});
+	}
+	constructPartialCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata) {
+		return new Promise((resolve) => {
+			resolve({
+				version: 3,
+				tokenTransactionMetadata: {
+					network: this.config.getNetworkProto(),
+					sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
+					validityDurationSeconds: this.config.getTokenValidityDurationSeconds(),
+					clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
+					invoiceAttachments: []
+				},
+				tokenInputs: {
+					$case: "createInput",
+					createInput: {
+						issuerPublicKey: tokenPublicKey,
+						tokenName,
+						tokenTicker,
+						decimals,
+						maxSupply: numberToBytesBE(maxSupply, 16),
+						isFreezable,
+						extraMetadata
+					}
+				},
+				partialTokenOutputs: []
+			});
+		});
 	}
 };
 
@@ -619,8 +627,10 @@ var IssuerSparkWallet = class extends SparkWallet {
 	* Retrieves the distribution information for the issuer's token.
 	* @throws {SparkError} This feature is not yet supported
 	*/
-	async getIssuerTokenDistribution() {
-		throw new SparkError("Token distribution is not yet supported");
+	getIssuerTokenDistribution() {
+		return new Promise((_, reject) => {
+			reject(new SparkError("Token distribution is not yet supported"));
+		});
 	}
 	/**
 	* This validates that the token belongs to this issuer.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/issuer-sdk",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "Spark Issuer SDK for token issuance",
   "license": "Apache-2.0",
   "keywords": [
@@ -68,10 +68,10 @@
     "docs": "typedoc src",
     "format:fix": "prettier . --write",
     "format": "prettier . --check",
-    "lint:fix": "echo \"Not implemented yet\"",
-    "lint:fix:continue": "echo \"Not implemented yet\"",
-    "lint:watch": "echo \"Not implemented yet\"",
-    "lint": "echo \"Not implemented yet\"",
+    "lint:fix": "eslint --fix .",
+    "lint:fix:continue": "eslint --fix . || exit 0",
+    "lint:watch": "esw ./src -w --ext .ts,.tsx,.js --color",
+    "lint": "eslint .",
     "package:checks": "yarn depcheck && yarn publint && 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",
@@ -82,7 +82,7 @@
     "types": "tsc"
   },
   "dependencies": {
-    "@buildonspark/spark-sdk": "0.7.16",
+    "@buildonspark/spark-sdk": "0.8.0",
     "@noble/curves": "^1.9.7",
     "@scure/btc-signer": "^1.5.0",
     "buffer": "^6.0.3"
@@ -90,9 +90,12 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.4",
     "@jest/globals": "^29.7.0",
+    "@lightsparkdev/eslint-config": "^0.0.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.13.2",
     "depcheck": "^1.4.7",
+    "eslint": "^9.25.0",
+    "eslint-watch": "^8.0.0",
     "jest": "^29.7.0",
     "madge": "^8.0.0",
     "node-fetch": "^3.3.2",

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

@@ -1,5 +1,4 @@
 import { IssuerSparkWallet as BaseIssuerSparkWallet } from "./issuer-spark-wallet.js";
-import type { WalletConfigService } from "@buildonspark/spark-sdk";
 
 /* We just need this path to exist to prevent RN from importing the default browser version.
    This extends @buildonspark/spark-sdk ReactNativeSparkWallet due to export paths there. */

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

@@ -1,19 +1,19 @@
 import {
-  Bech32mTokenIdentifier,
+  type Bech32mTokenIdentifier,
   decodeBech32mTokenIdentifier,
   decodeSparkAddress,
   encodeBech32mTokenIdentifier,
   encodeSparkAddress,
   SparkError,
-  SparkSigner,
+  type SparkSigner,
   SparkWallet,
   SparkRequestError,
   SparkValidationError,
   type ConfigOptions,
 } from "@buildonspark/spark-sdk";
 import {
-  OutputWithPreviousTransactionData,
-  TokenOutputRef,
+  type OutputWithPreviousTransactionData,
+  type TokenOutputRef,
 } from "@buildonspark/spark-sdk/proto/spark_token";
 import { bytesToHex, bytesToNumberBE, hexToBytes } from "@noble/curves/utils";
 import { TokenFreezeService } from "../services/freeze.js";
@@ -21,9 +21,9 @@ import { IssuerTokenTransactionService } from "../services/token-transactions.js
 import { hashFinalTokenTransaction } from "@buildonspark/spark-sdk";
 import { validateTokenParameters } from "../utils/create-validation.js";
 import {
-  IssuerTokenMetadata,
-  TokenCreationDetails,
-  TokenDistribution,
+  type IssuerTokenMetadata,
+  type TokenCreationDetails,
+  type TokenDistribution,
 } from "./types.js";
 
 const BURN_ADDRESS = "02".repeat(33);
@@ -204,8 +204,8 @@ export abstract class IssuerSparkWallet extends SparkWallet {
           network: this.config.getNetworkType(),
         });
 
-        // query_token_metadata will return metadata for all token identifiers and issuer public keys provided.
-        // It does not filter by issuer public key if both params are provided.
+        // query_token_metadata will return metadata for all token identifiers and issuer public
+        // keys provided. It does not filter by issuer public key if both params are provided.
         // Filter the response by issuer public key to return only the issuer tokens.
         if (bytesToHex(metadata.issuerPublicKey) !== issuerPublicKey) {
           continue;
@@ -421,7 +421,7 @@ export abstract class IssuerSparkWallet extends SparkWallet {
           );
         }
         const tokenIdentifier = encodeBech32mTokenIdentifier({
-          tokenIdentifier: broadcastResponse.tokenIdentifier!,
+          tokenIdentifier: broadcastResponse.tokenIdentifier,
           network: this.config.getNetworkType(),
         });
         return {
@@ -711,7 +711,7 @@ export abstract class IssuerSparkWallet extends SparkWallet {
       this.config.getNetworkType(),
     ).tokenIdentifier;
 
-    const response = await this.tokenFreezeService!.freezeTokens({
+    const response = await this.tokenFreezeService.freezeTokens({
       ownerPublicKey: hexToBytes(decodedOwnerPubkey.identityPublicKey),
       tokenIdentifier: rawTokenIdentifier,
     });
@@ -811,7 +811,7 @@ export abstract class IssuerSparkWallet extends SparkWallet {
       this.config.getNetworkType(),
     ).tokenIdentifier;
 
-    const response = await this.tokenFreezeService!.unfreezeTokens({
+    const response = await this.tokenFreezeService.unfreezeTokens({
       ownerPublicKey: hexToBytes(decodedOwnerPubkey.identityPublicKey),
       tokenIdentifier: rawTokenIdentifier,
     });
@@ -827,8 +827,10 @@ export abstract class IssuerSparkWallet extends SparkWallet {
    * Retrieves the distribution information for the issuer's token.
    * @throws {SparkError} This feature is not yet supported
    */
-  public async getIssuerTokenDistribution(): Promise<TokenDistribution> {
-    throw new SparkError("Token distribution is not yet supported");
+  public getIssuerTokenDistribution(): Promise<TokenDistribution> {
+    return new Promise((_, reject) => {
+      reject(new SparkError("Token distribution is not yet supported"));
+    });
   }
 
   /**
@@ -909,7 +911,7 @@ type AssertNever<T extends never> = T;
 type IssuerSparkWalletFunctionKeys = Extract<
   {
     [K in keyof IssuerSparkWallet]: IssuerSparkWallet[K] extends (
-      ...args: any[]
+      ...args: never[]
     ) => PromiseLike<unknown>
       ? /* Exclude SparkWallet methods that are already wrapped by the base class: */
         K extends keyof SparkWallet
@@ -942,3 +944,6 @@ type _AllIssuerMethodsCovered = AssertNever<
     (typeof PUBLIC_ISSUER_SPARK_WALLET_METHODS)[number]
   >
 >;
+
+const allIssuerMethodsCovered: _AllIssuerMethodsCovered = undefined as never;
+void allIssuerMethodsCovered;

package/src/issuer-wallet/types.ts

@@ -4,7 +4,8 @@ import type { Bech32mTokenIdentifier } from "@buildonspark/spark-sdk";
  * Token metadata containing essential information about issuer's token.
  * This is the wallet's internal representation with JavaScript-friendly types.
  *
- * rawTokenIdentifier: This is the raw binary token identifier - This is used to encode the human readable token identifier.
+ * rawTokenIdentifier: This is the raw binary token identifier - This is used to encode the human
+ * readable token identifier.
  *
  * tokenPublicKey: This is the hex-encoded public key of the token issuer - Same as issuerPublicKey.
  *

package/src/services/freeze.ts

@@ -1,12 +1,12 @@
 import {
   type BaseConnectionManager,
   SparkRequestError,
-  WalletConfigService,
+  type WalletConfigService,
   collectResponses,
 } from "@buildonspark/spark-sdk";
 import {
-  FreezeTokensPayload,
-  FreezeTokensResponse,
+  type FreezeTokensPayload,
+  type FreezeTokensResponse,
 } from "@buildonspark/spark-sdk/proto/spark_token";
 import { hexToBytes } from "@noble/curves/utils";
 import { hashFreezeTokensPayload } from "../utils/token-hashing.js";

package/src/services/token-transactions.ts

@@ -1,11 +1,11 @@
 import {
   TokenTransactionService,
-  WalletConfigService,
+  type WalletConfigService,
   type BaseConnectionManager,
 } from "@buildonspark/spark-sdk";
 import {
-  PartialTokenTransaction,
-  TokenTransaction,
+  type PartialTokenTransaction,
+  type TokenTransaction,
 } from "@buildonspark/spark-sdk/proto/spark_token";
 import { numberToBytesBE } from "@noble/curves/utils";
 
@@ -17,73 +17,77 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
     super(config, connectionManager);
   }
 
-  async constructMintTokenTransaction(
+  constructMintTokenTransaction(
     rawTokenIdentifierBytes: Uint8Array,
     issuerTokenPublicKey: Uint8Array,
     tokenAmount: bigint,
   ): Promise<TokenTransaction> {
-    return {
-      version: 2,
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "mintInput",
-        mintInput: {
-          issuerPublicKey: issuerTokenPublicKey,
-          tokenIdentifier: rawTokenIdentifierBytes,
-        },
-      },
-      tokenOutputs: [
-        {
-          ownerPublicKey: issuerTokenPublicKey,
-          tokenIdentifier: rawTokenIdentifierBytes,
-          tokenAmount: numberToBytesBE(tokenAmount, 16),
+    return new Promise((resolve) => {
+      resolve({
+        version: 2,
+        network: this.config.getNetworkProto(),
+        tokenInputs: {
+          $case: "mintInput",
+          mintInput: {
+            issuerPublicKey: issuerTokenPublicKey,
+            tokenIdentifier: rawTokenIdentifierBytes,
+          },
         },
-      ],
-      clientCreatedTimestamp: new Date(),
-      sparkOperatorIdentityPublicKeys:
-        super.collectOperatorIdentityPublicKeys(),
-      expiryTime: undefined,
-      invoiceAttachments: [],
-    };
+        tokenOutputs: [
+          {
+            ownerPublicKey: issuerTokenPublicKey,
+            tokenIdentifier: rawTokenIdentifierBytes,
+            tokenAmount: numberToBytesBE(tokenAmount, 16),
+          },
+        ],
+        clientCreatedTimestamp: new Date(),
+        sparkOperatorIdentityPublicKeys:
+          super.collectOperatorIdentityPublicKeys(),
+        expiryTime: undefined,
+        invoiceAttachments: [],
+      });
+    });
   }
 
-  async constructPartialMintTokenTransaction(
+  constructPartialMintTokenTransaction(
     rawTokenIdentifierBytes: Uint8Array,
     issuerTokenPublicKey: Uint8Array,
     tokenAmount: bigint,
   ): Promise<PartialTokenTransaction> {
-    return {
-      version: 3,
-      tokenTransactionMetadata: {
-        network: this.config.getNetworkProto(),
-        sparkOperatorIdentityPublicKeys:
-          this.collectOperatorIdentityPublicKeys(),
-        validityDurationSeconds:
-          await this.config.getTokenValidityDurationSeconds(),
-        clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
-        invoiceAttachments: [],
-      },
-      tokenInputs: {
-        $case: "mintInput",
-        mintInput: {
-          issuerPublicKey: issuerTokenPublicKey,
-          tokenIdentifier: rawTokenIdentifierBytes,
+    return new Promise((resolve) => {
+      resolve({
+        version: 3,
+        tokenTransactionMetadata: {
+          network: this.config.getNetworkProto(),
+          sparkOperatorIdentityPublicKeys:
+            this.collectOperatorIdentityPublicKeys(),
+          validityDurationSeconds:
+            this.config.getTokenValidityDurationSeconds(),
+          clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
+          invoiceAttachments: [],
         },
-      },
-      partialTokenOutputs: [
-        {
-          ownerPublicKey: issuerTokenPublicKey,
-          tokenIdentifier: rawTokenIdentifierBytes,
-          withdrawBondSats: this.config.getExpectedWithdrawBondSats(),
-          withdrawRelativeBlockLocktime:
-            this.config.getExpectedWithdrawRelativeBlockLocktime(),
-          tokenAmount: numberToBytesBE(tokenAmount, 16),
+        tokenInputs: {
+          $case: "mintInput",
+          mintInput: {
+            issuerPublicKey: issuerTokenPublicKey,
+            tokenIdentifier: rawTokenIdentifierBytes,
+          },
         },
-      ],
-    };
+        partialTokenOutputs: [
+          {
+            ownerPublicKey: issuerTokenPublicKey,
+            tokenIdentifier: rawTokenIdentifierBytes,
+            withdrawBondSats: this.config.getExpectedWithdrawBondSats(),
+            withdrawRelativeBlockLocktime:
+              this.config.getExpectedWithdrawRelativeBlockLocktime(),
+            tokenAmount: numberToBytesBE(tokenAmount, 16),
+          },
+        ],
+      });
+    });
   }
 
-  async constructCreateTokenTransaction(
+  constructCreateTokenTransaction(
     tokenPublicKey: Uint8Array,
     tokenName: string,
     tokenTicker: string,
@@ -92,31 +96,33 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
     isFreezable: boolean,
     extraMetadata: Uint8Array | undefined,
   ): Promise<TokenTransaction> {
-    return {
-      version: 2,
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "createInput",
-        createInput: {
-          issuerPublicKey: tokenPublicKey,
-          tokenName: tokenName,
-          tokenTicker: tokenTicker,
-          decimals: decimals,
-          maxSupply: numberToBytesBE(maxSupply, 16),
-          isFreezable: isFreezable,
-          extraMetadata: extraMetadata,
+    return new Promise((resolve) => {
+      resolve({
+        version: 2,
+        network: this.config.getNetworkProto(),
+        tokenInputs: {
+          $case: "createInput",
+          createInput: {
+            issuerPublicKey: tokenPublicKey,
+            tokenName: tokenName,
+            tokenTicker: tokenTicker,
+            decimals: decimals,
+            maxSupply: numberToBytesBE(maxSupply, 16),
+            isFreezable: isFreezable,
+            extraMetadata: extraMetadata,
+          },
         },
-      },
-      tokenOutputs: [],
-      clientCreatedTimestamp: new Date(),
-      sparkOperatorIdentityPublicKeys:
-        super.collectOperatorIdentityPublicKeys(),
-      expiryTime: undefined,
-      invoiceAttachments: [],
-    };
+        tokenOutputs: [],
+        clientCreatedTimestamp: new Date(),
+        sparkOperatorIdentityPublicKeys:
+          super.collectOperatorIdentityPublicKeys(),
+        expiryTime: undefined,
+        invoiceAttachments: [],
+      });
+    });
   }
 
-  async constructPartialCreateTokenTransaction(
+  constructPartialCreateTokenTransaction(
     tokenPublicKey: Uint8Array,
     tokenName: string,
     tokenTicker: string,
@@ -125,30 +131,32 @@ export class IssuerTokenTransactionService extends TokenTransactionService {
     isFreezable: boolean,
     extraMetadata?: Uint8Array,
   ): Promise<PartialTokenTransaction> {
-    return {
-      version: 3,
-      tokenTransactionMetadata: {
-        network: this.config.getNetworkProto(),
-        sparkOperatorIdentityPublicKeys:
-          this.collectOperatorIdentityPublicKeys(),
-        validityDurationSeconds:
-          await this.config.getTokenValidityDurationSeconds(),
-        clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
-        invoiceAttachments: [],
-      },
-      tokenInputs: {
-        $case: "createInput",
-        createInput: {
-          issuerPublicKey: tokenPublicKey,
-          tokenName: tokenName,
-          tokenTicker: tokenTicker,
-          decimals: decimals,
-          maxSupply: numberToBytesBE(maxSupply, 16),
-          isFreezable: isFreezable,
-          extraMetadata: extraMetadata,
+    return new Promise((resolve) => {
+      resolve({
+        version: 3,
+        tokenTransactionMetadata: {
+          network: this.config.getNetworkProto(),
+          sparkOperatorIdentityPublicKeys:
+            this.collectOperatorIdentityPublicKeys(),
+          validityDurationSeconds:
+            this.config.getTokenValidityDurationSeconds(),
+          clientCreatedTimestamp: this.connectionManager.getCurrentServerTime(),
+          invoiceAttachments: [],
+        },
+        tokenInputs: {
+          $case: "createInput",
+          createInput: {
+            issuerPublicKey: tokenPublicKey,
+            tokenName: tokenName,
+            tokenTicker: tokenTicker,
+            decimals: decimals,
+            maxSupply: numberToBytesBE(maxSupply, 16),
+            isFreezable: isFreezable,
+            extraMetadata: extraMetadata,
+          },
         },
-      },
-      partialTokenOutputs: [],
-    };
+        partialTokenOutputs: [],
+      });
+    });
   }
 }