@buildonspark/issuer-sdk 0.0.80 → 0.0.82

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @buildonspark/issuer-sdk
 
+## 0.0.82
+
+### Patch Changes
+
+- -leaf key improvements
+  -token improvements
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.2.3
+
+## 0.0.81
+
+### Patch Changes
+
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.2.2
+
 ## 0.0.80
 
 ### Patch Changes

package/dist/index.cjs

@@ -44,6 +44,7 @@ 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");
+var import_spark_sdk7 = require("@buildonspark/spark-sdk");
 
 // src/services/freeze.ts
 var import_spark_sdk2 = require("@buildonspark/spark-sdk");
@@ -60,16 +61,26 @@ function hashFreezeTokensPayload(payload) {
     });
   }
   let allHashes = [];
+  const versionHashObj = import_utils.sha256.create();
+  const versionBytes = new Uint8Array(4);
+  new DataView(versionBytes.buffer).setUint32(
+    0,
+    payload.version,
+    false
+    // false for big-endian
+  );
+  versionHashObj.update(versionBytes);
+  allHashes.push(versionHashObj.digest());
   const ownerPubKeyHash = import_utils.sha256.create();
   if (payload.ownerPublicKey) {
     ownerPubKeyHash.update(payload.ownerPublicKey);
   }
   allHashes.push(ownerPubKeyHash.digest());
