@buildonspark/issuer-sdk 0.1.6 → 0.1.7

package/dist/index.node.cjs

@@ -1,956 +1,675 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.node.ts
-var index_node_exports = {};
-__export(index_node_exports, {
-  DefaultSparkSigner: () => import_spark_sdk8.DefaultSparkSigner,
-  IssuerSparkWallet: () => IssuerSparkWalletNodeJS,
-  UnsafeStatelessSparkSigner: () => import_spark_sdk8.UnsafeStatelessSparkSigner,
-  WalletConfig: () => import_spark_sdk9.WalletConfig
-});
-module.exports = __toCommonJS(index_node_exports);
+let _buildonspark_spark_sdk = require("@buildonspark/spark-sdk");
+let _noble_curves_utils = require("@noble/curves/utils");
+let _scure_btc_signer_utils = require("@scure/btc-signer/utils");
 
-// buffer.js
-var import_buffer = require("buffer");
-if (typeof globalThis.Buffer === "undefined") {
-  globalThis.Buffer = import_buffer.Buffer;
-}
-if (typeof window !== "undefined") {
-  if (typeof window.global === "undefined") {
-    window.global = window;
-  }
-  if (typeof window.globalThis === "undefined") {
-    window.globalThis = window;
-  }
-}
-
-// src/issuer-wallet/issuer-spark-wallet.ts
-var import_spark_sdk5 = require("@buildonspark/spark-sdk");
-var import_utils4 = require("@noble/curves/utils");
-
-// src/services/freeze.ts
-var import_spark_sdk2 = require("@buildonspark/spark-sdk");
-var import_utils2 = require("@noble/curves/utils");
-
-// src/utils/token-hashing.ts
-var import_utils = require("@scure/btc-signer/utils");
-var import_spark_sdk = require("@buildonspark/spark-sdk");
+//#region src/utils/token-hashing.ts
 function hashFreezeTokensPayload(payload) {
-  if (!payload) {
-    throw new import_spark_sdk.SparkValidationError("Freeze tokens payload cannot be nil", {
-      field: "payload",
-      value: payload,
-      expected: "valid freeze tokens 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 tokenIdentifierHash = import_utils.sha256.create();
-  if (payload.tokenIdentifier) {
-    tokenIdentifierHash.update(payload.tokenIdentifier);
-  }
-  allHashes.push(tokenIdentifierHash.digest());
-  const shouldUnfreezeHash = import_utils.sha256.create();
-  shouldUnfreezeHash.update(new Uint8Array([payload.shouldUnfreeze ? 1 : 0]));
-  allHashes.push(shouldUnfreezeHash.digest());
-  const timestampHash = import_utils.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 = import_utils.sha256.create();
-  if (payload.operatorIdentityPublicKey) {
-    operatorPubKeyHash.update(payload.operatorIdentityPublicKey);
-  }
-  allHashes.push(operatorPubKeyHash.digest());
-  const finalHash = import_utils.sha256.create();
-  for (const hash of allHashes) {
-    finalHash.update(hash);
-  }
-  return finalHash.digest();
+	if (!payload) throw new _buildonspark_spark_sdk.SparkValidationError("Freeze tokens payload cannot be nil", {
+		field: "payload",
+		value: payload,
+		expected: "valid freeze tokens payload"
+	});
+	let allHashes = [];
+	const versionHashObj = _scure_btc_signer_utils.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 = _scure_btc_signer_utils.sha256.create();
+	if (payload.ownerPublicKey) ownerPubKeyHash.update(payload.ownerPublicKey);
+	allHashes.push(ownerPubKeyHash.digest());
+	const tokenIdentifierHash = _scure_btc_signer_utils.sha256.create();
+	if (payload.tokenIdentifier) tokenIdentifierHash.update(payload.tokenIdentifier);
+	allHashes.push(tokenIdentifierHash.digest());
+	const shouldUnfreezeHash = _scure_btc_signer_utils.sha256.create();
+	shouldUnfreezeHash.update(new Uint8Array([payload.shouldUnfreeze ? 1 : 0]));
+	allHashes.push(shouldUnfreezeHash.digest());
+	const timestampHash = _scure_btc_signer_utils.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 = _scure_btc_signer_utils.sha256.create();
+	if (payload.operatorIdentityPublicKey) operatorPubKeyHash.update(payload.operatorIdentityPublicKey);
+	allHashes.push(operatorPubKeyHash.digest());
+	const finalHash = _scure_btc_signer_utils.sha256.create();
+	for (const hash of allHashes) finalHash.update(hash);
+	return finalHash.digest();
 }
 
-// src/services/freeze.ts
+//#endregion
+//#region src/services/freeze.ts
 var TokenFreezeService = class {
-  config;
-  connectionManager;
-  constructor(config, 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: (0, import_utils2.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 import_spark_sdk2.SparkRequestError(
-            `Failed to send a freeze/unfreeze operation to operator: ${operator.address}`,
-            { operation: "freeze_tokens", error }
-          );
-        }
-      })
-    );
-    const successfulResponses = (0, import_spark_sdk2.collectResponses)(freezeResponses);
-    return successfulResponses[0].response;
-  }
+	config;
+	connectionManager;
+	constructor(config, 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();
+		return (0, _buildonspark_spark_sdk.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: (0, _noble_curves_utils.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 _buildonspark_spark_sdk.SparkRequestError(`Failed to send a freeze/unfreeze operation to operator: ${operator.address}`, {
+					operation: "freeze_tokens",
+					error
+				});
+			}
+		})))[0].response;
+	}
 };
 
