@buildonspark/issuer-sdk 0.1.6 → 0.1.7

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

@@ -1,938 +1,690 @@
 require("react-native-get-random-values");
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { DefaultSparkSigner, SparkError, SparkRequestError, SparkValidationError, SparkWallet, TokenTransactionService, UnsafeStatelessSparkSigner, WalletConfig, collectResponses, decodeBech32mTokenIdentifier, decodeSparkAddress, encodeBech32mTokenIdentifier, encodeSparkAddress, hashFinalTokenTransaction } from "@buildonspark/spark-sdk";
+import { bytesToHex, bytesToNumberBE, hexToBytes, numberToBytesBE } from "@noble/curves/utils";
+import { sha256 } from "@scure/btc-signer/utils";
 
-// buffer.js
-import { Buffer as Buffer2 } from "buffer";
-if (typeof globalThis.Buffer === "undefined") {
-  globalThis.Buffer = Buffer2;
+//#region src/utils/token-hashing.ts
+function hashFreezeTokensPayload(payload) {
+	if (!payload) throw new SparkValidationError("Freeze tokens payload cannot be nil", {
+		field: "payload",
+		value: payload,
+		expected: "valid freeze tokens payload"
+	});
+	let allHashes = [];
+	const versionHashObj = sha256.create();
+	const versionBytes = new Uint8Array(4);
+	new DataView(versionBytes.buffer).setUint32(0, payload.version, false);
+	versionHashObj.update(versionBytes);
+	allHashes.push(versionHashObj.digest());
+	const ownerPubKeyHash = sha256.create();
+	if (payload.ownerPublicKey) ownerPubKeyHash.update(payload.ownerPublicKey);
+	allHashes.push(ownerPubKeyHash.digest());
+	const tokenIdentifierHash = sha256.create();
+	if (payload.tokenIdentifier) tokenIdentifierHash.update(payload.tokenIdentifier);
+	allHashes.push(tokenIdentifierHash.digest());
+	const shouldUnfreezeHash = sha256.create();
+	shouldUnfreezeHash.update(new Uint8Array([payload.shouldUnfreeze ? 1 : 0]));
+	allHashes.push(shouldUnfreezeHash.digest());
+	const timestampHash = sha256.create();
+	if (payload.issuerProvidedTimestamp) {
+		const timestampBytes = new Uint8Array(8);
+		new DataView(timestampBytes.buffer).setBigUint64(0, BigInt(payload.issuerProvidedTimestamp), true);
+		timestampHash.update(timestampBytes);
+	}
+	allHashes.push(timestampHash.digest());
+	const operatorPubKeyHash = sha256.create();
+	if (payload.operatorIdentityPublicKey) operatorPubKeyHash.update(payload.operatorIdentityPublicKey);
+	allHashes.push(operatorPubKeyHash.digest());
+	const finalHash = sha256.create();
+	for (const hash of allHashes) finalHash.update(hash);
+	return finalHash.digest();
 }
-if (typeof window !== "undefined") {
-  if (typeof window.global === "undefined") {
-    window.global = window;
-  }
-  if (typeof window.globalThis === "undefined") {
-    window.globalThis = window;
-  }
+
+//#endregion
+//#region \0@oxc-project+runtime@0.108.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
 }
 
-// src/issuer-wallet/issuer-spark-wallet.ts
-import {
-  decodeBech32mTokenIdentifier,
-  decodeSparkAddress,
-  encodeBech32mTokenIdentifier,
-  encodeSparkAddress,
-  SparkError,
-  SparkWallet,
-  SparkRequestError as SparkRequestError2,
-  SparkValidationError as SparkValidationError3
-} from "@buildonspark/spark-sdk";
-import { bytesToHex, bytesToNumberBE, hexToBytes as hexToBytes2 } from "@noble/curves/utils";
+//#endregion
+//#region \0@oxc-project+runtime@0.108.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
 
-// src/services/freeze.ts
-import {
-  SparkRequestError,
-  collectResponses
-} from "@buildonspark/spark-sdk";
-import { hexToBytes } from "@noble/curves/utils";
+//#endregion
+//#region \0@oxc-project+runtime@0.108.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
 
-// src/utils/token-hashing.ts
-import { sha256 } from "@scure/btc-signer/utils";
-import { SparkValidationError } from "@buildonspark/spark-sdk";
-function hashFreezeTokensPayload(payload) {
-  if (!payload) {
-    throw new SparkValidationError("Freeze tokens payload cannot be nil", {
-      field: "payload",
-      value: payload,
-      expected: "valid freeze tokens 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 tokenIdentifierHash = sha256.create();
-  if (payload.tokenIdentifier) {
-    tokenIdentifierHash.update(payload.tokenIdentifier);
-  }
-  allHashes.push(tokenIdentifierHash.digest());
-  const shouldUnfreezeHash = sha256.create();
-  shouldUnfreezeHash.update(new Uint8Array([payload.shouldUnfreeze ? 1 : 0]));
-  allHashes.push(shouldUnfreezeHash.digest());
-  const timestampHash = sha256.create();
-  if (payload.issuerProvidedTimestamp) {
-    const timestampBytes = new Uint8Array(8);
-    new DataView(timestampBytes.buffer).setBigUint64(
-      0,
-      BigInt(payload.issuerProvidedTimestamp),
-      true
-      // true for little-endian
-    );
-    timestampHash.update(timestampBytes);
-  }
-  allHashes.push(timestampHash.digest());
-  const operatorPubKeyHash = sha256.create();
-  if (payload.operatorIdentityPublicKey) {
-    operatorPubKeyHash.update(payload.operatorIdentityPublicKey);
-  }
-  allHashes.push(operatorPubKeyHash.digest());
-  const finalHash = sha256.create();
-  for (const hash of allHashes) {
-    finalHash.update(hash);
-  }
-  return finalHash.digest();
+//#endregion
+//#region \0@oxc-project+runtime@0.108.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
 }
 
-// src/services/freeze.ts
+//#endregion
+//#region src/services/freeze.ts
 var TokenFreezeService = class {
-  constructor(config, connectionManager) {
-    __publicField(this, "config");
-    __publicField(this, "connectionManager");
-    this.config = config;
-    this.connectionManager = connectionManager;
-  }
-  async freezeTokens({
-    ownerPublicKey,
-    tokenIdentifier
-  }) {
-    return this.freezeOperation(ownerPublicKey, false, tokenIdentifier);
-  }
-  async unfreezeTokens({
-    ownerPublicKey,
-    tokenIdentifier
-  }) {
-    return this.freezeOperation(ownerPublicKey, true, tokenIdentifier);
-  }
-  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 sparkTokenClient = await this.connectionManager.createSparkTokenClient(operator.address);
-        const freezeTokensPayload = {
-          version: 1,
-          ownerPublicKey,
-          tokenIdentifier,
-          shouldUnfreeze,
-          issuerProvidedTimestamp,
-          operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
-        };
-        const hashedPayload = hashFreezeTokensPayload(freezeTokensPayload);
-        const issuerSignature = await this.config.signer.signMessageWithIdentityKey(hashedPayload);
-        try {
-          const response = await sparkTokenClient.freeze_tokens({
-            freezeTokensPayload,
-            issuerSignature
-          });
-          return {
-            identifier,
-            response
-          };
-        } catch (error) {
-          throw new SparkRequestError(
-            `Failed to send a freeze/unfreeze operation to operator: ${operator.address}`,
-            { operation: "freeze_tokens", error }
-          );
-        }
-      })
-    );
-    const successfulResponses = collectResponses(freezeResponses);
-    return successfulResponses[0].response;
-  }
+	constructor(config, connectionManager) {
+		_defineProperty(this, "config", void 0);
+		_defineProperty(this, "connectionManager", void 0);
+		this.config = config;
+		this.connectionManager = connectionManager;
+	}
+	async freezeTokens({ ownerPublicKey, tokenIdentifier }) {
+		return this.freezeOperation(ownerPublicKey, false, tokenIdentifier);
+	}
+	async unfreezeTokens({ ownerPublicKey, tokenIdentifier }) {
+		return this.freezeOperation(ownerPublicKey, true, tokenIdentifier);
+	}
+	async freezeOperation(ownerPublicKey, shouldUnfreeze, tokenIdentifier) {
+		const signingOperators = this.config.getSigningOperators();
+		const issuerProvidedTimestamp = Date.now();
+		return collectResponses(await Promise.allSettled(Object.entries(signingOperators).map(async ([identifier, operator]) => {
+			const sparkTokenClient = await this.connectionManager.createSparkTokenClient(operator.address);
+			const freezeTokensPayload = {
+				version: 1,
+				ownerPublicKey,
+				tokenIdentifier,
+				shouldUnfreeze,
+				issuerProvidedTimestamp,
+				operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
+			};
+			const hashedPayload = hashFreezeTokensPayload(freezeTokensPayload);
+			const issuerSignature = await this.config.signer.signMessageWithIdentityKey(hashedPayload);
+			try {
+				return {
+					identifier,
+					response: await sparkTokenClient.freeze_tokens({
+						freezeTokensPayload,
+						issuerSignature
+					})
+				};
+			} catch (error) {
+				throw new SparkRequestError(`Failed to send a freeze/unfreeze operation to operator: ${operator.address}`, {
+					operation: "freeze_tokens",
+					error
+				});
+			}
+		})))[0].response;
+	}
 };
 