-  const tokenPubKeyHash = import_utils.sha256.create();
-  if (payload.tokenPublicKey) {
-    tokenPubKeyHash.update(payload.tokenPublicKey);
+  const tokenIdentifierHash = import_utils.sha256.create();
+  if (payload.tokenIdentifier) {
+    tokenIdentifierHash.update(payload.tokenIdentifier);
   }
-  allHashes.push(tokenPubKeyHash.digest());
+  allHashes.push(tokenIdentifierHash.digest());
   const shouldUnfreezeHash = import_utils.sha256.create();
   shouldUnfreezeHash.update(new Uint8Array([payload.shouldUnfreeze ? 1 : 0]));
   allHashes.push(shouldUnfreezeHash.digest());
@@ -106,21 +117,28 @@ var TokenFreezeService = class {
     this.config = config;
     this.connectionManager = connectionManager;
   }
-  async freezeTokens(ownerPublicKey, tokenPublicKey) {
-    return this.freezeOperation(ownerPublicKey, tokenPublicKey, false);
+  async freezeTokens({
+    ownerPublicKey,
+    tokenIdentifier
+  }) {
+    return this.freezeOperation(ownerPublicKey, false, tokenIdentifier);
   }
-  async unfreezeTokens(ownerPublicKey, tokenPublicKey) {
-    return this.freezeOperation(ownerPublicKey, tokenPublicKey, true);
+  async unfreezeTokens({
+    ownerPublicKey,
+    tokenIdentifier
+  }) {
+    return this.freezeOperation(ownerPublicKey, true, tokenIdentifier);
   }
-  async freezeOperation(ownerPublicKey, tokenPublicKey, shouldUnfreeze) {
+  async freezeOperation(ownerPublicKey, shouldUnfreeze, tokenIdentifier) {
     const signingOperators = this.config.getSigningOperators();
     const issuerProvidedTimestamp = Date.now();
     const freezeResponses = await Promise.allSettled(
       Object.entries(signingOperators).map(async ([identifier, operator]) => {
-        const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
+        const sparkTokenClient = await this.connectionManager.createSparkTokenClient(operator.address);
         const freezeTokensPayload = {
+          version: 1,
           ownerPublicKey,
-          tokenPublicKey,
+          tokenIdentifier,
           shouldUnfreeze,
           issuerProvidedTimestamp,
           operatorIdentityPublicKey: (0, import_utils2.hexToBytes)(operator.identityPublicKey)
@@ -128,7 +146,7 @@ var TokenFreezeService = class {
         const hashedPayload = hashFreezeTokensPayload(freezeTokensPayload);
         const issuerSignature = await this.config.signer.signMessageWithIdentityKey(hashedPayload);
         try {
-          const response = await internalSparkClient.freeze_tokens({
+          const response = await sparkTokenClient.freeze_tokens({
             freezeTokensPayload,
             issuerSignature
           });
@@ -138,7 +156,7 @@ var TokenFreezeService = class {
           };
         } catch (error) {
           throw new import_spark_sdk2.NetworkError(
-            `Failed to send a freeze/unfreeze operation for token: ${tokenPublicKey.toString()} at operator: ${operator.address}`,
+            `Failed to send a freeze/unfreeze operation to operator: ${operator.address}`,
             {
               operation: "freeze_tokens",
               errorCount: 1,
@@ -228,7 +246,7 @@ var IssuerTokenTransactionService = class extends import_spark_sdk3.TokenTransac
 };
 
 // src/issuer-wallet/issuer-spark-wallet.ts
-var import_spark_sdk7 = require("@buildonspark/spark-sdk");
+var import_spark_sdk8 = require("@buildonspark/spark-sdk");
 
 // src/utils/create-validation.ts
 var import_spark_sdk4 = require("@buildonspark/spark-sdk");
@@ -300,7 +318,7 @@ function validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply) {
 }
 
 // src/issuer-wallet/issuer-spark-wallet.ts
-var import_spark_sdk8 = require("@buildonspark/spark-sdk");
+var import_spark_sdk9 = require("@buildonspark/spark-sdk");
 var BURN_ADDRESS = "02".repeat(33);
 var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.SparkWallet {
   issuerTokenTransactionService;
@@ -440,7 +458,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
         );
       }
       const metadata = response.tokenMetadata[0];
-      const tokenIdentifier = (0, import_spark_sdk8.encodeBech32mTokenIdentifier)({
+      const tokenIdentifier = (0, import_spark_sdk9.encodeBech32mTokenIdentifier)({
         tokenIdentifier: metadata.tokenIdentifier,
         network: this.config.getNetworkType()
       });
@@ -468,7 +486,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
    */
   async getIssuerTokenIdentifier() {
     const tokenMetadata = await this.getIssuerTokenMetadata();
-    return (0, import_spark_sdk8.encodeBech32mTokenIdentifier)({
+    return (0, import_spark_sdk9.encodeBech32mTokenIdentifier)({
       tokenIdentifier: tokenMetadata.rawTokenIdentifier,
       network: this.config.getNetworkType()
     });
@@ -565,15 +583,26 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
    */
   async freezeTokens(sparkAddress) {
     await this.syncTokenOutputs();
-    const tokenPublicKey = await super.getIdentityPublicKey();
     const decodedOwnerPubkey = (0, import_spark_sdk6.decodeSparkAddress)(
       sparkAddress,
       this.config.getNetworkType()
     );
-    const response = await this.tokenFreezeService.freezeTokens(
-      (0, import_utils4.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
-      (0, import_utils4.hexToBytes)(tokenPublicKey)
-    );
+    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new import_spark_sdk5.ValidationError("Issuer token identifier not found", {
+        field: "issuerTokenIdentifier",
+        value: issuerTokenIdentifier,
+        expected: "non-null token identifier"
+      });
+    }
+    const rawTokenIdentifier = (0, import_spark_sdk7.decodeBech32mTokenIdentifier)(
+      issuerTokenIdentifier,
+      this.config.getNetworkType()
+    ).tokenIdentifier;
+    const response = await this.tokenFreezeService.freezeTokens({
+      ownerPublicKey: (0, import_utils4.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
+      tokenIdentifier: rawTokenIdentifier
+    });
     const tokenAmount = (0, import_utils4.bytesToNumberBE)(response.impactedTokenAmount);
     return {
       impactedOutputIds: response.impactedOutputIds,
@@ -587,15 +616,26 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
    */
   async unfreezeTokens(sparkAddress) {
     await this.syncTokenOutputs();
-    const tokenPublicKey = await super.getIdentityPublicKey();
     const decodedOwnerPubkey = (0, import_spark_sdk6.decodeSparkAddress)(
       sparkAddress,
       this.config.getNetworkType()
     );
-    const response = await this.tokenFreezeService.unfreezeTokens(
-      (0, import_utils4.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
-      (0, import_utils4.hexToBytes)(tokenPublicKey)
-    );
+    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new import_spark_sdk5.ValidationError("Issuer token identifier not found", {
+        field: "issuerTokenIdentifier",
+        value: issuerTokenIdentifier,
+        expected: "non-null token identifier"
+      });
+    }
+    const rawTokenIdentifier = (0, import_spark_sdk7.decodeBech32mTokenIdentifier)(
+      issuerTokenIdentifier,
+      this.config.getNetworkType()
+    ).tokenIdentifier;
+    const response = await this.tokenFreezeService.unfreezeTokens({
+      ownerPublicKey: (0, import_utils4.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
+      tokenIdentifier: rawTokenIdentifier
+    });
     const tokenAmount = (0, import_utils4.bytesToNumberBE)(response.impactedTokenAmount);
     return {
       impactedOutputIds: response.impactedOutputIds,
@@ -607,7 +647,7 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk5.Spark
    * @throws {NotImplementedError} This feature is not yet supported
    */
   async getIssuerTokenDistribution() {
-    throw new import_spark_sdk7.NotImplementedError("Token distribution is not yet supported");
+    throw new import_spark_sdk8.NotImplementedError("Token distribution is not yet supported");
   }
   /**
    * Announces a new token on the L1 (Bitcoin) network.

package/dist/index.js

@@ -19,6 +19,7 @@ import {
   bytesToNumberBE,
   hexToBytes as hexToBytes2
 } from "@noble/curves/abstract/utils";
+import { decodeBech32mTokenIdentifier } from "@buildonspark/spark-sdk";
 
 // src/services/freeze.ts
 import {
@@ -38,16 +39,26 @@ function hashFreezeTokensPayload(payload) {
     });
   }
   let allHashes = [];
+  const versionHashObj = sha256.create();
+  const versionBytes = new Uint8Array(4);
+  new DataView(versionBytes.buffer).setUint32(
+    0,
+    payload.version,
+    false
+    // false for big-endian
+  );
+  versionHashObj.update(versionBytes);
+  allHashes.push(versionHashObj.digest());
   const ownerPubKeyHash = sha256.create();
   if (payload.ownerPublicKey) {
     ownerPubKeyHash.update(payload.ownerPublicKey);
   }
   allHashes.push(ownerPubKeyHash.digest());
-  const tokenPubKeyHash = sha256.create();
-  if (payload.tokenPublicKey) {
-    tokenPubKeyHash.update(payload.tokenPublicKey);
+  const tokenIdentifierHash = sha256.create();
+  if (payload.tokenIdentifier) {
+    tokenIdentifierHash.update(payload.tokenIdentifier);
   }
-  allHashes.push(tokenPubKeyHash.digest());
+  allHashes.push(tokenIdentifierHash.digest());
   const shouldUnfreezeHash = sha256.create();
   shouldUnfreezeHash.update(new Uint8Array([payload.shouldUnfreeze ? 1 : 0]));
   allHashes.push(shouldUnfreezeHash.digest());
@@ -84,21 +95,28 @@ var TokenFreezeService = class {
     this.config = config;
     this.connectionManager = connectionManager;
   }
-  async freezeTokens(ownerPublicKey, tokenPublicKey) {
-    return this.freezeOperation(ownerPublicKey, tokenPublicKey, false);
+  async freezeTokens({
+    ownerPublicKey,
+    tokenIdentifier
+  }) {
+    return this.freezeOperation(ownerPublicKey, false, tokenIdentifier);
   }
-  async unfreezeTokens(ownerPublicKey, tokenPublicKey) {
-    return this.freezeOperation(ownerPublicKey, tokenPublicKey, true);
+  async unfreezeTokens({
+    ownerPublicKey,
+    tokenIdentifier
+  }) {
+    return this.freezeOperation(ownerPublicKey, true, tokenIdentifier);
   }
-  async freezeOperation(ownerPublicKey, tokenPublicKey, shouldUnfreeze) {
+  async freezeOperation(ownerPublicKey, shouldUnfreeze, tokenIdentifier) {
     const signingOperators = this.config.getSigningOperators();
     const issuerProvidedTimestamp = Date.now();
     const freezeResponses = await Promise.allSettled(
       Object.entries(signingOperators).map(async ([identifier, operator]) => {
-        const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
+        const sparkTokenClient = await this.connectionManager.createSparkTokenClient(operator.address);
         const freezeTokensPayload = {
+          version: 1,
           ownerPublicKey,
-          tokenPublicKey,
+          tokenIdentifier,
           shouldUnfreeze,
           issuerProvidedTimestamp,
           operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
@@ -106,7 +124,7 @@ var TokenFreezeService = class {
         const hashedPayload = hashFreezeTokensPayload(freezeTokensPayload);
         const issuerSignature = await this.config.signer.signMessageWithIdentityKey(hashedPayload);
         try {
-          const response = await internalSparkClient.freeze_tokens({
+          const response = await sparkTokenClient.freeze_tokens({
             freezeTokensPayload,
             issuerSignature
           });
@@ -116,7 +134,7 @@ var TokenFreezeService = class {
           };
         } catch (error) {
           throw new NetworkError(
-            `Failed to send a freeze/unfreeze operation for token: ${tokenPublicKey.toString()} at operator: ${operator.address}`,
+            `Failed to send a freeze/unfreeze operation to operator: ${operator.address}`,
             {
               operation: "freeze_tokens",
               errorCount: 1,
@@ -545,15 +563,26 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
    */
   async freezeTokens(sparkAddress) {
     await this.syncTokenOutputs();
-    const tokenPublicKey = await super.getIdentityPublicKey();
     const decodedOwnerPubkey = decodeSparkAddress(
       sparkAddress,
       this.config.getNetworkType()
     );
-    const response = await this.tokenFreezeService.freezeTokens(
-      hexToBytes2(decodedOwnerPubkey.identityPublicKey),
-      hexToBytes2(tokenPublicKey)
-    );
+    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new ValidationError3("Issuer token identifier not found", {
+        field: "issuerTokenIdentifier",
+        value: issuerTokenIdentifier,
+        expected: "non-null token identifier"
+      });
+    }
+    const rawTokenIdentifier = decodeBech32mTokenIdentifier(
+      issuerTokenIdentifier,
+      this.config.getNetworkType()
+    ).tokenIdentifier;
+    const response = await this.tokenFreezeService.freezeTokens({
+      ownerPublicKey: hexToBytes2(decodedOwnerPubkey.identityPublicKey),
+      tokenIdentifier: rawTokenIdentifier
+    });
     const tokenAmount = bytesToNumberBE(response.impactedTokenAmount);
     return {
       impactedOutputIds: response.impactedOutputIds,
@@ -567,15 +596,26 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends SparkWallet {
    */
   async unfreezeTokens(sparkAddress) {
     await this.syncTokenOutputs();
-    const tokenPublicKey = await super.getIdentityPublicKey();
     const decodedOwnerPubkey = decodeSparkAddress(
       sparkAddress,
       this.config.getNetworkType()
     );
-    const response = await this.tokenFreezeService.unfreezeTokens(
-      hexToBytes2(decodedOwnerPubkey.identityPublicKey),
-      hexToBytes2(tokenPublicKey)
-    );
+    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new ValidationError3("Issuer token identifier not found", {
+        field: "issuerTokenIdentifier",
+        value: issuerTokenIdentifier,
+        expected: "non-null token identifier"
+      });
+    }
+    const rawTokenIdentifier = decodeBech32mTokenIdentifier(
+      issuerTokenIdentifier,
+      this.config.getNetworkType()
+    ).tokenIdentifier;
+    const response = await this.tokenFreezeService.unfreezeTokens({
+      ownerPublicKey: hexToBytes2(decodedOwnerPubkey.identityPublicKey),
+      tokenIdentifier: rawTokenIdentifier
+    });
     const tokenAmount = bytesToNumberBE(response.impactedTokenAmount);
     return {
       impactedOutputIds: response.impactedOutputIds,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buildonspark/issuer-sdk",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "description": "Spark Issuer SDK for token issuance",
   "license": "Apache-2.0",
   "module": "./dist/index.js",
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "@buildonspark/lrc20-sdk": "0.0.60",
-    "@buildonspark/spark-sdk": "0.2.1",
+    "@buildonspark/spark-sdk": "0.2.3",
     "@lightsparkdev/core": "^1.4.2",
     "@noble/curves": "^1.8.0",
     "@scure/btc-signer": "^1.5.0",

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

@@ -21,6 +21,7 @@ import {
   bytesToNumberBE,
   hexToBytes,
 } from "@noble/curves/abstract/utils";
+import { decodeBech32mTokenIdentifier } from "@buildonspark/spark-sdk";
 import { TokenFreezeService } from "../services/freeze.js";
 import { IssuerTokenTransactionService } from "../services/token-transactions.js";
 import { TokenDistribution, IssuerTokenMetadata } from "./types.js";
@@ -347,15 +348,29 @@ export class IssuerSparkWallet extends SparkWallet {
     sparkAddress: string,
   ): Promise<{ impactedOutputIds: string[]; impactedTokenAmount: bigint }> {
     await this.syncTokenOutputs();
-    const tokenPublicKey = await super.getIdentityPublicKey();
     const decodedOwnerPubkey = decodeSparkAddress(
       sparkAddress,
       this.config.getNetworkType(),
     );
-    const response = await this.tokenFreezeService!.freezeTokens(
-      hexToBytes(decodedOwnerPubkey.identityPublicKey),
-      hexToBytes(tokenPublicKey),
-    );
+
+    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new ValidationError("Issuer token identifier not found", {
+        field: "issuerTokenIdentifier",
+        value: issuerTokenIdentifier,
+        expected: "non-null token identifier",
+      });
+    }
+
+    const rawTokenIdentifier = decodeBech32mTokenIdentifier(
+      issuerTokenIdentifier,
+      this.config.getNetworkType(),
+    ).tokenIdentifier;
+
+    const response = await this.tokenFreezeService!.freezeTokens({
+      ownerPublicKey: hexToBytes(decodedOwnerPubkey.identityPublicKey),
+      tokenIdentifier: rawTokenIdentifier,
+    });
 
     // Convert the Uint8Array to a bigint
     const tokenAmount = bytesToNumberBE(response.impactedTokenAmount);
@@ -375,15 +390,29 @@ export class IssuerSparkWallet extends SparkWallet {
     sparkAddress: string,
   ): Promise<{ impactedOutputIds: string[]; impactedTokenAmount: bigint }> {
     await this.syncTokenOutputs();
-    const tokenPublicKey = await super.getIdentityPublicKey();
     const decodedOwnerPubkey = decodeSparkAddress(
       sparkAddress,
       this.config.getNetworkType(),
     );
-    const response = await this.tokenFreezeService!.unfreezeTokens(
-      hexToBytes(decodedOwnerPubkey.identityPublicKey),
-      hexToBytes(tokenPublicKey),
-    );
+
+    const issuerTokenIdentifier = await this.getIssuerTokenIdentifier();
+    if (issuerTokenIdentifier === null) {
+      throw new ValidationError("Issuer token identifier not found", {
+        field: "issuerTokenIdentifier",
+        value: issuerTokenIdentifier,
+        expected: "non-null token identifier",
+      });
+    }
+
+    const rawTokenIdentifier = decodeBech32mTokenIdentifier(
+      issuerTokenIdentifier,
+      this.config.getNetworkType(),
+    ).tokenIdentifier;
+
+    const response = await this.tokenFreezeService!.unfreezeTokens({
+      ownerPublicKey: hexToBytes(decodedOwnerPubkey.identityPublicKey),
+      tokenIdentifier: rawTokenIdentifier,
+    });
     const tokenAmount = bytesToNumberBE(response.impactedTokenAmount);
 
     return {

package/src/proto/spark_token.ts

@@ -0,0 +1 @@
+export * from "@buildonspark/spark-sdk/proto/spark_token";

package/src/services/freeze.ts

@@ -1,7 +1,7 @@
 import {
-  FreezeTokensPayload,
   FreezeTokensResponse,
-} from "@buildonspark/spark-sdk/proto/spark";
+  FreezeTokensPayload,
+} from "@buildonspark/spark-sdk/proto/spark_token";
 import {
   type ConnectionManager,
   WalletConfigService,
@@ -23,24 +23,30 @@ export class TokenFreezeService {
     this.connectionManager = connectionManager;
   }
 
-  async freezeTokens(
-    ownerPublicKey: Uint8Array,
-    tokenPublicKey: Uint8Array,
-  ): Promise<FreezeTokensResponse> {
-    return this.freezeOperation(ownerPublicKey, tokenPublicKey, false);
+  async freezeTokens({
+    ownerPublicKey,
+    tokenIdentifier,
+  }: {
+    ownerPublicKey: Uint8Array;
+    tokenIdentifier?: Uint8Array;
+  }): Promise<FreezeTokensResponse> {
+    return this.freezeOperation(ownerPublicKey, false, tokenIdentifier!);
   }
 
-  async unfreezeTokens(
-    ownerPublicKey: Uint8Array,
-    tokenPublicKey: Uint8Array,
-  ): Promise<FreezeTokensResponse> {
-    return this.freezeOperation(ownerPublicKey, tokenPublicKey, true);
+  async unfreezeTokens({
+    ownerPublicKey,
+    tokenIdentifier,
+  }: {
+    ownerPublicKey: Uint8Array;
+    tokenIdentifier?: Uint8Array;
+  }): Promise<FreezeTokensResponse> {
+    return this.freezeOperation(ownerPublicKey, true, tokenIdentifier!);
   }
 
   private async freezeOperation(
     ownerPublicKey: Uint8Array,
-    tokenPublicKey: Uint8Array,
     shouldUnfreeze: boolean,
+    tokenIdentifier: Uint8Array,
   ): Promise<FreezeTokensResponse> {
     const signingOperators = this.config.getSigningOperators();
     const issuerProvidedTimestamp = Date.now();
@@ -48,12 +54,13 @@ export class TokenFreezeService {
     // Submit freeze_tokens to all SOs in parallel
     const freezeResponses = await Promise.allSettled(
       Object.entries(signingOperators).map(async ([identifier, operator]) => {
-        const internalSparkClient =
-          await this.connectionManager.createSparkClient(operator.address);
+        const sparkTokenClient =
+          await this.connectionManager.createSparkTokenClient(operator.address);
 
         const freezeTokensPayload: FreezeTokensPayload = {
+          version: 1,
           ownerPublicKey,
-          tokenPublicKey,
+          tokenIdentifier,
           shouldUnfreeze,
           issuerProvidedTimestamp,
           operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey),
@@ -66,7 +73,7 @@ export class TokenFreezeService {
           await this.config.signer.signMessageWithIdentityKey(hashedPayload);
 
         try {
-          const response = await internalSparkClient.freeze_tokens({
+          const response = await sparkTokenClient.freeze_tokens({
             freezeTokensPayload,
             issuerSignature,
           });
@@ -77,7 +84,7 @@ export class TokenFreezeService {
           };
         } catch (error) {
           throw new NetworkError(
-            `Failed to send a freeze/unfreeze operation for token: ${tokenPublicKey.toString()} at operator: ${operator.address}`,
+            `Failed to send a freeze/unfreeze operation to operator: ${operator.address}`,
             {
               operation: "freeze_tokens",
               errorCount: 1,

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

@@ -2,12 +2,9 @@ import {
   WalletConfig,
   ConfigOptions,
   filterTokenBalanceForTokenPublicKey,
-  encodeSparkAddress,
 } from "@buildonspark/spark-sdk";
 import { jest } from "@jest/globals";
-import { BitcoinFaucet } from "@buildonspark/spark-sdk/test-utils";
 import { IssuerSparkWalletTesting } from "../utils/issuer-test-wallet.js";
-import { bytesToHex, hexToBytes } from "@noble/curves/abstract/utils";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
 import { IssuerSparkWallet } from "../../index.js";
 
@@ -53,29 +50,11 @@ describe.each(TEST_CONFIGS)(
     let sharedUserWallet: any;
     let sharedTokenPublicKey: string;
 
-    beforeAll(async () => {
-      const { wallet: issuerWallet } =
-        await IssuerSparkWalletTesting.initialize({
-          options: config,
-        });
-
-      const { wallet: userWallet } = await SparkWalletTesting.initialize({
-        options: config,
-      });
-
-      // Announce a shared token for this configuration
-      await fundAndAnnounce(issuerWallet, 1000000n, 0, `${name}Shared`, "SHR");
-
-      sharedIssuerWallet = issuerWallet;
-      sharedUserWallet = userWallet;
-      sharedTokenPublicKey = await issuerWallet.getIdentityPublicKey();
-    });
-
     afterEach(async () => {
       await new Promise((resolve) => setTimeout(resolve, 1000));
     });
 
-    it("should fail when minting tokens without announcement", async () => {
+    it("should fail when minting tokens without creation", async () => {
       const tokenAmount: bigint = 1000n;
       const { wallet } = await IssuerSparkWalletTesting.initialize({
         options: config,
@@ -84,21 +63,20 @@ describe.each(TEST_CONFIGS)(
       await expect(wallet.mintTokens(tokenAmount)).rejects.toThrow();
     });
 
-    it("should fail when announce decimal is greater than js MAX_SAFE_INTEGER", async () => {
+    it("should fail when creation decimal is greater than js MAX_SAFE_INTEGER", async () => {
       const tokenAmount: bigint = 1000n;
       const { wallet } = await IssuerSparkWalletTesting.initialize({
         options: config,
       });
 
       await expect(
-        fundAndAnnounce(
-          wallet,
-          tokenAmount,
-          2 ** 53,
-          "2Pow53Decimal",
-          "2P53D",
-          false,
-        ),
+        wallet.createToken({
+          tokenName: "2Pow53Decimal",
+          tokenTicker: "2P53D",
+          decimals: 2 ** 53,
+          isFreezable: false,
+          maxSupply: tokenAmount,
+        }),
       ).rejects.toThrow();
     });
 
@@ -108,19 +86,38 @@ describe.each(TEST_CONFIGS)(
         options: config,
       });
 
-      await fundAndAnnounce(wallet, 2n, 0, "MST", "MST");
+      await wallet.createToken({
+        tokenName: "MST",
+        tokenTicker: "MST",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 2n,
+      });
       await expect(wallet.mintTokens(tokenAmount)).rejects.toThrow();
     });
 
     it("should mint tokens successfully", async () => {
       const tokenAmount: bigint = 1000n;
 
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: config,
+        });
+      await issuerWallet.createToken({
+        tokenName: `${name}M`,
+        tokenTicker: "MIN",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1_000_000n,
+      });
+      sharedIssuerWallet = issuerWallet;
+      sharedTokenPublicKey = await issuerWallet.getIdentityPublicKey();
+
       const tokenMetadata = await sharedIssuerWallet.getIssuerTokenMetadata();
 
-      // Assert token public key metadata values
       const identityPublicKey = await sharedIssuerWallet.getIdentityPublicKey();
-      expect(tokenMetadata?.tokenName).toEqual(`${name}Shared`);
-      expect(tokenMetadata?.tokenTicker).toEqual("SHR");
+      expect(tokenMetadata?.tokenName).toEqual(`${name}M`);
+      expect(tokenMetadata?.tokenTicker).toEqual("MIN");
       expect(tokenMetadata?.decimals).toEqual(0);
       expect(tokenMetadata?.maxSupply).toEqual(1000000n);
       expect(tokenMetadata?.isFreezable).toEqual(false);
@@ -138,6 +135,24 @@ describe.each(TEST_CONFIGS)(
     it("should mint and transfer tokens", async () => {
       const tokenAmount: bigint = 1000n;
 
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: config,
+        });
+      const { wallet: userWallet } = await SparkWalletTesting.initialize({
+        options: config,
+      });
+      await issuerWallet.createToken({
+        tokenName: `${name}MTR`,
+        tokenTicker: "MTR",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1_000_000n,
+      });
+      sharedIssuerWallet = issuerWallet;
+      sharedUserWallet = userWallet;
+      sharedTokenPublicKey = await issuerWallet.getIdentityPublicKey();
+
       await sharedIssuerWallet.mintTokens(tokenAmount);
 
       const sharedIssuerBalance =
@@ -296,6 +311,20 @@ describe.each(TEST_CONFIGS)(
     it("should mint and batchtransfer tokens", async () => {
       const tokenAmount: bigint = 999n;
 
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: config,
+        });
+      await issuerWallet.createToken({
+        tokenName: `${name}MBN`,
+        tokenTicker: "MBN",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1_000_000n,
+      });
+      sharedIssuerWallet = issuerWallet;
+      sharedTokenPublicKey = await issuerWallet.getIdentityPublicKey();
+
       const { wallet: destinationWallet } = await SparkWalletTesting.initialize(
         {
           options: config,
@@ -409,117 +438,128 @@ describe.each(TEST_CONFIGS)(
           options: config,
         });
 
-      await fundAndAnnounce(issuerWallet, 1n, 0, "MST", "MST");
+      await issuerWallet.createToken({
+        tokenName: "MST",
+        tokenTicker: "MST",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1n,
+      });
       await issuerWallet.mintTokens(tokenAmount);
 
       const tokenBalance = await issuerWallet.getIssuerTokenBalance();
       expect(tokenBalance.balance).toEqual(tokenAmount);
     });
 
-    it("it should be able to announce a token with name of size equal to MAX_SYMBOL_SIZE", async () => {
+    it("it should be able to create a token with name of size equal to MAX_SYMBOL_SIZE", async () => {
       const { wallet: issuerWallet } =
         await IssuerSparkWalletTesting.initialize({
           options: config,
         });
 
-      await fundAndAnnounce(issuerWallet, 1n, 0, "MST", "TESTAA");
+      await issuerWallet.createToken({
+        tokenName: "MST",
+        tokenTicker: "TESTAA",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1n,
+      });
     });
 
-    it("it should be able to announce a token with symbol of size equal to MAX_NAME_SIZE", async () => {
+    it("it should be able to create a token with symbol of size equal to MAX_NAME_SIZE", async () => {
       const { wallet: issuerWallet } =
         await IssuerSparkWalletTesting.initialize({
           options: config,
         });
 
-      await fundAndAnnounce(issuerWallet, 1n, 0, "ABCDEFGHIJKLMNOPQ", "MQS");
+      await issuerWallet.createToken({
+        tokenName: "ABCDEFGHIJKLMNOPQ",
+        tokenTicker: "MQS",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1n,
+      });
     });
 
-    it("it should NOT be able to announce a token with ( symbol size + name size ) > MAX_NAME_AND_SYMBOL_SIZE", async () => {
+    it("should create, mint, freeze and unfreeze tokens", async () => {
+      const tokenAmount: bigint = 1000n;
       const { wallet: issuerWallet } =
         await IssuerSparkWalletTesting.initialize({
           options: config,
         });
 
-      await expect(
-        fundAndAnnounce(issuerWallet, 1n, 0, "ABCDEFGHIJKLMNOPQ", "TESTAB"),
-      ).rejects.toThrow();
-    });
-
-    it("it should NOT be able to announce a token with ( symbol size + name size ) > MAX_NAME_AND_SYMBOL_SIZE, and size is calculated in bytes", async () => {
-      const { wallet: issuerWallet } =
-        await IssuerSparkWalletTesting.initialize({
-          options: config,
-        });
+      await issuerWallet.createToken({
+        tokenName: `${name}FRZ`,
+        tokenTicker: "FRZ",
+        decimals: 0,
+        isFreezable: true,
+        maxSupply: 100000n,
+      });
+      await issuerWallet.mintTokens(tokenAmount);
 
-      await expect(
-        fundAndAnnounce(issuerWallet, 1n, 0, "ABCDEFGHIJKLMNOPQ", "🥸🥸"),
-      ).rejects.toThrow();
-    });
+      // Check issuer balance after minting
+      const issuerBalanceObjAfterMint =
+        await issuerWallet.getIssuerTokenBalance();
+      expect(issuerBalanceObjAfterMint).toBeDefined();
+      expect(issuerBalanceObjAfterMint.tokenIdentifier).toBeDefined();
 
-    // freeze is hardcoded to mainnet
-    brokenTestFn(
-      "should announce, mint, freeze and unfreeze tokens",
-      async () => {
-        const tokenAmount: bigint = 1000n;
-        const { wallet: issuerWallet } =
-          await IssuerSparkWalletTesting.initialize({
-            options: config,
-          });
+      const issuerBalanceAfterMint = issuerBalanceObjAfterMint.balance;
+      const tokenIdentifier = issuerBalanceObjAfterMint.tokenIdentifier!;
 
-        await fundAndAnnounce(issuerWallet, 100000n, 0, `${name}FR`, "FRT");
-        await issuerWallet.mintTokens(tokenAmount);
+      expect(issuerBalanceAfterMint).toEqual(tokenAmount);
 
-        // Check issuer balance after minting
-        const issuerBalanceObjAfterMint =
-          await issuerWallet.getIssuerTokenBalance();
-        expect(issuerBalanceObjAfterMint).toBeDefined();
-        expect(issuerBalanceObjAfterMint.tokenIdentifier).toBeDefined();
+      const { wallet: userWallet } = await SparkWalletTesting.initialize({
+        options: config,
+      });
+      const userSparkAddress = await userWallet.getSparkAddress();
 
-        const issuerBalanceAfterMint = issuerBalanceObjAfterMint.balance;
-        const tokenIdentifier = issuerBalanceObjAfterMint.tokenIdentifier!;
+      await issuerWallet.transferTokens({
+        tokenAmount,
+        tokenIdentifier,
+        receiverSparkAddress: userSparkAddress,
+      });
+      const issuerBalanceAfterTransfer = (
+        await issuerWallet.getIssuerTokenBalance()
+      ).balance;
+      expect(issuerBalanceAfterTransfer).toEqual(0n);
 
-        expect(issuerBalanceAfterMint).toEqual(tokenAmount);
+      const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
+      const userBalanceObj = await userWallet.getBalance();
+      const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
+        userBalanceObj?.tokenBalances,
+        tokenPublicKey,
+      );
+      expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
 
-        const { wallet: userWallet } = await SparkWalletTesting.initialize({
-          options: config,
-        });
-        const userWalletPublicKey = await userWallet.getSparkAddress();
+      // Freeze tokens
+      const freezeResponse = await issuerWallet.freezeTokens(userSparkAddress);
+      expect(freezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
+      expect(freezeResponse.impactedTokenAmount).toEqual(tokenAmount);
 
-        await issuerWallet.transferTokens({
-          tokenAmount,
-          tokenIdentifier,
-          receiverSparkAddress: userWalletPublicKey,
-        });
-        const issuerBalanceAfterTransfer = (
-          await issuerWallet.getIssuerTokenBalance()
-        ).balance;
-        expect(issuerBalanceAfterTransfer).toEqual(0n);
-
-        const tokenPublicKey = await issuerWallet.getIdentityPublicKey();
-        const userBalanceObj = await userWallet.getBalance();
-        const userBalanceAfterTransfer = filterTokenBalanceForTokenPublicKey(
-          userBalanceObj?.tokenBalances,
-          tokenPublicKey,
-        );
-        expect(userBalanceAfterTransfer.balance).toEqual(tokenAmount);
-
-        // Freeze tokens
-        const freezeResponse =
-          await issuerWallet.freezeTokens(userWalletPublicKey);
-        expect(freezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
-        expect(freezeResponse.impactedTokenAmount).toEqual(tokenAmount);
-
-        // Unfreeze tokens
-        const unfreezeResponse =
-          await issuerWallet.unfreezeTokens(userWalletPublicKey);
-        expect(unfreezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
-        expect(unfreezeResponse.impactedTokenAmount).toEqual(tokenAmount);
-      },
-    );
+      // Unfreeze tokens
+      const unfreezeResponse =
+        await issuerWallet.unfreezeTokens(userSparkAddress);
+      expect(unfreezeResponse.impactedOutputIds.length).toBeGreaterThan(0);
+      expect(unfreezeResponse.impactedTokenAmount).toEqual(tokenAmount);
+    });
 
     it("should mint and burn tokens", async () => {
       const tokenAmount: bigint = 200n;
 
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: config,
+        });
+      await issuerWallet.createToken({
+        tokenName: `${name}MBN`,
+        tokenTicker: "MBN",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1_000_000n,
+      });
+      sharedIssuerWallet = issuerWallet;
+      sharedTokenPublicKey = await issuerWallet.getIdentityPublicKey();
+
       await sharedIssuerWallet.mintTokens(tokenAmount);
       const issuerTokenBalance = (
         await sharedIssuerWallet.getIssuerTokenBalance()
@@ -536,9 +576,23 @@ describe.each(TEST_CONFIGS)(
       );
     });
 
-    it("should complete full token lifecycle: announce, mint, transfer, return, burn", async () => {
+    it("should complete full token lifecycle: create, mint, transfer, return, burn", async () => {
       const tokenAmount: bigint = 1000n;
 
+      const { wallet: issuerWallet } =
+        await IssuerSparkWalletTesting.initialize({
+          options: config,
+        });
+      await issuerWallet.createToken({
+        tokenName: `${name}LFC`,
+        tokenTicker: "LFC",
+        decimals: 0,
+        isFreezable: false,
+        maxSupply: 1_000_000n,
+      });
+      sharedIssuerWallet = issuerWallet;
+      sharedTokenPublicKey = await issuerWallet.getIdentityPublicKey();
+
       const { wallet: userWallet } = await SparkWalletTesting.initialize({
         options: config,
       });
@@ -554,12 +608,12 @@ describe.each(TEST_CONFIGS)(
       expect(issuerBalanceAfterMint).toEqual(initialBalance + tokenAmount);
       expect(issuerBalanceObjAfterMint.tokenIdentifier).toBeDefined();
       const tokenIdentifier = issuerBalanceObjAfterMint.tokenIdentifier!;
-      const userWalletPublicKey = await userWallet.getSparkAddress();
+      const userSparkAddress = await userWallet.getSparkAddress();
 
       await sharedIssuerWallet.transferTokens({
         tokenAmount,
         tokenIdentifier,
-        receiverSparkAddress: userWalletPublicKey,
+        receiverSparkAddress: userSparkAddress,
       });
 
       const issuerBalanceAfterTransfer = (
@@ -708,40 +762,3 @@ describe.each(TEST_CONFIGS)(
     );
   },
 );
-
-async function fundAndAnnounce(
-  wallet: IssuerSparkWallet,
-  maxSupply: bigint = 100000n,
-  decimals: number = 0,
-  tokenName: string = "TestToken1",
-  tokenSymbol: string = "TT1",
-  isFreezable: boolean = false,
-) {
-  // Faucet funds to the Issuer wallet because announcing a token
-  // requires ownership of an L1 UTXO.
-  const faucet = BitcoinFaucet.getInstance();
-  const l1WalletPubKey = await wallet.getTokenL1Address();
-  await faucet.sendToAddress(l1WalletPubKey, 100_000n);
-  await faucet.mineBlocks(6);
-
-  await new Promise((resolve) => setTimeout(resolve, 3000));
-
-  try {
-    const response = await wallet.announceTokenL1(
-      tokenName,
-      tokenSymbol,
-      decimals,
-      maxSupply,
-      isFreezable,
-    );
-    console.log("Announce token response:", response);
-  } catch (error: any) {
-    console.error("Error when announcing token on L1:", error);
-    throw error;
-  }
-  await faucet.mineBlocks(2);
-
-  // Wait for LRC20 processing.
-  const SECONDS = 1000;
-  await new Promise((resolve) => setTimeout(resolve, 3 * SECONDS));
-}

package/src/tests/utils/spark-testing-wallet.ts

@@ -1,8 +1,8 @@
 import {
+  ConfigOptions,
+  SparkSigner,
   SparkWallet,
   SparkWalletProps,
-  SparkSigner,
-  ConfigOptions,
 } from "@buildonspark/spark-sdk";
 import {
   type QueryTransfersResponse,

package/src/utils/token-hashing.ts

@@ -1,5 +1,5 @@
 import { sha256 } from "@scure/btc-signer/utils";
-import { FreezeTokensPayload } from "@buildonspark/spark-sdk/proto/spark";
+import { FreezeTokensPayload } from "@buildonspark/spark-sdk/proto/spark_token";
 import { ValidationError } from "@buildonspark/spark-sdk";
 
 export function hashFreezeTokensPayload(
@@ -15,6 +15,17 @@ export function hashFreezeTokensPayload(
 
   let allHashes: Uint8Array[] = [];
 
+  // Hash version
+  const versionHashObj = sha256.create();
+  const versionBytes = new Uint8Array(4);
+  new DataView(versionBytes.buffer).setUint32(
+    0,
+    payload.version,
+    false, // false for big-endian
+  );
+  versionHashObj.update(versionBytes);
+  allHashes.push(versionHashObj.digest());
+
   // Hash owner public key
   const ownerPubKeyHash = sha256.create();
   if (payload.ownerPublicKey) {
@@ -22,12 +33,12 @@ export function hashFreezeTokensPayload(
   }
   allHashes.push(ownerPubKeyHash.digest());
 
-  // Hash token public key
-  const tokenPubKeyHash = sha256.create();
-  if (payload.tokenPublicKey) {
-    tokenPubKeyHash.update(payload.tokenPublicKey);
+  // Hash token identifier
+  const tokenIdentifierHash = sha256.create();
+  if (payload.tokenIdentifier) {
+    tokenIdentifierHash.update(payload.tokenIdentifier);
   }
-  allHashes.push(tokenPubKeyHash.digest());
+  allHashes.push(tokenIdentifierHash.digest());
 
   // Hash shouldUnfreeze
   const shouldUnfreezeHash = sha256.create();