-// src/services/token-transactions.ts
-var import_spark_sdk3 = require("@buildonspark/spark-sdk");
-var import_utils3 = require("@noble/curves/utils");
-var IssuerTokenTransactionService = class extends import_spark_sdk3.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: (0, import_utils3.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: (0, import_utils3.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: (0, import_utils3.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: (0, import_utils3.numberToBytesBE)(maxSupply, 16),
-          isFreezable,
-          extraMetadata
-        }
-      },
-      partialTokenOutputs: []
-    };
-  }
+//#endregion
+//#region src/services/token-transactions.ts
+var IssuerTokenTransactionService = class extends _buildonspark_spark_sdk.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: (0, _noble_curves_utils.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: (0, _noble_curves_utils.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: (0, _noble_curves_utils.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: (0, _noble_curves_utils.numberToBytesBE)(maxSupply, 16),
+					isFreezable,
+					extraMetadata
+				}
+			},
+			partialTokenOutputs: []
+		};
+	}
 };
 
-// src/issuer-wallet/issuer-spark-wallet.ts
-var import_spark_sdk6 = require("@buildonspark/spark-sdk");
-
-// src/utils/create-validation.ts
-var import_spark_sdk4 = require("@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 import_spark_sdk4.SparkValidationError("Token name must be NFC-normalised UTF-8", {
-      field: "tokenName",
-      value: tokenName,
-      expected: "NFC normalised string"
-    });
-  }
-  if (!isNfcNormalized(tokenTicker)) {
-    throw new import_spark_sdk4.SparkValidationError(
-      "Token ticker must be NFC-normalised UTF-8",
-      {
-        field: "tokenTicker",
-        value: tokenTicker,
-        expected: "NFC normalised string"
-      }
-    );
-  }
-  const nameBytes = import_buffer.Buffer.from(tokenName, "utf-8").length;
-  if (nameBytes < MIN_NAME_SIZE || nameBytes > MAX_NAME_SIZE) {
-    throw new import_spark_sdk4.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 = import_buffer.Buffer.from(tokenTicker, "utf-8").length;
-  if (tickerBytes < MIN_SYMBOL_SIZE || tickerBytes > MAX_SYMBOL_SIZE) {
-    throw new import_spark_sdk4.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 import_spark_sdk4.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 import_spark_sdk4.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 import_spark_sdk4.SparkValidationError(
-      `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 _buildonspark_spark_sdk.SparkValidationError("Token name must be NFC-normalised UTF-8", {
+		field: "tokenName",
+		value: tokenName,
+		expected: "NFC normalised string"
+	});
+	if (!isNfcNormalized(tokenTicker)) throw new _buildonspark_spark_sdk.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 _buildonspark_spark_sdk.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 _buildonspark_spark_sdk.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 _buildonspark_spark_sdk.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 _buildonspark_spark_sdk.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 _buildonspark_spark_sdk.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);
-var IssuerSparkWallet = class extends import_spark_sdk5.SparkWallet {
-  issuerTokenTransactionService;
-  tokenFreezeService;
-  tracerId = "issuer-sdk";
-  /**
-   * Initializes a new IssuerSparkWallet instance.
-   * Inherits the generic static initialize from the base class.
-   */
-  constructor(configOptions, signer) {
-    super(configOptions, signer);
-    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 import_spark_sdk5.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 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 import_spark_sdk5.SparkValidationError("No tokens found. Create a token first.");
-    }
-    if (tokensMetadata.length > 1) {
-      throw new import_spark_sdk5.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) => (0, import_spark_sdk5.decodeBech32mTokenIdentifier)(id, this.config.getNetworkType()).tokenIdentifier
-      );
-    } else {
-      request.issuerPublicKeys = Array.of((0, import_utils4.hexToBytes)(issuerPublicKey));
-    }
-    try {
-      const response = await sparkTokenClient.query_token_metadata(request);
-      const tokenMetadata = [];
-      for (const metadata of response.tokenMetadata) {
-        const bech32mTokenIdentifier = (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
-          tokenIdentifier: metadata.tokenIdentifier,
-          network: this.config.getNetworkType()
-        });
-        if ((0, import_utils4.bytesToHex)(metadata.issuerPublicKey) !== issuerPublicKey) {
-          continue;
-        }
-        if (filterByIdentifiers && !tokenIdentifierSet.has(bech32mTokenIdentifier)) {
-          continue;
-        }
-        this.tokenMetadata.set(bech32mTokenIdentifier, metadata);
-        tokenMetadata.push({
-          tokenPublicKey: (0, import_utils4.bytesToHex)(metadata.issuerPublicKey),
-          rawTokenIdentifier: metadata.tokenIdentifier,
-          tokenName: metadata.tokenName,
-          tokenTicker: metadata.tokenTicker,
-          decimals: metadata.decimals,
-          maxSupply: (0, import_utils4.bytesToNumberBE)(metadata.maxSupply),
-          isFreezable: metadata.isFreezable,
-          extraMetadata: metadata.extraMetadata ? new Uint8Array(metadata.extraMetadata) : void 0,
-          bech32mTokenIdentifier
-        });
-      }
-      return tokenMetadata;
-    } catch (error) {
-      if (error instanceof import_spark_sdk5.SparkError) {
-        throw error;
-      }
-      throw new import_spark_sdk5.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 import_spark_sdk5.SparkValidationError("No tokens found. Create a token first.");
-    }
-    if (tokensMetadata.length > 1) {
-      throw new import_spark_sdk5.SparkValidationError(
-        "Multiple tokens found. Use getIssuerTokenIdentifiers() instead.",
-        {
-          method: "getIssuerTokenIdentifier",
-          availableTokens: tokensMetadata.map((t) => ({
-            tokenName: t.tokenName,
-            tokenTicker: t.tokenTicker,
-            bech32mTokenIdentifier: (0, import_spark_sdk5.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(
-        (0, import_utils4.hexToBytes)(issuerPublicKey),
-        tokenName,
-        tokenTicker,
-        decimals,
-        maxSupply,
-        isFreezable,
-        extraMetadata
-      );
-      const { finalTokenTransactionHash, tokenIdentifier } = await this.issuerTokenTransactionService.broadcastTokenTransactionDetailed(
-        tokenTransaction
-      );
-      const txHash = (0, import_utils4.bytesToHex)(finalTokenTransactionHash);
-      if (returnIdentifierForCreate) {
-        if (!tokenIdentifier) {
-          throw new import_spark_sdk5.SparkRequestError(
-            "Server response missing expected field: tokenIdentifier",
-            {
-              operation: "broadcast_transaction",
-              field: "tokenIdentifier"
-            }
-          );
-        }
-        const bech32mTokenIdentifier = (0, import_spark_sdk5.encodeBech32mTokenIdentifier)({
-          tokenIdentifier,
-          network: this.config.getNetworkType()
-        });
-        return {
-          tokenIdentifier: bech32mTokenIdentifier,
-          transactionHash: txHash
-        };
-      }
-      return txHash;
-    } else {
-      const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialCreateTokenTransaction(
-        (0, import_utils4.hexToBytes)(issuerPublicKey),
-        tokenName,
-        tokenTicker,
-        decimals,
-        maxSupply,
-        isFreezable,
-        extraMetadata
-      );
-      const broadcastResponse = await this.issuerTokenTransactionService.broadcastTokenTransactionV3Detailed(
-        partialTokenTransaction
-      );
-      const finalHash = await (0, import_spark_sdk6.hashFinalTokenTransaction)(
-        broadcastResponse.finalTokenTransaction
-      );
-      const finalTransactionHash = (0, import_utils4.bytesToHex)(finalHash);
-      if (returnIdentifierForCreate) {
-        if (!broadcastResponse.tokenIdentifier) {
-          throw new import_spark_sdk5.SparkRequestError(
-            "Server response missing expected field: tokenIdentifier",
-            {
-              operation: "broadcast_transaction",
-              field: "tokenIdentifier"
-            }
-          );
-        }
-        const tokenIdentifier = (0, import_spark_sdk5.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 = (0, import_utils4.hexToBytes)(issuerTokenPublicKey);
-    if (bech32mTokenIdentifier === void 0) {
-      const tokensMetadata = await this.getIssuerTokensMetadata();
-      if (tokensMetadata.length === 0) {
-        throw new import_spark_sdk5.SparkValidationError(
-          "No tokens found. Create a token first."
-        );
-      }
-      if (tokensMetadata.length > 1) {
-        throw new import_spark_sdk5.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 = (0, import_spark_sdk5.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 import_spark_sdk5.SparkValidationError(
-          "No tokens found. Create a token first."
-        );
-      }
-      if (tokenIdentifiers.length > 1) {
-        throw new import_spark_sdk5.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 = (0, import_spark_sdk5.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 = (0, import_spark_sdk5.decodeSparkAddress)(
-      sparkAddress,
-      this.config.getNetworkType()
-    );
-    if (bech32mTokenIdentifier === void 0) {
-      const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
-      if (tokenIdentifiers.length === 0) {
-        throw new import_spark_sdk5.SparkValidationError(
-          "No tokens found. Create a token first."
-        );
-      }
-      if (tokenIdentifiers.length > 1) {
-        throw new import_spark_sdk5.SparkValidationError(
-          "Multiple tokens found. Use freezeTokens({ tokenIdentifier, sparkAddress }) instead.",
-          {
-            field: "tokenIdentifier",
-            availableTokens: tokenIdentifiers
-          }
-        );
-      }
-      bech32mTokenIdentifier = tokenIdentifiers[0];
-    } else {
-      await this.validateTokenIssuer(bech32mTokenIdentifier);
-    }
-    const rawTokenIdentifier = (0, import_spark_sdk5.decodeBech32mTokenIdentifier)(
-      bech32mTokenIdentifier,
-      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,
-      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 import_spark_sdk5.SparkValidationError(
-          "No tokens found. Create a token first."
-        );
-      }
-      if (tokenIdentifiers.length > 1) {
-        throw new import_spark_sdk5.SparkValidationError(
-          "Multiple tokens found. Use unfreezeTokens({ tokenIdentifier, sparkAddress }) instead.",
-          {
-            field: "tokenIdentifier",
-            availableTokens: tokenIdentifiers
-          }
-        );
-      }
-      bech32mTokenIdentifier = tokenIdentifiers[0];
-    } else {
-      await this.validateTokenIssuer(bech32mTokenIdentifier);
-    }
-    const decodedOwnerPubkey = (0, import_spark_sdk5.decodeSparkAddress)(
-      sparkAddress,
-      this.config.getNetworkType()
-    );
-    const rawTokenIdentifier = (0, import_spark_sdk5.decodeBech32mTokenIdentifier)(
-      bech32mTokenIdentifier,
-      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,
-      impactedTokenAmount: tokenAmount
-    };
-  }
-  /**
-   * Retrieves the distribution information for the issuer's token.
-   * @throws {SparkError} This feature is not yet supported
-   */
-  async getIssuerTokenDistribution() {
-    throw new import_spark_sdk5.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 ((0, import_utils4.bytesToHex)(cachedMetadata.issuerPublicKey) !== issuerPublicKey) {
-        throw new import_spark_sdk5.SparkValidationError("Token was not issued by this issuer", {
-          field: "issuerPublicKey",
-          tokenIdentifier,
-          expected: issuerPublicKey,
-          actual: (0, import_utils4.bytesToHex)(cachedMetadata.issuerPublicKey)
-        });
-      }
-    } else {
-      const tokensMetadata = await this.getIssuerTokensMetadata([
-        tokenIdentifier
-      ]);
-      if (tokensMetadata.length === 0) {
-        throw new import_spark_sdk5.SparkValidationError("Token not found for this issuer", {
-          field: "tokenIdentifier",
-          value: tokenIdentifier
-        });
-      }
-      if (tokensMetadata[0].tokenPublicKey !== issuerPublicKey) {
-        throw new import_spark_sdk5.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;
-    const wrapped = import_spark_sdk5.SparkWallet.wrapMethod(
-      String(methodName),
-      originalFn,
-      this
-    );
-    this[methodName] = wrapped;
-  }
-  wrapIssuerSparkWalletMethods() {
-    PUBLIC_ISSUER_SPARK_WALLET_METHODS.forEach(
-      (m) => this.wrapIssuerPublicMethod(m)
-    );
-  }
+//#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 _buildonspark_spark_sdk.SparkWallet {
+	issuerTokenTransactionService;
+	tokenFreezeService;
+	tracerId = "issuer-sdk";
+	/**
+	* Initializes a new IssuerSparkWallet instance.
+	* Inherits the generic static initialize from the base class.
+	*/
+	constructor(configOptions, signer) {
+		super(configOptions, signer);
+		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 _buildonspark_spark_sdk.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 _buildonspark_spark_sdk.SparkValidationError("No tokens found. Create a token first.");
+		if (tokensMetadata.length > 1) throw new _buildonspark_spark_sdk.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) => (0, _buildonspark_spark_sdk.decodeBech32mTokenIdentifier)(id, this.config.getNetworkType()).tokenIdentifier);
+		else request.issuerPublicKeys = Array.of((0, _noble_curves_utils.hexToBytes)(issuerPublicKey));
+		try {
+			const response = await sparkTokenClient.query_token_metadata(request);
+			const tokenMetadata = [];
+			for (const metadata of response.tokenMetadata) {
+				const bech32mTokenIdentifier = (0, _buildonspark_spark_sdk.encodeBech32mTokenIdentifier)({
+					tokenIdentifier: metadata.tokenIdentifier,
+					network: this.config.getNetworkType()
+				});
+				if ((0, _noble_curves_utils.bytesToHex)(metadata.issuerPublicKey) !== issuerPublicKey) continue;
+				if (filterByIdentifiers && !tokenIdentifierSet.has(bech32mTokenIdentifier)) continue;
+				this.tokenMetadata.set(bech32mTokenIdentifier, metadata);
+				tokenMetadata.push({
+					tokenPublicKey: (0, _noble_curves_utils.bytesToHex)(metadata.issuerPublicKey),
+					rawTokenIdentifier: metadata.tokenIdentifier,
+					tokenName: metadata.tokenName,
+					tokenTicker: metadata.tokenTicker,
+					decimals: metadata.decimals,
+					maxSupply: (0, _noble_curves_utils.bytesToNumberBE)(metadata.maxSupply),
+					isFreezable: metadata.isFreezable,
+					extraMetadata: metadata.extraMetadata ? new Uint8Array(metadata.extraMetadata) : void 0,
+					bech32mTokenIdentifier
+				});
+			}
+			return tokenMetadata;
+		} catch (error) {
+			if (error instanceof _buildonspark_spark_sdk.SparkError) throw error;
+			throw new _buildonspark_spark_sdk.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 _buildonspark_spark_sdk.SparkValidationError("No tokens found. Create a token first.");
+		if (tokensMetadata.length > 1) throw new _buildonspark_spark_sdk.SparkValidationError("Multiple tokens found. Use getIssuerTokenIdentifiers() instead.", {
+			method: "getIssuerTokenIdentifier",
+			availableTokens: tokensMetadata.map((t) => ({
+				tokenName: t.tokenName,
+				tokenTicker: t.tokenTicker,
+				bech32mTokenIdentifier: (0, _buildonspark_spark_sdk.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((0, _noble_curves_utils.hexToBytes)(issuerPublicKey), tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata);
+			const { finalTokenTransactionHash, tokenIdentifier } = await this.issuerTokenTransactionService.broadcastTokenTransactionDetailed(tokenTransaction);
+			const txHash = (0, _noble_curves_utils.bytesToHex)(finalTokenTransactionHash);
+			if (returnIdentifierForCreate) {
+				if (!tokenIdentifier) throw new _buildonspark_spark_sdk.SparkRequestError("Server response missing expected field: tokenIdentifier", {
+					operation: "broadcast_transaction",
+					field: "tokenIdentifier"
+				});
+				return {
+					tokenIdentifier: (0, _buildonspark_spark_sdk.encodeBech32mTokenIdentifier)({
+						tokenIdentifier,
+						network: this.config.getNetworkType()
+					}),
+					transactionHash: txHash
+				};
+			}
+			return txHash;
+		} else {
+			const partialTokenTransaction = await this.issuerTokenTransactionService.constructPartialCreateTokenTransaction((0, _noble_curves_utils.hexToBytes)(issuerPublicKey), tokenName, tokenTicker, decimals, maxSupply, isFreezable, extraMetadata);
+			const broadcastResponse = await this.issuerTokenTransactionService.broadcastTokenTransactionV3Detailed(partialTokenTransaction);
+			const finalTransactionHash = (0, _noble_curves_utils.bytesToHex)(await (0, _buildonspark_spark_sdk.hashFinalTokenTransaction)(broadcastResponse.finalTokenTransaction));
+			if (returnIdentifierForCreate) {
+				if (!broadcastResponse.tokenIdentifier) throw new _buildonspark_spark_sdk.SparkRequestError("Server response missing expected field: tokenIdentifier", {
+					operation: "broadcast_transaction",
+					field: "tokenIdentifier"
+				});
+				return {
+					tokenIdentifier: (0, _buildonspark_spark_sdk.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 = (0, _noble_curves_utils.hexToBytes)(await super.getIdentityPublicKey());
+		if (bech32mTokenIdentifier === void 0) {
+			const tokensMetadata = await this.getIssuerTokensMetadata();
+			if (tokensMetadata.length === 0) throw new _buildonspark_spark_sdk.SparkValidationError("No tokens found. Create a token first.");
+			if (tokensMetadata.length > 1) throw new _buildonspark_spark_sdk.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 = (0, _buildonspark_spark_sdk.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 _buildonspark_spark_sdk.SparkValidationError("No tokens found. Create a token first.");
+			if (tokenIdentifiers.length > 1) throw new _buildonspark_spark_sdk.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 = (0, _buildonspark_spark_sdk.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 = (0, _buildonspark_spark_sdk.decodeSparkAddress)(sparkAddress, this.config.getNetworkType());
+		if (bech32mTokenIdentifier === void 0) {
+			const tokenIdentifiers = await this.getIssuerTokenIdentifiers();
+			if (tokenIdentifiers.length === 0) throw new _buildonspark_spark_sdk.SparkValidationError("No tokens found. Create a token first.");
+			if (tokenIdentifiers.length > 1) throw new _buildonspark_spark_sdk.SparkValidationError("Multiple tokens found. Use freezeTokens({ tokenIdentifier, sparkAddress }) instead.", {
+				field: "tokenIdentifier",
+				availableTokens: tokenIdentifiers
+			});
+			bech32mTokenIdentifier = tokenIdentifiers[0];
+		} else await this.validateTokenIssuer(bech32mTokenIdentifier);
+		const rawTokenIdentifier = (0, _buildonspark_spark_sdk.decodeBech32mTokenIdentifier)(bech32mTokenIdentifier, this.config.getNetworkType()).tokenIdentifier;
+		const response = await this.tokenFreezeService.freezeTokens({
+			ownerPublicKey: (0, _noble_curves_utils.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
+			tokenIdentifier: rawTokenIdentifier
+		});
+		const tokenAmount = (0, _noble_curves_utils.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 _buildonspark_spark_sdk.SparkValidationError("No tokens found. Create a token first.");
+			if (tokenIdentifiers.length > 1) throw new _buildonspark_spark_sdk.SparkValidationError("Multiple tokens found. Use unfreezeTokens({ tokenIdentifier, sparkAddress }) instead.", {
+				field: "tokenIdentifier",
+				availableTokens: tokenIdentifiers
+			});
+			bech32mTokenIdentifier = tokenIdentifiers[0];
+		} else await this.validateTokenIssuer(bech32mTokenIdentifier);
+		const decodedOwnerPubkey = (0, _buildonspark_spark_sdk.decodeSparkAddress)(sparkAddress, this.config.getNetworkType());
+		const rawTokenIdentifier = (0, _buildonspark_spark_sdk.decodeBech32mTokenIdentifier)(bech32mTokenIdentifier, this.config.getNetworkType()).tokenIdentifier;
+		const response = await this.tokenFreezeService.unfreezeTokens({
+			ownerPublicKey: (0, _noble_curves_utils.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
+			tokenIdentifier: rawTokenIdentifier
+		});
+		const tokenAmount = (0, _noble_curves_utils.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 _buildonspark_spark_sdk.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 ((0, _noble_curves_utils.bytesToHex)(cachedMetadata.issuerPublicKey) !== issuerPublicKey) throw new _buildonspark_spark_sdk.SparkValidationError("Token was not issued by this issuer", {
+				field: "issuerPublicKey",
+				tokenIdentifier,
+				expected: issuerPublicKey,
+				actual: (0, _noble_curves_utils.bytesToHex)(cachedMetadata.issuerPublicKey)
+			});
+		} else {
+			const tokensMetadata = await this.getIssuerTokensMetadata([tokenIdentifier]);
+			if (tokensMetadata.length === 0) throw new _buildonspark_spark_sdk.SparkValidationError("Token not found for this issuer", {
+				field: "tokenIdentifier",
+				value: tokenIdentifier
+			});
+			if (tokensMetadata[0].tokenPublicKey !== issuerPublicKey) throw new _buildonspark_spark_sdk.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] = _buildonspark_spark_sdk.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.node.ts
-var import_spark_sdk7 = require("@buildonspark/spark-sdk");
+//#endregion
+//#region src/issuer-wallet/issuer-spark-wallet.node.ts
 var IssuerSparkWalletNodeJS = class extends IssuerSparkWallet {
-  buildConnectionManager(config) {
-    return new import_spark_sdk7.ConnectionManager(config);
-  }
-  initializeTracerEnv({
-    spanProcessors,
-    traceUrls
-  }) {
-    (0, import_spark_sdk7.initializeTracerEnv)({ spanProcessors, traceUrls });
-  }
+	buildConnectionManager(config) {
+		return new _buildonspark_spark_sdk.ConnectionManager(config);
+	}
+	initializeTracerEnv({ spanProcessors, traceUrls }) {
+		(0, _buildonspark_spark_sdk.initializeTracerEnv)({
+			spanProcessors,
+			traceUrls
+		});
+	}
 };
 
-// src/index-shared.ts
-var import_spark_sdk8 = require("@buildonspark/spark-sdk");
-var import_spark_sdk9 = require("@buildonspark/spark-sdk");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DefaultSparkSigner,
-  IssuerSparkWallet,
-  UnsafeStatelessSparkSigner,
-  WalletConfig
+//#endregion
+Object.defineProperty(exports, 'DefaultSparkSigner', {
+  enumerable: true,
+  get: function () {
+    return _buildonspark_spark_sdk.DefaultSparkSigner;
+  }
 });
+exports.IssuerSparkWallet = IssuerSparkWalletNodeJS;
+Object.defineProperty(exports, 'UnsafeStatelessSparkSigner', {
+  enumerable: true,
+  get: function () {
+    return _buildonspark_spark_sdk.UnsafeStatelessSparkSigner;
+  }
+});
+Object.defineProperty(exports, 'WalletConfig', {
+  enumerable: true,
+  get: function () {
+    return _buildonspark_spark_sdk.WalletConfig;
+  }
+});