-// src/services/token-transactions.ts
-import {
-  TokenTransactionService
-} from "@buildonspark/spark-sdk";
-import { numberToBytesBE } from "@noble/curves/utils";
+//#endregion
+//#region src/services/token-transactions.ts
 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: {
-        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
-        }
-      },
-      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: []
-    };
-  }
-  async constructPartialCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata) {
-    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,
-          tokenTicker,
-          decimals,
-          maxSupply: numberToBytesBE(maxSupply, 16),
-          isFreezable,
-          extraMetadata
-        }
-      },
-      partialTokenOutputs: []
-    };
-  }
+	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: {
+				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
+				}
+			},
+			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: []
+		};
+	}
+	async constructPartialCreateTokenTransaction(tokenPublicKey, tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata) {
+		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,
+					tokenTicker,
+					decimals,
+					maxSupply: numberToBytesBE(maxSupply, 16),
+					isFreezable,
+					extraMetadata
+				}
+			},
+			partialTokenOutputs: []
+		};
+	}
 };
 
-// src/issuer-wallet/issuer-spark-wallet.ts
-import { hashFinalTokenTransaction } from "@buildonspark/spark-sdk";
-
-// src/utils/create-validation.ts
-import { SparkValidationError as SparkValidationError2 } from "@buildonspark/spark-sdk";
+//#endregion
+//#region src/utils/create-validation.ts
+/**
+* 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) {
-  return value.normalize("NFC") === 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;
-var MAX_TOKEN_CONTENT_SIZE = 1024;
+const MIN_NAME_SIZE = 3;
+const MAX_NAME_SIZE = 20;
+const MIN_SYMBOL_SIZE = 3;
+const MAX_SYMBOL_SIZE = 6;
+const MAX_DECIMALS = 255;
+const MAXIMUM_MAX_SUPPLY = (1n << 128n) - 1n;
+const MAX_TOKEN_CONTENT_SIZE = 1024;
 function validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply, extraMetadata) {
-  if (!isNfcNormalized(tokenName)) {
-    throw new SparkValidationError2("Token name must be NFC-normalised UTF-8", {
-      field: "tokenName",
-      value: tokenName,
-      expected: "NFC normalised string"
-    });
-  }
-  if (!isNfcNormalized(tokenTicker)) {
-    throw new SparkValidationError2(
-      "Token ticker must be NFC-normalised UTF-8",
-      {
-        field: "tokenTicker",
-        value: tokenTicker,
-        expected: "NFC normalised string"
-      }
-    );
-  }
-  const nameBytes = Buffer2.from(tokenName, "utf-8").length;
-  if (nameBytes < MIN_NAME_SIZE || nameBytes > MAX_NAME_SIZE) {
-    throw new SparkValidationError2(
-      `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 = Buffer2.from(tokenTicker, "utf-8").length;
-  if (tickerBytes < MIN_SYMBOL_SIZE || tickerBytes > MAX_SYMBOL_SIZE) {
-    throw new SparkValidationError2(
-      `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 SparkValidationError2(
-      `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 SparkValidationError2(`maxSupply must be between 0 and 2^128-1`, {
-      field: "maxSupply",
-      value: maxSupply.toString(),
-      expected: `>=0 and <=${MAXIMUM_MAX_SUPPLY.toString()}`
-    });
-  }
-  if (extraMetadata && extraMetadata.length > MAX_TOKEN_CONTENT_SIZE) {
-    throw new SparkValidationError2(
-      `Extra metadata must be less than ${MAX_TOKEN_CONTENT_SIZE} bytes`,
-      {
-        field: "extraMetadata",
-        value: extraMetadata.length,
-        expected: `<${MAX_TOKEN_CONTENT_SIZE}`
-      }
-    );
-  }
+	if (!isNfcNormalized(tokenName)) throw new SparkValidationError("Token name must be NFC-normalised UTF-8", {
+		field: "tokenName",
+		value: tokenName,
+		expected: "NFC normalised string"
+	});
+	if (!isNfcNormalized(tokenTicker)) throw new SparkValidationError("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 SparkValidationError(`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 SparkValidationError(`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 SparkValidationError(`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 SparkValidationError(`maxSupply must be between 0 and 2^128-1`, {
+		field: "maxSupply",
+		value: maxSupply.toString(),
+		expected: `>=0 and <=${MAXIMUM_MAX_SUPPLY.toString()}`
+	});
+	if (extraMetadata && extraMetadata.length > MAX_TOKEN_CONTENT_SIZE) throw new SparkValidationError(`Extra metadata must be less than ${MAX_TOKEN_CONTENT_SIZE} bytes`, {
+		field: "extraMetadata",
+		value: extraMetadata.length,
+		expected: `<${MAX_TOKEN_CONTENT_SIZE}`
+	});
 }
 
-// src/issuer-wallet/issuer-spark-wallet.ts
-var BURN_ADDRESS = "02".repeat(33);
+//#endregion
+//#region src/issuer-wallet/issuer-spark-wallet.ts
+const BURN_ADDRESS = "02".repeat(33);
+/**
+* Represents a Spark wallet with minting capabilities.
+* This class extends the base SparkWallet with additional functionality for token minting,
+* burning, and freezing operations.
+*/
 var IssuerSparkWallet = class extends SparkWallet {
-  /**
-   * Initializes a new IssuerSparkWallet instance.
-   * Inherits the generic static initialize from the base class.
-   */
-  constructor(configOptions, signer) {
-    super(configOptions, signer);
-    __publicField(this, "issuerTokenTransactionService");
-    __publicField(this, "tokenFreezeService");
-    __publicField(this, "tracerId", "issuer-sdk");
-    this.issuerTokenTransactionService = new IssuerTokenTransactionService(
-      this.config,
-      this.connectionManager
-    );
-    this.tokenFreezeService = new TokenFreezeService(
-      this.config,
-      this.connectionManager
-    );
-    this.wrapIssuerSparkWalletMethods();
-  }
-  /**
-   * Gets the token balance for the issuer's token.
-   * @deprecated Use getIssuerTokenBalances() instead. This method will be removed in a future version.
-   * @returns An object containing the token balance as a bigint
-   *
-   * @throws {SparkValidationError} If multiple tokens are found for this issuer
-   */
-  async getIssuerTokenBalance() {
-    const publicKey = await super.getIdentityPublicKey();
-    const balanceObj = await this.getBalance();
-    const issuerBalance = [...balanceObj.tokenBalances.entries()].filter(
-      ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey
-    );
-    if (issuerBalance.length > 1) {
-      throw new SparkValidationError3(
-        "Multiple tokens found for this issuer. Use getIssuerTokenBalances() instead.",
-        {
-          field: "issuerTokenBalance",
-          expected: "single token",
-          actual: `${issuerBalance.length} tokens`
-        }
-      );
-    }
-    if (issuerBalance.length === 0) {
-      return {
-        tokenIdentifier: void 0,
-        balance: 0n
-      };
-    }
-    return {
-      tokenIdentifier: issuerBalance[0][0],
-      balance: issuerBalance[0][1].balance
-    };
-  }
-  /**
-   * Gets the token balances for the tokens that were issued by this user.
-   * @returns An array of objects containing the token identifier and balance
-   */
-  async getIssuerTokenBalances() {
-    const publicKey = await super.getIdentityPublicKey();
-    const balanceObj = await this.getBalance();
-    const issuerBalance = [...balanceObj.tokenBalances.entries()].filter(
-      ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey
-    );
-    if (issuerBalance.length === 0) {
-      return [
-        {
-          tokenIdentifier: void 0,
-          balance: 0n
-        }
-      ];
-    }
-    return issuerBalance.map(([tokenIdentifier, { balance }]) => ({
-      tokenIdentifier,
-      balance
-    }));
-  }
-  /**
-   * Retrieves information about the issuer's token.
-   * @deprecated Use getIssuerTokensMetadata() instead. This method will be removed in a future version.
-   * @returns An object containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
-   * @throws {SparkRequestError} If the token metadata cannot be retrieved
-   * @throws {SparkValidationError} If multiple tokens are found for this issuer
-   */
-  async getIssuerTokenMetadata() {
-    const tokensMetadata = await this.getIssuerTokensMetadata();
-    if (tokensMetadata.length === 0) {
-      throw new SparkValidationError3("No tokens found. Create a token first.");
-    }
-    if (tokensMetadata.length > 1) {
-      throw new SparkValidationError3(
-        "Multiple tokens found for this issuer. Please migrate to getIssuerTokensMetadata() instead.",
-        {
-          field: "tokenMetadata",
-          value: tokensMetadata
-        }
-      );
-    }
-    return tokensMetadata[0];
-  }
-  /**
-   * Retrieves information about the tokens that were issued by this user.
-   * @param tokenIdentifiers - Optional array of specific token identifiers to fetch.
-   *                           If omitted, all tokens for this issuer are fetched.
-   * @returns An array of objects containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
-   * @throws {SparkRequestError} If the token metadata cannot be retrieved
-   */
-  async getIssuerTokensMetadata(tokenIdentifiers) {
-    const issuerPublicKey = await super.getIdentityPublicKey();
-    const sparkTokenClient = await this.connectionManager.createSparkTokenClient(
-      this.config.getCoordinatorAddress()
-    );
-    const filterByIdentifiers = Array.isArray(tokenIdentifiers) && tokenIdentifiers.length > 0;
-    const tokenIdentifierSet = filterByIdentifiers ? new Set(tokenIdentifiers) : void 0;
-    const request = {};
-    if (filterByIdentifiers) {
-      request.tokenIdentifiers = tokenIdentifiers.map(
-        (id) => decodeBech32mTokenIdentifier(id, this.config.getNetworkType()).tokenIdentifier
-      );
-    } else {
-      request.issuerPublicKeys = Array.of(hexToBytes2(issuerPublicKey));
-    }
-    try {
-      const response = await sparkTokenClient.query_token_metadata(request);
-      const tokenMetadata = [];
-      for (const metadata of response.tokenMetadata) {
-        const bech32mTokenIdentifier = encodeBech32mTokenIdentifier({
-          tokenIdentifier: metadata.tokenIdentifier,
-          network: this.config.getNetworkType()
-        });
-        if (bytesToHex(metadata.issuerPublicKey) !== issuerPublicKey) {
-          continue;
-        }
-        if (filterByIdentifiers && !tokenIdentifierSet.has(bech32mTokenIdentifier)) {
-          continue;
-        }
-        this.tokenMetadata.set(bech32mTokenIdentifier, metadata);
-        tokenMetadata.push({
-          tokenPublicKey: bytesToHex(metadata.issuerPublicKey),
-          rawTokenIdentifier: metadata.tokenIdentifier,
-          tokenName: metadata.tokenName,
-          tokenTicker: metadata.tokenTicker,
-          decimals: metadata.decimals,
-          maxSupply: bytesToNumberBE(metadata.maxSupply),
-          isFreezable: metadata.isFreezable,
-          extraMetadata: metadata.extraMetadata ? new Uint8Array(metadata.extraMetadata) : void 0,
-          bech32mTokenIdentifier
-        });
-      }
-      return tokenMetadata;
-    } catch (error) {
-      if (error instanceof SparkError) {
-        throw error;
-      }
-      throw new SparkRequestError2("Failed to fetch token metadata", { error });
-    }
-  }
-  /**
-   * Retrieves the bech32m encoded token identifier for the issuer's token.
-   * @deprecated Use getIssuerTokenIdentifiers() instead. This method will be removed in a future version.
-   * @returns The bech32m encoded token identifier for the issuer's token
-   * @throws {SparkRequestError} If the token identifier cannot be retrieved
-   * @throws {SparkValidationError} If multiple tokens are found for this issuer
-   */
-  async getIssuerTokenIdentifier() {
-    const tokensMetadata = await this.getIssuerTokensMetadata();
-    if (tokensMetadata.length === 0) {
-      throw new SparkValidationError3("No tokens found. Create a token first.");
-    }
-    if (tokensMetadata.length > 1) {
-      throw new SparkValidationError3(
-        "Multiple tokens found. Use getIssuerTokenIdentifiers() instead.",
-        {
-          method: "getIssuerTokenIdentifier",
-          availableTokens: tokensMetadata.map((t) => ({
-            tokenName: t.tokenName,
-            tokenTicker: t.tokenTicker,
-            bech32mTokenIdentifier: encodeBech32mTokenIdentifier({
-              tokenIdentifier: t.rawTokenIdentifier,
-              network: this.config.getNetworkType()
-            })
-          }))
-        }
-      );
-    }
-    return tokensMetadata[0].bech32mTokenIdentifier;
-  }
-  /**
-   * Retrieves the bech32m encoded token identifier for the issuer's token.
-   * @returns The bech32m encoded token identifier for the issuer's token
-   * @throws {SparkRequestError} If the token identifier cannot be retrieved
-   */
-  async getIssuerTokenIdentifiers() {
-    const tokensMetadata = await this.getIssuerTokensMetadata();
-    return tokensMetadata.map((metadata) => metadata.bech32mTokenIdentifier);
-  }
-  async createToken({
-    tokenName,
-    tokenTicker,
-    decimals,
-    isFreezable,
-    maxSupply = 0n,
-    extraMetadata,
-    returnIdentifierForCreate = false
-  }) {
-    validateTokenParameters(
-      tokenName,
-      tokenTicker,
-      decimals,
-      maxSupply,
-      extraMetadata
-    );
-    const issuerPublicKey = await super.getIdentityPublicKey();
-    if (this.config.getTokenTransactionVersion() === "V2") {
-      const tokenTransaction = await this.issuerTokenTransactionService.constructCreateTokenTransaction(
-        hexToBytes2(issuerPublicKey),
-        tokenName,
-        tokenTicker,
-        decimals,
-        maxSupply,
-        isFreezable,
-        extraMetadata
-      );
-      const { finalTokenTransactionHash, tokenIdentifier } = await this.issuerTokenTransactionService.broadcastTokenTransactionDetailed(
-        tokenTransaction
-      );
-      const txHash = bytesToHex(finalTokenTransactionHash);
-      if (returnIdentifierForCreate) {
-        if (!tokenIdentifier) {
-          throw new SparkRequestError2(
-            "Server response missing expected field: tokenIdentifier",
-            {
-              operation: "broadcast_transaction",
-              field: "tokenIdentifier"
-            }
-          );
-        }
-        const bech32mTokenIdentifier = encodeBech32mTokenIdentifier({
-          tokenIdentifier,
-          network: this.config.getNetworkType()
-        });
-        return {
-          tokenIdentifier: bech32mTokenIdentifier,
-          transactionHash: txHash
-        };
-      }
-      return txHash;
-    } else {
-      const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialCreateTokenTransaction(
-        hexToBytes2(issuerPublicKey),
-        tokenName,
-        tokenTicker,
-        decimals,
-        maxSupply,
-        isFreezable,
-        extraMetadata
-      );
-      const broadcastResponse = await this.issuerTokenTransactionService.broadcastTokenTransactionV3Detailed(
-        partialTokenTransaction
-      );
-      const finalHash = await hashFinalTokenTransaction(
-        broadcastResponse.finalTokenTransaction
-      );
-      const finalTransactionHash = bytesToHex(finalHash);
-      if (returnIdentifierForCreate) {
-        if (!broadcastResponse.tokenIdentifier) {
-          throw new SparkRequestError2(
-            "Server response missing expected field: tokenIdentifier",
-            {
-              operation: "broadcast_transaction",
-              field: "tokenIdentifier"
-            }
-          );
-        }
-        const tokenIdentifier = encodeBech32mTokenIdentifier({
-          tokenIdentifier: broadcastResponse.tokenIdentifier,
-          network: this.config.getNetworkType()
-        });
-        return {
-          tokenIdentifier,
-          transactionHash: finalTransactionHash
-        };
-      }
-      return finalTransactionHash;
-    }
-  }
-  async mintTokens(tokenAmountOrParams) {
-    let tokenAmount;
-    let bech32mTokenIdentifier;
-    if (typeof tokenAmountOrParams === "bigint") {
-      tokenAmount = tokenAmountOrParams;
-      bech32mTokenIdentifier = void 0;
-    } else {
-      tokenAmount = tokenAmountOrParams.tokenAmount;
-      bech32mTokenIdentifier = tokenAmountOrParams.tokenIdentifier;
-    }
-    const issuerTokenPublicKey = await super.getIdentityPublicKey();
-    const issuerTokenPublicKeyBytes = hexToBytes2(issuerTokenPublicKey);
-    if (bech32mTokenIdentifier === void 0) {
-      const tokensMetadata = await this.getIssuerTokensMetadata();
-      if (tokensMetadata.length === 0) {
-        throw new SparkValidationError3(
-          "No tokens found. Create a token first."
-        );
-      }
-      if (tokensMetadata.length > 1) {
-        throw new SparkValidationError3(
-          "Multiple tokens found. Please use mintTokens({ tokenAmount, tokenIdentifier }) instead.",
-          {
-            field: "tokenIdentifier",
-            availableTokens: tokensMetadata.map((t) => ({
-              tokenName: t.tokenName,
-              tokenTicker: t.tokenTicker,
-              bech32mTokenIdentifier: t.bech32mTokenIdentifier
-            }))
-          }
-        );
-      }
-      bech32mTokenIdentifier = tokensMetadata[0].bech32mTokenIdentifier;
-    } else {
-      await this.validateTokenIssuer(bech32mTokenIdentifier);
-    }
-    const rawTokenIdentifier = decodeBech32mTokenIdentifier(
-      bech32mTokenIdentifier,
-      this.config.getNetworkType()
-    ).tokenIdentifier;
-    if (this.config.getTokenTransactionVersion() === "V2") {
-      const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-        rawTokenIdentifier,
-        issuerTokenPublicKeyBytes,
-        tokenAmount
-      );
-      return await this.issuerTokenTransactionService.broadcastTokenTransaction(
-        tokenTransaction
-      );
-    } else {
-      const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialMintTokenTransaction(
-        rawTokenIdentifier,
-        issuerTokenPublicKeyBytes,
-        tokenAmount
-      );
-      return await this.issuerTokenTransactionService.broadcastTokenTransactionV3(
-        partialTokenTransaction
-      );
-    }
-  }
-  async burnTokens(tokenAmountOrParams, selectedOutputs) {
-    let burnTokenIdentifier;
-    let tokenAmount;
-    let outputs;
-    if (typeof tokenAmountOrParams === "bigint") {
-      tokenAmount = tokenAmountOrParams;
-      outputs = selectedOutputs;
-      const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
-      if (tokenIdentifiers.length === 0) {
-        throw new SparkValidationError3(
-          "No tokens found. Create a token first."
-        );
-      }
-      if (tokenIdentifiers.length > 1) {
-        throw new SparkValidationError3(
-          "Multiple tokens found. Use burnTokens({ tokenIdentifier, tokenAmount, selectedOutputs }) to specify which token to burn.",
-          {
-            field: "tokenIdentifier",
-            availableTokens: tokenIdentifiers
-          }
-        );
-      }
-      burnTokenIdentifier = tokenIdentifiers[0];
-    } else {
-      tokenAmount = tokenAmountOrParams.tokenAmount;
-      outputs = tokenAmountOrParams.selectedOutputs;
-      await this.validateTokenIssuer(tokenAmountOrParams.tokenIdentifier);
-      burnTokenIdentifier = tokenAmountOrParams.tokenIdentifier;
-    }
-    const burnAddress = encodeSparkAddress({
-      identityPublicKey: BURN_ADDRESS,
-      network: this.config.getNetworkType()
-    });
-    return await this.transferTokens({
-      tokenIdentifier: burnTokenIdentifier,
-      tokenAmount,
-      receiverSparkAddress: burnAddress,
-      selectedOutputs: outputs
-    });
-  }
-  async freezeTokens(sparkAddressOrParams) {
-    let bech32mTokenIdentifier;
-    let sparkAddress;
-    if (typeof sparkAddressOrParams === "string") {
-      sparkAddress = sparkAddressOrParams;
-      bech32mTokenIdentifier = void 0;
-    } else {
-      sparkAddress = sparkAddressOrParams.sparkAddress;
-      bech32mTokenIdentifier = sparkAddressOrParams.tokenIdentifier;
-    }
-    const decodedOwnerPubkey = decodeSparkAddress(
-      sparkAddress,
-      this.config.getNetworkType()
-    );
-    if (bech32mTokenIdentifier === void 0) {
-      const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
-      if (tokenIdentifiers.length === 0) {
-        throw new SparkValidationError3(
-          "No tokens found. Create a token first."
-        );
-      }
-      if (tokenIdentifiers.length > 1) {
-        throw new SparkValidationError3(
-          "Multiple tokens found. Use freezeTokens({ tokenIdentifier, sparkAddress }) instead.",
-          {
-            field: "tokenIdentifier",
-            availableTokens: tokenIdentifiers
-          }
-        );
-      }
-      bech32mTokenIdentifier = tokenIdentifiers[0];
-    } else {
-      await this.validateTokenIssuer(bech32mTokenIdentifier);
-    }
-    const rawTokenIdentifier = decodeBech32mTokenIdentifier(
-      bech32mTokenIdentifier,
-      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,
-      impactedTokenAmount: tokenAmount
-    };
-  }
-  async unfreezeTokens(sparkAddressOrParams) {
-    let bech32mTokenIdentifier;
-    let sparkAddress;
-    if (typeof sparkAddressOrParams === "string") {
-      sparkAddress = sparkAddressOrParams;
-      bech32mTokenIdentifier = void 0;
-    } else {
-      sparkAddress = sparkAddressOrParams.sparkAddress;
-      bech32mTokenIdentifier = sparkAddressOrParams.tokenIdentifier;
-    }
-    if (bech32mTokenIdentifier === void 0) {
-      const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
-      if (tokenIdentifiers.length === 0) {
-        throw new SparkValidationError3(
-          "No tokens found. Create a token first."
-        );
-      }
-      if (tokenIdentifiers.length > 1) {
-        throw new SparkValidationError3(
-          "Multiple tokens found. Use unfreezeTokens({ tokenIdentifier, sparkAddress }) instead.",
-          {
-            field: "tokenIdentifier",
-            availableTokens: tokenIdentifiers
-          }
-        );
-      }
-      bech32mTokenIdentifier = tokenIdentifiers[0];
-    } else {
-      await this.validateTokenIssuer(bech32mTokenIdentifier);
-    }
-    const decodedOwnerPubkey = decodeSparkAddress(
-      sparkAddress,
-      this.config.getNetworkType()
-    );
-    const rawTokenIdentifier = decodeBech32mTokenIdentifier(
-      bech32mTokenIdentifier,
-      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,
-      impactedTokenAmount: tokenAmount
-    };
-  }
-  /**
-   * 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");
-  }
-  /**
-   * This validates that the token belongs to this issuer.
-   * If a token is in the cache, it must belong to this issuer.
-   * @param tokenIdentifier - The bech32m encoded token identifier
-   * @throws {SparkValidationError} If the token is not found for this issuer
-   * @private
-   */
-  async validateTokenIssuer(tokenIdentifier) {
-    const issuerPublicKey = await super.getIdentityPublicKey();
-    const cachedMetadata = this.tokenMetadata.get(tokenIdentifier);
-    if (cachedMetadata) {
-      if (bytesToHex(cachedMetadata.issuerPublicKey) !== issuerPublicKey) {
-        throw new SparkValidationError3("Token was not issued by this issuer", {
-          field: "issuerPublicKey",
-          tokenIdentifier,
-          expected: issuerPublicKey,
-          actual: bytesToHex(cachedMetadata.issuerPublicKey)
-        });
-      }
-    } else {
-      const tokensMetadata = await this.getIssuerTokensMetadata([
-        tokenIdentifier
-      ]);
-      if (tokensMetadata.length === 0) {
-        throw new SparkValidationError3("Token not found for this issuer", {
-          field: "tokenIdentifier",
-          value: tokenIdentifier
-        });
-      }
-      if (tokensMetadata[0].tokenPublicKey !== issuerPublicKey) {
-        throw new SparkValidationError3("Token was not issued by this issuer", {
-          field: "issuerPublicKey",
-          tokenIdentifier,
-          expected: issuerPublicKey,
-          actual: tokensMetadata[0].tokenPublicKey
-        });
-      }
-    }
-  }
-  getTraceName(methodName) {
-    return `IssuerSparkWallet.${methodName}`;
-  }
-  wrapIssuerPublicMethod(methodName) {
-    const original = this[methodName];
-    if (typeof original !== "function") {
-      throw new Error(
-        `Method ${methodName} is not a function on IssuerSparkWallet.`
-      );
-    }
-    const originalFn = original;
-    const wrapped = SparkWallet.wrapMethod(
-      String(methodName),
-      originalFn,
-      this
-    );
-    this[methodName] = wrapped;
-  }
-  wrapIssuerSparkWalletMethods() {
-    PUBLIC_ISSUER_SPARK_WALLET_METHODS.forEach(
-      (m) => this.wrapIssuerPublicMethod(m)
-    );
-  }
+	/**
+	* Initializes a new IssuerSparkWallet instance.
+	* Inherits the generic static initialize from the base class.
+	*/
+	constructor(configOptions, signer) {
+		super(configOptions, signer);
+		_defineProperty(this, "issuerTokenTransactionService", void 0);
+		_defineProperty(this, "tokenFreezeService", void 0);
+		_defineProperty(this, "tracerId", "issuer-sdk");
+		this.issuerTokenTransactionService = new IssuerTokenTransactionService(this.config, this.connectionManager);
+		this.tokenFreezeService = new TokenFreezeService(this.config, this.connectionManager);
+		this.wrapIssuerSparkWalletMethods();
+	}
+	/**
+	* Gets the token balance for the issuer's token.
+	* @deprecated Use getIssuerTokenBalances() instead. This method will be removed in a future version.
+	* @returns An object containing the token balance as a bigint
+	*
+	* @throws {SparkValidationError} If multiple tokens are found for this issuer
+	*/
+	async getIssuerTokenBalance() {
+		const publicKey = await super.getIdentityPublicKey();
+		const issuerBalance = [...(await this.getBalance()).tokenBalances.entries()].filter(([, info]) => info.tokenMetadata.tokenPublicKey === publicKey);
+		if (issuerBalance.length > 1) throw new SparkValidationError("Multiple tokens found for this issuer. Use getIssuerTokenBalances() instead.", {
+			field: "issuerTokenBalance",
+			expected: "single token",
+			actual: `${issuerBalance.length} tokens`
+		});
+		if (issuerBalance.length === 0) return {
+			tokenIdentifier: void 0,
+			balance: 0n
+		};
+		return {
+			tokenIdentifier: issuerBalance[0][0],
+			balance: issuerBalance[0][1].balance
+		};
+	}
+	/**
+	* Gets the token balances for the tokens that were issued by this user.
+	* @returns An array of objects containing the token identifier and balance
+	*/
+	async getIssuerTokenBalances() {
+		const publicKey = await super.getIdentityPublicKey();
+		const issuerBalance = [...(await this.getBalance()).tokenBalances.entries()].filter(([, info]) => info.tokenMetadata.tokenPublicKey === publicKey);
+		if (issuerBalance.length === 0) return [{
+			tokenIdentifier: void 0,
+			balance: 0n
+		}];
+		return issuerBalance.map(([tokenIdentifier, { balance }]) => ({
+			tokenIdentifier,
+			balance
+		}));
+	}
+	/**
+	* Retrieves information about the issuer's token.
+	* @deprecated Use getIssuerTokensMetadata() instead. This method will be removed in a future version.
+	* @returns An object containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
+	* @throws {SparkRequestError} If the token metadata cannot be retrieved
+	* @throws {SparkValidationError} If multiple tokens are found for this issuer
+	*/
+	async getIssuerTokenMetadata() {
+		const tokensMetadata = await this.getIssuerTokensMetadata();
+		if (tokensMetadata.length === 0) throw new SparkValidationError("No tokens found. Create a token first.");
+		if (tokensMetadata.length > 1) throw new SparkValidationError("Multiple tokens found for this issuer. Please migrate to getIssuerTokensMetadata() instead.", {
+			field: "tokenMetadata",
+			value: tokensMetadata
+		});
+		return tokensMetadata[0];
+	}
+	/**
+	* Retrieves information about the tokens that were issued by this user.
+	* @param tokenIdentifiers - Optional array of specific token identifiers to fetch.
+	*                           If omitted, all tokens for this issuer are fetched.
+	* @returns An array of objects containing token information including public key, name, symbol, decimals, max supply, freeze status, and extra metadata
+	* @throws {SparkRequestError} If the token metadata cannot be retrieved
+	*/
+	async getIssuerTokensMetadata(tokenIdentifiers) {
+		const issuerPublicKey = await super.getIdentityPublicKey();
+		const sparkTokenClient = await this.connectionManager.createSparkTokenClient(this.config.getCoordinatorAddress());
+		const filterByIdentifiers = Array.isArray(tokenIdentifiers) && tokenIdentifiers.length > 0;
+		const tokenIdentifierSet = filterByIdentifiers ? new Set(tokenIdentifiers) : void 0;
+		const request = {};
+		if (filterByIdentifiers) request.tokenIdentifiers = tokenIdentifiers.map((id) => decodeBech32mTokenIdentifier(id, this.config.getNetworkType()).tokenIdentifier);
+		else request.issuerPublicKeys = Array.of(hexToBytes(issuerPublicKey));
+		try {
+			const response = await sparkTokenClient.query_token_metadata(request);
+			const tokenMetadata = [];
+			for (const metadata of response.tokenMetadata) {
+				const bech32mTokenIdentifier = encodeBech32mTokenIdentifier({
+					tokenIdentifier: metadata.tokenIdentifier,
+					network: this.config.getNetworkType()
+				});
+				if (bytesToHex(metadata.issuerPublicKey) !== issuerPublicKey) continue;
+				if (filterByIdentifiers && !tokenIdentifierSet.has(bech32mTokenIdentifier)) continue;
+				this.tokenMetadata.set(bech32mTokenIdentifier, metadata);
+				tokenMetadata.push({
+					tokenPublicKey: bytesToHex(metadata.issuerPublicKey),
+					rawTokenIdentifier: metadata.tokenIdentifier,
+					tokenName: metadata.tokenName,
+					tokenTicker: metadata.tokenTicker,
+					decimals: metadata.decimals,
+					maxSupply: bytesToNumberBE(metadata.maxSupply),
+					isFreezable: metadata.isFreezable,
+					extraMetadata: metadata.extraMetadata ? new Uint8Array(metadata.extraMetadata) : void 0,
+					bech32mTokenIdentifier
+				});
+			}
+			return tokenMetadata;
+		} catch (error) {
+			if (error instanceof SparkError) throw error;
+			throw new SparkRequestError("Failed to fetch token metadata", { error });
+		}
+	}
+	/**
+	* Retrieves the bech32m encoded token identifier for the issuer's token.
+	* @deprecated Use getIssuerTokenIdentifiers() instead. This method will be removed in a future version.
+	* @returns The bech32m encoded token identifier for the issuer's token
+	* @throws {SparkRequestError} If the token identifier cannot be retrieved
+	* @throws {SparkValidationError} If multiple tokens are found for this issuer
+	*/
+	async getIssuerTokenIdentifier() {
+		const tokensMetadata = await this.getIssuerTokensMetadata();
+		if (tokensMetadata.length === 0) throw new SparkValidationError("No tokens found. Create a token first.");
+		if (tokensMetadata.length > 1) throw new SparkValidationError("Multiple tokens found. Use getIssuerTokenIdentifiers() instead.", {
+			method: "getIssuerTokenIdentifier",
+			availableTokens: tokensMetadata.map((t) => ({
+				tokenName: t.tokenName,
+				tokenTicker: t.tokenTicker,
+				bech32mTokenIdentifier: encodeBech32mTokenIdentifier({
+					tokenIdentifier: t.rawTokenIdentifier,
+					network: this.config.getNetworkType()
+				})
+			}))
+		});
+		return tokensMetadata[0].bech32mTokenIdentifier;
+	}
+	/**
+	* Retrieves the bech32m encoded token identifier for the issuer's token.
+	* @returns The bech32m encoded token identifier for the issuer's token
+	* @throws {SparkRequestError} If the token identifier cannot be retrieved
+	*/
+	async getIssuerTokenIdentifiers() {
+		return (await this.getIssuerTokensMetadata()).map((metadata) => metadata.bech32mTokenIdentifier);
+	}
+	async createToken({ tokenName, tokenTicker, decimals, isFreezable, maxSupply = 0n, extraMetadata, returnIdentifierForCreate = false }) {
+		validateTokenParameters(tokenName, tokenTicker, decimals, maxSupply, extraMetadata);
+		const issuerPublicKey = await super.getIdentityPublicKey();
+		if (this.config.getTokenTransactionVersion() === "V2") {
+			const tokenTransaction = await this.issuerTokenTransactionService.constructCreateTokenTransaction(hexToBytes(issuerPublicKey), tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata);
+			const { finalTokenTransactionHash, tokenIdentifier } = await this.issuerTokenTransactionService.broadcastTokenTransactionDetailed(tokenTransaction);
+			const txHash = bytesToHex(finalTokenTransactionHash);
+			if (returnIdentifierForCreate) {
+				if (!tokenIdentifier) throw new SparkRequestError("Server response missing expected field: tokenIdentifier", {
+					operation: "broadcast_transaction",
+					field: "tokenIdentifier"
+				});
+				return {
+					tokenIdentifier: encodeBech32mTokenIdentifier({
+						tokenIdentifier,
+						network: this.config.getNetworkType()
+					}),
+					transactionHash: txHash
+				};
+			}
+			return txHash;
+		} else {
+			const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialCreateTokenTransaction(hexToBytes(issuerPublicKey), tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata);
+			const broadcastResponse = await this.issuerTokenTransactionService.broadcastTokenTransactionV3Detailed(partialTokenTransaction);
+			const finalTransactionHash = bytesToHex(await hashFinalTokenTransaction(broadcastResponse.finalTokenTransaction));
+			if (returnIdentifierForCreate) {
+				if (!broadcastResponse.tokenIdentifier) throw new SparkRequestError("Server response missing expected field: tokenIdentifier", {
+					operation: "broadcast_transaction",
+					field: "tokenIdentifier"
+				});
+				return {
+					tokenIdentifier: encodeBech32mTokenIdentifier({
+						tokenIdentifier: broadcastResponse.tokenIdentifier,
+						network: this.config.getNetworkType()
+					}),
+					transactionHash: finalTransactionHash
+				};
+			}
+			return finalTransactionHash;
+		}
+	}
+	async mintTokens(tokenAmountOrParams) {
+		let tokenAmount;
+		let bech32mTokenIdentifier;
+		if (typeof tokenAmountOrParams === "bigint") {
+			tokenAmount = tokenAmountOrParams;
+			bech32mTokenIdentifier = void 0;
+		} else {
+			tokenAmount = tokenAmountOrParams.tokenAmount;
+			bech32mTokenIdentifier = tokenAmountOrParams.tokenIdentifier;
+		}
+		const issuerTokenPublicKeyBytes = hexToBytes(await super.getIdentityPublicKey());
+		if (bech32mTokenIdentifier === void 0) {
+			const tokensMetadata = await this.getIssuerTokensMetadata();
+			if (tokensMetadata.length === 0) throw new SparkValidationError("No tokens found. Create a token first.");
+			if (tokensMetadata.length > 1) throw new SparkValidationError("Multiple tokens found. Please use mintTokens({ tokenAmount, tokenIdentifier }) instead.", {
+				field: "tokenIdentifier",
+				availableTokens: tokensMetadata.map((t) => ({
+					tokenName: t.tokenName,
+					tokenTicker: t.tokenTicker,
+					bech32mTokenIdentifier: t.bech32mTokenIdentifier
+				}))
+			});
+			bech32mTokenIdentifier = tokensMetadata[0].bech32mTokenIdentifier;
+		} else await this.validateTokenIssuer(bech32mTokenIdentifier);
+		const rawTokenIdentifier = decodeBech32mTokenIdentifier(bech32mTokenIdentifier, this.config.getNetworkType()).tokenIdentifier;
+		if (this.config.getTokenTransactionVersion() === "V2") {
+			const tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(rawTokenIdentifier, issuerTokenPublicKeyBytes, tokenAmount);
+			return await this.issuerTokenTransactionService.broadcastTokenTransaction(tokenTransaction);
+		} else {
+			const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialMintTokenTransaction(rawTokenIdentifier, issuerTokenPublicKeyBytes, tokenAmount);
+			return await this.issuerTokenTransactionService.broadcastTokenTransactionV3(partialTokenTransaction);
+		}
+	}
+	async burnTokens(tokenAmountOrParams, selectedOutputs) {
+		let burnTokenIdentifier;
+		let tokenAmount;
+		let outputs;
+		if (typeof tokenAmountOrParams === "bigint") {
+			tokenAmount = tokenAmountOrParams;
+			outputs = selectedOutputs;
+			const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+			if (tokenIdentifiers.length === 0) throw new SparkValidationError("No tokens found. Create a token first.");
+			if (tokenIdentifiers.length > 1) throw new SparkValidationError("Multiple tokens found. Use burnTokens({ tokenIdentifier, tokenAmount, selectedOutputs }) to specify which token to burn.", {
+				field: "tokenIdentifier",
+				availableTokens: tokenIdentifiers
+			});
+			burnTokenIdentifier = tokenIdentifiers[0];
+		} else {
+			tokenAmount = tokenAmountOrParams.tokenAmount;
+			outputs = tokenAmountOrParams.selectedOutputs;
+			await this.validateTokenIssuer(tokenAmountOrParams.tokenIdentifier);
+			burnTokenIdentifier = tokenAmountOrParams.tokenIdentifier;
+		}
+		const burnAddress = encodeSparkAddress({
+			identityPublicKey: BURN_ADDRESS,
+			network: this.config.getNetworkType()
+		});
+		return await this.transferTokens({
+			tokenIdentifier: burnTokenIdentifier,
+			tokenAmount,
+			receiverSparkAddress: burnAddress,
+			selectedOutputs: outputs
+		});
+	}
+	async freezeTokens(sparkAddressOrParams) {
+		let bech32mTokenIdentifier;
+		let sparkAddress;
+		if (typeof sparkAddressOrParams === "string") {
+			sparkAddress = sparkAddressOrParams;
+			bech32mTokenIdentifier = void 0;
+		} else {
+			sparkAddress = sparkAddressOrParams.sparkAddress;
+			bech32mTokenIdentifier = sparkAddressOrParams.tokenIdentifier;
+		}
+		const decodedOwnerPubkey = decodeSparkAddress(sparkAddress, this.config.getNetworkType());
+		if (bech32mTokenIdentifier === void 0) {
+			const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+			if (tokenIdentifiers.length === 0) throw new SparkValidationError("No tokens found. Create a token first.");
+			if (tokenIdentifiers.length > 1) throw new SparkValidationError("Multiple tokens found. Use freezeTokens({ tokenIdentifier, sparkAddress }) instead.", {
+				field: "tokenIdentifier",
+				availableTokens: tokenIdentifiers
+			});
+			bech32mTokenIdentifier = tokenIdentifiers[0];
+		} else await this.validateTokenIssuer(bech32mTokenIdentifier);
+		const rawTokenIdentifier = decodeBech32mTokenIdentifier(bech32mTokenIdentifier, this.config.getNetworkType()).tokenIdentifier;
+		const response = await this.tokenFreezeService.freezeTokens({
+			ownerPublicKey: hexToBytes(decodedOwnerPubkey.identityPublicKey),
+			tokenIdentifier: rawTokenIdentifier
+		});
+		const tokenAmount = bytesToNumberBE(response.impactedTokenAmount);
+		return {
+			impactedOutputIds: response.impactedOutputIds,
+			impactedTokenAmount: tokenAmount
+		};
+	}
+	async unfreezeTokens(sparkAddressOrParams) {
+		let bech32mTokenIdentifier;
+		let sparkAddress;
+		if (typeof sparkAddressOrParams === "string") {
+			sparkAddress = sparkAddressOrParams;
+			bech32mTokenIdentifier = void 0;
+		} else {
+			sparkAddress = sparkAddressOrParams.sparkAddress;
+			bech32mTokenIdentifier = sparkAddressOrParams.tokenIdentifier;
+		}
+		if (bech32mTokenIdentifier === void 0) {
+			const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+			if (tokenIdentifiers.length === 0) throw new SparkValidationError("No tokens found. Create a token first.");
+			if (tokenIdentifiers.length > 1) throw new SparkValidationError("Multiple tokens found. Use unfreezeTokens({ tokenIdentifier, sparkAddress }) instead.", {
+				field: "tokenIdentifier",
+				availableTokens: tokenIdentifiers
+			});
+			bech32mTokenIdentifier = tokenIdentifiers[0];
+		} else await this.validateTokenIssuer(bech32mTokenIdentifier);
+		const decodedOwnerPubkey = decodeSparkAddress(sparkAddress, this.config.getNetworkType());
+		const rawTokenIdentifier = decodeBech32mTokenIdentifier(bech32mTokenIdentifier, this.config.getNetworkType()).tokenIdentifier;
+		const response = await this.tokenFreezeService.unfreezeTokens({
+			ownerPublicKey: hexToBytes(decodedOwnerPubkey.identityPublicKey),
+			tokenIdentifier: rawTokenIdentifier
+		});
+		const tokenAmount = bytesToNumberBE(response.impactedTokenAmount);
+		return {
+			impactedOutputIds: response.impactedOutputIds,
+			impactedTokenAmount: tokenAmount
+		};
+	}
+	/**
+	* 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");
+	}
+	/**
+	* This validates that the token belongs to this issuer.
+	* If a token is in the cache, it must belong to this issuer.
+	* @param tokenIdentifier - The bech32m encoded token identifier
+	* @throws {SparkValidationError} If the token is not found for this issuer
+	* @private
+	*/
+	async validateTokenIssuer(tokenIdentifier) {
+		const issuerPublicKey = await super.getIdentityPublicKey();
+		const cachedMetadata = this.tokenMetadata.get(tokenIdentifier);
+		if (cachedMetadata) {
+			if (bytesToHex(cachedMetadata.issuerPublicKey) !== issuerPublicKey) throw new SparkValidationError("Token was not issued by this issuer", {
+				field: "issuerPublicKey",
+				tokenIdentifier,
+				expected: issuerPublicKey,
+				actual: bytesToHex(cachedMetadata.issuerPublicKey)
+			});
+		} else {
+			const tokensMetadata = await this.getIssuerTokensMetadata([tokenIdentifier]);
+			if (tokensMetadata.length === 0) throw new SparkValidationError("Token not found for this issuer", {
+				field: "tokenIdentifier",
+				value: tokenIdentifier
+			});
+			if (tokensMetadata[0].tokenPublicKey !== issuerPublicKey) throw new SparkValidationError("Token was not issued by this issuer", {
+				field: "issuerPublicKey",
+				tokenIdentifier,
+				expected: issuerPublicKey,
+				actual: tokensMetadata[0].tokenPublicKey
+			});
+		}
+	}
+	getTraceName(methodName) {
+		return `IssuerSparkWallet.${methodName}`;
+	}
+	wrapIssuerPublicMethod(methodName) {
+		const original = this[methodName];
+		if (typeof original !== "function") throw new Error(`Method ${methodName} is not a function on IssuerSparkWallet.`);
+		const originalFn = original;
+		this[methodName] = SparkWallet.wrapMethod(String(methodName), originalFn, this);
+	}
+	wrapIssuerSparkWalletMethods() {
+		PUBLIC_ISSUER_SPARK_WALLET_METHODS.forEach((m) => this.wrapIssuerPublicMethod(m));
+	}
 };
-var PUBLIC_ISSUER_SPARK_WALLET_METHODS = [
-  "getIssuerTokenBalance",
-  "getIssuerTokenBalances",
-  "getIssuerTokenMetadata",
-  "getIssuerTokensMetadata",
-  "getIssuerTokenIdentifier",
-  "getIssuerTokenIdentifiers",
-  "createToken",
-  "mintTokens",
-  "burnTokens",
-  "freezeTokens",
-  "unfreezeTokens",
-  "getIssuerTokenDistribution"
+const PUBLIC_ISSUER_SPARK_WALLET_METHODS = [
+	"getIssuerTokenBalance",
+	"getIssuerTokenBalances",
+	"getIssuerTokenMetadata",
+	"getIssuerTokensMetadata",
+	"getIssuerTokenIdentifier",
+	"getIssuerTokenIdentifiers",
+	"createToken",
+	"mintTokens",
+	"burnTokens",
+	"freezeTokens",
+	"unfreezeTokens",
+	"getIssuerTokenDistribution"
 ];
 
-// src/issuer-wallet/issuer-spark-wallet.react-native.ts
-var IssuerSparkWalletReactNative = class extends IssuerSparkWallet {
-};
+//#endregion
+//#region src/issuer-wallet/issuer-spark-wallet.react-native.ts
+var IssuerSparkWalletReactNative = class extends IssuerSparkWallet {};
 
-// src/index-shared.ts
-import {
-  DefaultSparkSigner,
-  UnsafeStatelessSparkSigner
-} from "@buildonspark/spark-sdk";
-import { WalletConfig } from "@buildonspark/spark-sdk";
-export {
-  DefaultSparkSigner,
-  IssuerSparkWalletReactNative as IssuerSparkWallet,
-  UnsafeStatelessSparkSigner,
-  WalletConfig
-};
+//#endregion
+export { DefaultSparkSigner, IssuerSparkWalletReactNative as IssuerSparkWallet, UnsafeStatelessSparkSigner, WalletConfig };