@buildonspark/spark-sdk 0.1.41 → 0.1.43

package/dist/services/index.cjs

@@ -1315,7 +1315,7 @@ init_buffer();
 
 // src/signer/signer.ts
 init_buffer();
-var import_utils4 = require("@noble/curves/abstract/utils");
+var import_utils5 = require("@noble/curves/abstract/utils");
 var import_secp256k15 = require("@noble/curves/secp256k1");
 var import_bip32 = require("@scure/bip32");
 var import_bip39 = require("@scure/bip39");
@@ -1324,14 +1324,27 @@ var ecies = __toESM(require("eciesjs"), 1);
 
 // src/constants.ts
 init_buffer();
+var import_core = require("@lightsparkdev/core");
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
+var packageVersion = true ? "0.1.43" : "unknown";
+var baseEnvStr = "unknown";
+if (import_core.isNode) {
+  baseEnvStr = `node/${process.version}`;
+} else if (isReactNative) {
+  baseEnvStr = "react-native";
+} else {
+  const userAgent = typeof navigator !== "undefined" && navigator.userAgent || "unknown-user-agent";
+  baseEnvStr = `browser/${userAgent}`;
+}
+var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
 
 // src/errors/types.ts
 init_buffer();
 
 // src/errors/base.ts
 init_buffer();
+var import_utils = require("@noble/hashes/utils");
 var SparkSDKError = class extends Error {
   context;
   originalError;
@@ -1363,12 +1376,42 @@ var SparkSDKError = class extends Error {
   }
 };
 function getMessage(message, context = {}, originalError) {
-  const contextStr = Object.entries(context).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+  const contextStr = Object.entries(context).map(([key, value]) => `${key}: ${safeStringify(value)}`).join(", ");
   const originalErrorStr = originalError ? `
 Original Error: ${originalError.message}` : "";
   return `SparkSDKError: ${message}${contextStr ? `
 Context: ${contextStr}` : ""}${originalErrorStr}`;
 }
+function safeStringify(value) {
+  const replacer = (_, v) => {
+    if (typeof v === "bigint") {
+      return v.toString();
+    }
+    if (v instanceof Uint8Array) {
+      return formatUint8Array(v);
+    }
+    return v;
+  };
+  if (typeof value === "bigint") {
+    return `"${value.toString()}"`;
+  }
+  if (value instanceof Uint8Array) {
+    return `"${formatUint8Array(value)}"`;
+  }
+  try {
+    const result = JSON.stringify(value, replacer);
+    return result === void 0 ? String(value) : result;
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+}
+function formatUint8Array(arr) {
+  return `Uint8Array(0x${(0, import_utils.bytesToHex)(arr)})`;
+}
 
 // src/errors/types.ts
 var NetworkError = class extends SparkSDKError {
@@ -1400,7 +1443,7 @@ var ConfigurationError = class extends SparkSDKError {
 // src/utils/adaptor-signature.ts
 init_buffer();
 var import_modular = require("@noble/curves/abstract/modular");
-var import_utils = require("@noble/curves/abstract/utils");
+var import_utils2 = require("@noble/curves/abstract/utils");
 var import_secp256k1 = require("@noble/curves/secp256k1");
 
 // src/errors/index.ts
@@ -1410,10 +1453,10 @@ init_buffer();
 function generateAdaptorFromSignature(signature) {
   const adaptorPrivateKey = import_secp256k1.secp256k1.utils.randomPrivateKey();
   const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils.bytesToNumberBE)(s);
-  const tBigInt = (0, import_utils.bytesToNumberBE)(adaptorPrivateKey);
+  const sBigInt = (0, import_utils2.bytesToNumberBE)(s);
+  const tBigInt = (0, import_utils2.bytesToNumberBE)(adaptorPrivateKey);
   const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k1.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils.numberToBytesBE)(newS, 32)]);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(newS, 32)]);
   return {
     adaptorSignature: newSignature,
     adaptorPrivateKey
@@ -1434,15 +1477,15 @@ function parseSignature(signature) {
   }
   const r = signature.slice(0, 32);
   const s = signature.slice(32, 64);
-  if ((0, import_utils.bytesToNumberBE)(r) >= import_secp256k1.secp256k1.CURVE.Fp.ORDER) {
+  if ((0, import_utils2.bytesToNumberBE)(r) >= import_secp256k1.secp256k1.CURVE.Fp.ORDER) {
     throw new ValidationError("Invalid signature: r >= field prime", {
-      rValue: (0, import_utils.bytesToNumberBE)(r),
+      rValue: (0, import_utils2.bytesToNumberBE)(r),
       fieldPrime: import_secp256k1.secp256k1.CURVE.Fp.ORDER
     });
   }
-  if ((0, import_utils.bytesToNumberBE)(s) >= import_secp256k1.secp256k1.CURVE.n) {
+  if ((0, import_utils2.bytesToNumberBE)(s) >= import_secp256k1.secp256k1.CURVE.n) {
     throw new ValidationError("Invalid signature: s >= group order", {
-      sValue: (0, import_utils.bytesToNumberBE)(s),
+      sValue: (0, import_utils2.bytesToNumberBE)(s),
       groupOrder: import_secp256k1.secp256k1.CURVE.n
     });
   }
@@ -1451,7 +1494,7 @@ function parseSignature(signature) {
 
 // src/utils/keys.ts
 init_buffer();
-var import_utils2 = require("@noble/curves/abstract/utils");
+var import_utils3 = require("@noble/curves/abstract/utils");
 var import_secp256k12 = require("@noble/curves/secp256k1");
 function subtractPrivateKeys(a, b) {
   if (a.length !== 32 || b.length !== 32) {
@@ -1464,12 +1507,12 @@ function subtractPrivateKeys(a, b) {
   const privA = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(a);
   const privB = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(b);
   const sum = (import_secp256k12.secp256k1.CURVE.n - privB + privA) % import_secp256k12.secp256k1.CURVE.n;
-  return (0, import_utils2.numberToBytesBE)(sum, 32);
+  return (0, import_utils3.numberToBytesBE)(sum, 32);
 }
 
 // src/utils/secret-sharing.ts
 init_buffer();
-var import_utils3 = require("@noble/curves/abstract/utils");
+var import_utils4 = require("@noble/curves/abstract/utils");
 var import_secp256k13 = require("@noble/curves/secp256k1");
 
 // src/utils/crypto.ts
@@ -1488,7 +1531,7 @@ function getRandomBigInt(max) {
   const mask = (1n << BigInt(max.toString(2).length)) - 1n;
   while (true) {
     const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
-    const randValue = BigInt("0x" + (0, import_utils3.bytesToHex)(randBytes)) & mask;
+    const randValue = BigInt("0x" + (0, import_utils4.bytesToHex)(randBytes)) & mask;
     if (randValue < maxBigInt) {
       return randValue;
     }
@@ -1666,7 +1709,9 @@ function getSigningCommitmentFromNonce(nonce) {
 var import_secp256k16 = require("@bitcoinerlab/secp256k1");
 var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
 var import_sha2 = require("@noble/hashes/sha2");
-var import_utils5 = require("@scure/btc-signer/utils");
+var import_utils6 = require("@scure/btc-signer/utils");
+var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
+var import_types2 = require("@buildonspark/lrc20-sdk/lrc/types");
 var sparkFrostModule = void 0;
 var getSparkFrostModule = async () => {
   if (isReactNative) {
@@ -1765,28 +1810,28 @@ var DefaultSparkSigner = class {
       const privateKey = this.deriveSigningKey(hash);
       const publicKey = import_secp256k15.secp256k1.getPublicKey(privateKey);
       this.publicKeyToPrivateKeyMap.set(
-        (0, import_utils4.bytesToHex)(publicKey),
-        (0, import_utils4.bytesToHex)(privateKey)
+        (0, import_utils5.bytesToHex)(publicKey),
+        (0, import_utils5.bytesToHex)(privateKey)
       );
     }
   }
   async getSchnorrPublicKey(publicKey) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
+    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils5.bytesToHex)(publicKey));
     if (!privateKey) {
       throw new ValidationError("Private key is not set", {
         field: "privateKey"
       });
     }
-    return import_secp256k15.schnorr.getPublicKey((0, import_utils4.hexToBytes)(privateKey));
+    return import_secp256k15.schnorr.getPublicKey((0, import_utils5.hexToBytes)(privateKey));
   }
   async signSchnorr(message, publicKey) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
+    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils5.bytesToHex)(publicKey));
     if (!privateKey) {
       throw new ValidationError("Private key is not set", {
         field: "privateKey"
       });
     }
-    return import_secp256k15.schnorr.sign(message, (0, import_utils4.hexToBytes)(privateKey));
+    return import_secp256k15.schnorr.sign(message, (0, import_utils5.hexToBytes)(privateKey));
   }
   async signSchnorrWithIdentityKey(message) {
     if (!this.identityKey?.privateKey) {
@@ -1828,8 +1873,8 @@ var DefaultSparkSigner = class {
     );
     this.staticDepositKeyMap.set(idx, staticDepositKey);
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(staticDepositKey.publicKey),
-      (0, import_utils4.bytesToHex)(staticDepositKey.privateKey)
+      (0, import_utils5.bytesToHex)(staticDepositKey.publicKey),
+      (0, import_utils5.bytesToHex)(staticDepositKey.privateKey)
     );
     return staticDepositKey.publicKey;
   }
@@ -1874,7 +1919,7 @@ var DefaultSparkSigner = class {
     return await (0, import_bip39.mnemonicToSeed)(mnemonic);
   }
   async getTrackedPublicKeys() {
-    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(import_utils4.hexToBytes);
+    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(import_utils5.hexToBytes);
   }
   async generatePublicKey(hash) {
     if (!this.signingKey) {
@@ -1894,31 +1939,31 @@ var DefaultSparkSigner = class {
       });
     }
     const publicKey = import_secp256k15.secp256k1.getPublicKey(newPrivateKey);
-    const pubKeyHex = (0, import_utils4.bytesToHex)(publicKey);
-    const privKeyHex = (0, import_utils4.bytesToHex)(newPrivateKey);
+    const pubKeyHex = (0, import_utils5.bytesToHex)(publicKey);
+    const privKeyHex = (0, import_utils5.bytesToHex)(newPrivateKey);
     this.publicKeyToPrivateKeyMap.set(pubKeyHex, privKeyHex);
     return publicKey;
   }
   async removePublicKey(publicKey) {
-    this.publicKeyToPrivateKeyMap.delete((0, import_utils4.bytesToHex)(publicKey));
+    this.publicKeyToPrivateKeyMap.delete((0, import_utils5.bytesToHex)(publicKey));
   }
   async subtractPrivateKeysGivenPublicKeys(first, second) {
-    const firstPubKeyHex = (0, import_utils4.bytesToHex)(first);
-    const secondPubKeyHex = (0, import_utils4.bytesToHex)(second);
+    const firstPubKeyHex = (0, import_utils5.bytesToHex)(first);
+    const secondPubKeyHex = (0, import_utils5.bytesToHex)(second);
     const firstPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(firstPubKeyHex);
     const secondPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(secondPubKeyHex);
     if (!firstPrivateKeyHex || !secondPrivateKeyHex) {
       throw new Error("Private key is not set");
     }
-    const firstPrivateKey = (0, import_utils4.hexToBytes)(firstPrivateKeyHex);
-    const secondPrivateKey = (0, import_utils4.hexToBytes)(secondPrivateKeyHex);
+    const firstPrivateKey = (0, import_utils5.hexToBytes)(firstPrivateKeyHex);
+    const secondPrivateKey = (0, import_utils5.hexToBytes)(secondPrivateKeyHex);
     const resultPrivKey = subtractPrivateKeys(
       firstPrivateKey,
       secondPrivateKey
     );
     const resultPubKey = import_secp256k15.secp256k1.getPublicKey(resultPrivKey);
-    const resultPrivKeyHex = (0, import_utils4.bytesToHex)(resultPrivKey);
-    const resultPubKeyHex = (0, import_utils4.bytesToHex)(resultPubKey);
+    const resultPrivKeyHex = (0, import_utils5.bytesToHex)(resultPrivKey);
+    const resultPubKeyHex = (0, import_utils5.bytesToHex)(resultPubKey);
     this.publicKeyToPrivateKeyMap.set(resultPubKeyHex, resultPrivKeyHex);
     return resultPubKey;
   }
@@ -1930,14 +1975,14 @@ var DefaultSparkSigner = class {
     isSecretPubkey = false
   }) {
     if (isSecretPubkey) {
-      const pubKeyHex = (0, import_utils4.bytesToHex)(secret);
+      const pubKeyHex = (0, import_utils5.bytesToHex)(secret);
       const privateKey = this.publicKeyToPrivateKeyMap.get(pubKeyHex);
       if (!privateKey) {
         throw new Error("Private key is not set");
       }
-      secret = (0, import_utils4.hexToBytes)(privateKey);
+      secret = (0, import_utils5.hexToBytes)(privateKey);
     }
-    const secretAsInt = (0, import_utils4.bytesToNumberBE)(secret);
+    const secretAsInt = (0, import_utils5.bytesToNumberBE)(secret);
     return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
   }
   async signFrost({
@@ -1955,7 +2000,7 @@ var DefaultSparkSigner = class {
         field: "SparkFrost"
       });
     }
-    const privateAsPubKeyHex = (0, import_utils4.bytesToHex)(privateAsPubKey);
+    const privateAsPubKeyHex = (0, import_utils5.bytesToHex)(privateAsPubKey);
     const signingPrivateKey = this.publicKeyToPrivateKeyMap.get(privateAsPubKeyHex);
     if (!signingPrivateKey) {
       throw new ValidationError("Private key not found for public key", {
@@ -1969,7 +2014,7 @@ var DefaultSparkSigner = class {
       });
     }
     const keyPackage = {
-      secretKey: (0, import_utils4.hexToBytes)(signingPrivateKey),
+      secretKey: (0, import_utils5.hexToBytes)(signingPrivateKey),
       publicKey,
       verifyingKey
     };
@@ -2013,7 +2058,7 @@ var DefaultSparkSigner = class {
   }
   async createSparkWalletFromSeed(seed, accountNumber) {
     if (typeof seed === "string") {
-      seed = (0, import_utils4.hexToBytes)(seed);
+      seed = (0, import_utils5.hexToBytes)(seed);
     }
     const {
       masterPublicKey,
@@ -2028,28 +2073,28 @@ var DefaultSparkSigner = class {
     this.signingKey = signingKey.hdKey;
     this.staticDepositKey = staticDepositKey.hdKey;
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(identityKey.publicKey),
-      (0, import_utils4.bytesToHex)(identityKey.privateKey)
+      (0, import_utils5.bytesToHex)(identityKey.publicKey),
+      (0, import_utils5.bytesToHex)(identityKey.privateKey)
     );
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(depositKey.publicKey),
-      (0, import_utils4.bytesToHex)(depositKey.privateKey)
+      (0, import_utils5.bytesToHex)(depositKey.publicKey),
+      (0, import_utils5.bytesToHex)(depositKey.privateKey)
     );
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(staticDepositKey.publicKey),
-      (0, import_utils4.bytesToHex)(staticDepositKey.privateKey)
+      (0, import_utils5.bytesToHex)(staticDepositKey.publicKey),
+      (0, import_utils5.bytesToHex)(staticDepositKey.privateKey)
     );
-    return (0, import_utils4.bytesToHex)(identityKey.publicKey);
+    return (0, import_utils5.bytesToHex)(identityKey.publicKey);
   }
   async signMessageWithPublicKey(message, publicKey, compact) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
+    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils5.bytesToHex)(publicKey));
     if (!privateKey) {
       throw new ValidationError("Private key not found for public key", {
         field: "privateKey",
-        value: (0, import_utils4.bytesToHex)(publicKey)
+        value: (0, import_utils5.bytesToHex)(publicKey)
       });
     }
-    const signature = import_secp256k15.secp256k1.sign(message, (0, import_utils4.hexToBytes)(privateKey));
+    const signature = import_secp256k15.secp256k1.sign(message, (0, import_utils5.hexToBytes)(privateKey));
     if (compact) {
       return signature.toCompactRawBytes();
     }
@@ -2068,12 +2113,12 @@ var DefaultSparkSigner = class {
     return signature.toDERRawBytes();
   }
   async encryptLeafPrivateKeyEcies(receiverPublicKey, publicKey) {
-    const publicKeyHex = (0, import_utils4.bytesToHex)(publicKey);
+    const publicKeyHex = (0, import_utils5.bytesToHex)(publicKey);
     const privateKey = this.publicKeyToPrivateKeyMap.get(publicKeyHex);
     if (!privateKey) {
       throw new Error("Private key is not set");
     }
-    return ecies.encrypt(receiverPublicKey, (0, import_utils4.hexToBytes)(privateKey));
+    return ecies.encrypt(receiverPublicKey, (0, import_utils5.hexToBytes)(privateKey));
   }
   async decryptEcies(ciphertext) {
     if (!this.identityKey?.privateKey) {
@@ -2082,12 +2127,12 @@ var DefaultSparkSigner = class {
       });
     }
     const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils4.bytesToHex)(this.identityKey.privateKey)
+      (0, import_utils5.bytesToHex)(this.identityKey.privateKey)
     );
     const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
     const publicKey = import_secp256k15.secp256k1.getPublicKey(privateKey);
-    const publicKeyHex = (0, import_utils4.bytesToHex)(publicKey);
-    const privateKeyHex = (0, import_utils4.bytesToHex)(privateKey);
+    const publicKeyHex = (0, import_utils5.bytesToHex)(publicKey);
+    const privateKeyHex = (0, import_utils5.bytesToHex)(privateKey);
     this.publicKeyToPrivateKeyMap.set(publicKeyHex, privateKeyHex);
     return publicKey;
   }
@@ -2104,8 +2149,8 @@ var DefaultSparkSigner = class {
     const adaptor = generateAdaptorFromSignature(signature);
     const adaptorPublicKey = import_secp256k15.secp256k1.getPublicKey(adaptor.adaptorPrivateKey);
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(adaptorPublicKey),
-      (0, import_utils4.bytesToHex)(adaptor.adaptorPrivateKey)
+      (0, import_utils5.bytesToHex)(adaptorPublicKey),
+      (0, import_utils5.bytesToHex)(adaptor.adaptorPrivateKey)
     );
     return {
       adaptorSignature: signature,
@@ -2156,19 +2201,19 @@ var DefaultSparkSigner = class {
   }
   signTransactionIndex(tx, index, publicKey) {
     let privateKey;
-    if ((0, import_utils4.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+    if ((0, import_utils5.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.identityKey?.privateKey;
-    } else if ((0, import_utils4.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+    } else if ((0, import_utils5.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.depositKey?.privateKey;
     } else {
-      privateKey = (0, import_utils4.hexToBytes)(
-        this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey)) ?? ""
+      privateKey = (0, import_utils5.hexToBytes)(
+        this.publicKeyToPrivateKeyMap.get((0, import_utils5.bytesToHex)(publicKey)) ?? ""
       );
     }
     if (!privateKey) {
       throw new ValidationError("Private key not found for public key", {
         field: "privateKey",
-        value: (0, import_utils4.bytesToHex)(publicKey)
+        value: (0, import_utils5.bytesToHex)(publicKey)
       });
     }
     tx.signIdx(privateKey, index);
@@ -2177,7 +2222,7 @@ var DefaultSparkSigner = class {
 
 // src/utils/network.ts
 init_buffer();
-var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
+var import_lrc20_sdk3 = require("@buildonspark/lrc20-sdk");
 var btc = __toESM(require("@scure/btc-signer"), 1);
 var bitcoin = __toESM(require("bitcoinjs-lib"), 1);
 
@@ -15282,11 +15327,11 @@ var LRC_WALLET_NETWORK = Object.freeze({
   [4 /* LOCAL */]: bitcoin.networks.regtest
 });
 var LRC_WALLET_NETWORK_TYPE = Object.freeze({
-  [0 /* MAINNET */]: import_lrc20_sdk2.NetworkType.MAINNET,
-  [1 /* TESTNET */]: import_lrc20_sdk2.NetworkType.TESTNET,
-  [2 /* SIGNET */]: import_lrc20_sdk2.NetworkType.TESTNET,
-  [3 /* REGTEST */]: import_lrc20_sdk2.NetworkType.REGTEST,
-  [4 /* LOCAL */]: import_lrc20_sdk2.NetworkType.LOCAL
+  [0 /* MAINNET */]: import_lrc20_sdk3.NetworkType.MAINNET,
+  [1 /* TESTNET */]: import_lrc20_sdk3.NetworkType.TESTNET,
+  [2 /* SIGNET */]: import_lrc20_sdk3.NetworkType.TESTNET,
+  [3 /* REGTEST */]: import_lrc20_sdk3.NetworkType.REGTEST,
+  [4 /* LOCAL */]: import_lrc20_sdk3.NetworkType.LOCAL
 });
 
 // src/services/wallet-config.ts
@@ -15294,10 +15339,10 @@ init_buffer();
 
 // src/tests/isHermeticTest.ts
 init_buffer();
-var import_core = require("@lightsparkdev/core");
+var import_core2 = require("@lightsparkdev/core");
 var import_fs = __toESM(require("fs"), 1);
 function isHermeticTest() {
-  if (import_core.isNode) {
+  if (import_core2.isNode) {
     return (import_fs.default?.existsSync?.("/tmp/spark_hermetic") ?? false) || process.env.HERMETIC_TEST === "true";
   }
   return typeof process !== "undefined" && process.env?.HERMETIC_TEST === "true" || false;
@@ -15425,6 +15470,7 @@ var BASE_CONFIG = {
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
   tokenTransactionVersion: "V0",
+  tokenValidityDurationSeconds: 180,
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 1e4,
   expectedWithdrawRelativeBlockLocktime: 1e3,
@@ -15635,6 +15681,9 @@ var WalletConfigService = class {
   getTokenTransactionVersion() {
     return this.config.tokenTransactionVersion;
   }
+  getTokenValidityDurationSeconds() {
+    return this.config.tokenValidityDurationSeconds;
+  }
   getElectrsUrl() {
     return this.config.electrsUrl;
   }
@@ -15645,19 +15694,290 @@ var WalletConfigService = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils9 = require("@noble/curves/abstract/utils");
+var import_utils10 = require("@noble/curves/abstract/utils");
 var import_secp256k19 = require("@noble/curves/secp256k1");
 
 // src/utils/token-hashing.ts
 init_buffer();
 var import_sha22 = require("@noble/hashes/sha2");
 function hashTokenTransaction(tokenTransaction, partialHash = false) {
+  switch (tokenTransaction.version) {
+    case 0:
+      return hashTokenTransactionV0(tokenTransaction, partialHash);
+    case 1:
+      return hashTokenTransactionV1(tokenTransaction, partialHash);
+    default:
+      throw new ValidationError("invalid token transaction version", {
+        field: "tokenTransaction.version",
+        value: tokenTransaction.version
+      });
+  }
+}
+function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
+  if (!tokenTransaction) {
+    throw new ValidationError("token transaction cannot be nil", {
+      field: "tokenTransaction"
+    });
+  }
+  let allHashes = [];
+  if (tokenTransaction.tokenInputs?.$case === "transferInput") {
+    if (!tokenTransaction.tokenInputs.transferInput.outputsToSpend) {
+      throw new ValidationError("outputs to spend cannot be null", {
+        field: "tokenInputs.transferInput.outputsToSpend"
+      });
+    }
+    if (tokenTransaction.tokenInputs.transferInput.outputsToSpend.length === 0) {
+      throw new ValidationError("outputs to spend cannot be empty", {
+        field: "tokenInputs.transferInput.outputsToSpend"
+      });
+    }
+    for (const [
+      i,
+      output
+    ] of tokenTransaction.tokenInputs.transferInput.outputsToSpend.entries()) {
+      if (!output) {
+        throw new ValidationError(`output cannot be null at index ${i}`, {
+          field: `tokenInputs.transferInput.outputsToSpend[${i}]`,
+          index: i
+        });
+      }
+      const hashObj2 = import_sha22.sha256.create();
+      if (output.prevTokenTransactionHash) {
+        const prevHash = output.prevTokenTransactionHash;
+        if (output.prevTokenTransactionHash.length !== 32) {
+          throw new ValidationError(
+            `invalid previous transaction hash length at index ${i}`,
+            {
+              field: `tokenInputs.transferInput.outputsToSpend[${i}].prevTokenTransactionHash`,
+              value: prevHash,
+              expectedLength: 32,
+              actualLength: prevHash.length,
+              index: i
+            }
+          );
+        }
+        hashObj2.update(output.prevTokenTransactionHash);
+      }
+      const voutBytes = new Uint8Array(4);
+      new DataView(voutBytes.buffer).setUint32(
+        0,
+        output.prevTokenTransactionVout,
+        false
+      );
+      hashObj2.update(voutBytes);
+      allHashes.push(hashObj2.digest());
+    }
+  }
+  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
+    const hashObj2 = import_sha22.sha256.create();
+    if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
+      const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
+      if (issuerPubKey.length === 0) {
+        throw new ValidationError("issuer public key cannot be empty", {
+          field: "tokenInputs.mintInput.issuerPublicKey",
+          value: issuerPubKey,
+          expectedLength: 1,
+          actualLength: 0
+        });
+      }
+      hashObj2.update(issuerPubKey);
+      if (tokenTransaction.tokenInputs.mintInput.issuerProvidedTimestamp != 0) {
+        const timestampBytes = new Uint8Array(8);
+        new DataView(timestampBytes.buffer).setBigUint64(
+          0,
+          BigInt(
+            tokenTransaction.tokenInputs.mintInput.issuerProvidedTimestamp
+          ),
+          true
+          // true for little-endian to match Go implementation
+        );
+        hashObj2.update(timestampBytes);
+      }
+      allHashes.push(hashObj2.digest());
+    }
+  }
+  if (!tokenTransaction.tokenOutputs) {
+    throw new ValidationError("token outputs cannot be null", {
+      field: "tokenOutputs"
+    });
+  }
+  if (tokenTransaction.tokenOutputs.length === 0) {
+    throw new ValidationError("token outputs cannot be empty", {
+      field: "tokenOutputs"
+    });
+  }
+  for (const [i, output] of tokenTransaction.tokenOutputs.entries()) {
+    if (!output) {
+      throw new ValidationError(`output cannot be null at index ${i}`, {
+        field: `tokenOutputs[${i}]`,
+        index: i
+      });
+    }
+    const hashObj2 = import_sha22.sha256.create();
+    if (output.id && !partialHash) {
+      if (output.id.length === 0) {
+        throw new ValidationError(`output ID at index ${i} cannot be empty`, {
+          field: `tokenOutputs[${i}].id`,
+          index: i
+        });
+      }
+      hashObj2.update(new TextEncoder().encode(output.id));
+    }
+    if (output.ownerPublicKey) {
+      if (output.ownerPublicKey.length === 0) {
+        throw new ValidationError(
+          `owner public key at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].ownerPublicKey`,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.ownerPublicKey);
+    }
+    if (!partialHash) {
+      const revPubKey = output.revocationCommitment;
+      if (revPubKey) {
+        if (revPubKey.length === 0) {
+          throw new ValidationError(
+            `revocation commitment at index ${i} cannot be empty`,
+            {
+              field: `tokenOutputs[${i}].revocationCommitment`,
+              index: i
+            }
+          );
+        }
+        hashObj2.update(revPubKey);
+      }
+      const bondBytes = new Uint8Array(8);
+      new DataView(bondBytes.buffer).setBigUint64(
+        0,
+        BigInt(output.withdrawBondSats),
+        false
+      );
+      hashObj2.update(bondBytes);
+      const locktimeBytes = new Uint8Array(8);
+      new DataView(locktimeBytes.buffer).setBigUint64(
+        0,
+        BigInt(output.withdrawRelativeBlockLocktime),
+        false
+      );
+      hashObj2.update(locktimeBytes);
+    }
+    if (output.tokenPublicKey) {
+      if (output.tokenPublicKey.length === 0) {
+        throw new ValidationError(
+          `token public key at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].tokenPublicKey`,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.tokenPublicKey);
+    }
+    if (output.tokenAmount) {
+      if (output.tokenAmount.length === 0) {
+        throw new ValidationError(
+          `token amount at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].tokenAmount`,
+            index: i
+          }
+        );
+      }
+      if (output.tokenAmount.length > 16) {
+        throw new ValidationError(
+          `token amount at index ${i} exceeds maximum length`,
+          {
+            field: `tokenOutputs[${i}].tokenAmount`,
+            value: output.tokenAmount,
+            expectedLength: 16,
+            actualLength: output.tokenAmount.length,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.tokenAmount);
+    }
+    allHashes.push(hashObj2.digest());
+  }
+  if (!tokenTransaction.sparkOperatorIdentityPublicKeys) {
+    throw new ValidationError(
+      "spark operator identity public keys cannot be null",
+      {}
+    );
+  }
+  const sortedPubKeys = [
+    ...tokenTransaction.sparkOperatorIdentityPublicKeys || []
+  ].sort((a, b) => {
+    for (let i = 0; i < a.length && i < b.length; i++) {
+      if (a[i] !== b[i]) return a[i] - b[i];
+    }
+    return a.length - b.length;
+  });
+  for (const [i, pubKey] of sortedPubKeys.entries()) {
+    if (!pubKey) {
+      throw new ValidationError(
+        `operator public key at index ${i} cannot be null`,
+        {
+          field: `sparkOperatorIdentityPublicKeys[${i}]`,
+          index: i
+        }
+      );
+    }
+    if (pubKey.length === 0) {
+      throw new ValidationError(
+        `operator public key at index ${i} cannot be empty`,
+        {
+          field: `sparkOperatorIdentityPublicKeys[${i}]`,
+          index: i
+        }
+      );
+    }
+    const hashObj2 = import_sha22.sha256.create();
+    hashObj2.update(pubKey);
+    allHashes.push(hashObj2.digest());
+  }
+  const hashObj = import_sha22.sha256.create();
+  let networkBytes = new Uint8Array(4);
+  new DataView(networkBytes.buffer).setUint32(
+    0,
+    tokenTransaction.network.valueOf(),
+    false
+    // false for big-endian
+  );
+  hashObj.update(networkBytes);
+  allHashes.push(hashObj.digest());
+  const finalHashObj = import_sha22.sha256.create();
+  const concatenatedHashes = new Uint8Array(
+    allHashes.reduce((sum, hash) => sum + hash.length, 0)
+  );
+  let offset = 0;
+  for (const hash of allHashes) {
+    concatenatedHashes.set(hash, offset);
+    offset += hash.length;
+  }
+  finalHashObj.update(concatenatedHashes);
+  return finalHashObj.digest();
+}
+function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
   if (!tokenTransaction) {
     throw new ValidationError("token transaction cannot be nil", {
       field: "tokenTransaction"
     });
   }
   let allHashes = [];
+  const versionHashObj = import_sha22.sha256.create();
+  const versionBytes = new Uint8Array(4);
+  new DataView(versionBytes.buffer).setUint32(
+    0,
+    tokenTransaction.version,
+    false
+    // false for big-endian
+  );
+  versionHashObj.update(versionBytes);
+  allHashes.push(versionHashObj.digest());
   if (tokenTransaction.tokenInputs?.$case === "transferInput") {
     if (!tokenTransaction.tokenInputs.transferInput.outputsToSpend) {
       throw new ValidationError("outputs to spend cannot be null", {
@@ -15887,6 +16207,17 @@ function hashTokenTransaction(tokenTransaction, partialHash = false) {
   );
   hashObj.update(networkBytes);
   allHashes.push(hashObj.digest());
+  const expiryHashObj = import_sha22.sha256.create();
+  const validityDurationBytes = new Uint8Array(8);
+  const expiryUnixTime = tokenTransaction.expiryTime ? Math.floor(tokenTransaction.expiryTime.getTime() / 1e3) : 0;
+  new DataView(validityDurationBytes.buffer).setBigUint64(
+    0,
+    BigInt(expiryUnixTime),
+    false
+    // false for big-endian
+  );
+  expiryHashObj.update(validityDurationBytes);
+  allHashes.push(expiryHashObj.digest());
   const finalHashObj = import_sha22.sha256.create();
   const concatenatedHashes = new Uint8Array(
     allHashes.reduce((sum, hash) => sum + hash.length, 0)
@@ -15950,15 +16281,15 @@ function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
 
 // src/utils/token-transactions.ts
 init_buffer();
-var import_utils6 = require("@noble/curves/abstract/utils");
+var import_utils7 = require("@noble/curves/abstract/utils");
 function calculateAvailableTokenAmount(outputLeaves) {
   return outputLeaves.reduce(
-    (sum, output) => sum + BigInt((0, import_utils6.bytesToNumberBE)(output.output.tokenAmount)),
+    (sum, output) => sum + BigInt((0, import_utils7.bytesToNumberBE)(output.output.tokenAmount)),
     BigInt(0)
   );
 }
 function checkIfSelectedOutputsAreAvailable(selectedOutputs, tokenOutputs, tokenPublicKey) {
-  const tokenPubKeyHex = (0, import_utils6.bytesToHex)(tokenPublicKey);
+  const tokenPubKeyHex = (0, import_utils7.bytesToHex)(tokenPublicKey);
   const tokenOutputsAvailable = tokenOutputs.get(tokenPubKeyHex);
   if (!tokenOutputsAvailable) {
     return false;
@@ -16234,7 +16565,7 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 }
 
 // src/services/token-transactions.ts
-var import_utils10 = require("@noble/hashes/utils");
+var import_utils11 = require("@noble/hashes/utils");
 
 // src/address/index.ts
 init_buffer();
@@ -16242,10 +16573,10 @@ init_buffer();
 // src/address/address.ts
 init_buffer();
 var import_secp256k17 = require("@noble/curves/secp256k1");
-var import_utils7 = require("@noble/hashes/utils");
+var import_utils8 = require("@noble/hashes/utils");
 var import_base2 = require("@scure/base");
 var import_uuidv7 = require("uuidv7");
-var import_utils8 = require("@noble/curves/abstract/utils");
+var import_utils9 = require("@noble/curves/abstract/utils");
 var AddressNetwork = {
   MAINNET: "sp",
   TESTNET: "spt",
@@ -16264,7 +16595,7 @@ function decodeSparkAddress(address2, network) {
       });
     }
     const payload = SparkAddress.decode(import_base2.bech32m.fromWords(decoded.words));
-    const publicKey = (0, import_utils7.bytesToHex)(payload.identityPublicKey);
+    const publicKey = (0, import_utils8.bytesToHex)(payload.identityPublicKey);
     isValidPublicKey(publicKey);
     const paymentIntentFields = payload.paymentIntentFields;
     return {
@@ -16272,8 +16603,8 @@ function decodeSparkAddress(address2, network) {
       network,
       paymentIntentFields: paymentIntentFields && {
         id: import_uuidv7.UUID.ofInner(paymentIntentFields.id).toString(),
-        assetIdentifier: paymentIntentFields.assetIdentifier ? (0, import_utils7.bytesToHex)(paymentIntentFields.assetIdentifier) : void 0,
-        assetAmount: (0, import_utils8.bytesToNumberBE)(paymentIntentFields.assetAmount),
+        assetIdentifier: paymentIntentFields.assetIdentifier ? (0, import_utils8.bytesToHex)(paymentIntentFields.assetIdentifier) : void 0,
+        assetAmount: (0, import_utils9.bytesToNumberBE)(paymentIntentFields.assetAmount),
         memo: paymentIntentFields.memo
       }
     };
@@ -16374,7 +16705,7 @@ var TokenTransactionService = class {
       if (!checkIfSelectedOutputsAreAvailable(
         outputsToUse,
         tokenOutputs,
-        (0, import_utils10.hexToBytes)(receiverOutputs[0].tokenPublicKey)
+        (0, import_utils11.hexToBytes)(receiverOutputs[0].tokenPublicKey)
       )) {
         throw new ValidationError(
           "One or more selected TTXOs are not available",
@@ -16415,8 +16746,8 @@ var TokenTransactionService = class {
         this.config.getNetworkType()
       );
       return {
-        receiverSparkAddress: (0, import_utils10.hexToBytes)(receiverAddress.identityPublicKey),
-        tokenPublicKey: (0, import_utils10.hexToBytes)(transfer.tokenPublicKey),
+        receiverSparkAddress: (0, import_utils11.hexToBytes)(receiverAddress.identityPublicKey),
+        tokenPublicKey: (0, import_utils11.hexToBytes)(transfer.tokenPublicKey),
         tokenAmount: transfer.tokenAmount
       };
     });
@@ -16448,7 +16779,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverSparkAddress,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils9.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils10.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -16456,7 +16787,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils9.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils10.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -16483,7 +16814,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverSparkAddress,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils9.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils10.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -16491,7 +16822,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils9.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils10.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -16516,7 +16847,7 @@ var TokenTransactionService = class {
     for (const [_, operator] of Object.entries(
       this.config.getSigningOperators()
     )) {
-      operatorKeys.push((0, import_utils10.hexToBytes)(operator.identityPublicKey));
+      operatorKeys.push((0, import_utils11.hexToBytes)(operator.identityPublicKey));
     }
     return operatorKeys;
   }
@@ -16600,7 +16931,7 @@ var TokenTransactionService = class {
               {
                 field: "revocationCommitment",
                 value: derivedRevocationCommitment,
-                expected: (0, import_utils9.bytesToHex)(outputsToSpendCommitments[outputIndex]),
+                expected: (0, import_utils10.bytesToHex)(outputsToSpendCommitments[outputIndex]),
                 outputIndex
               }
             )
@@ -16626,7 +16957,7 @@ var TokenTransactionService = class {
         threshold
       );
     }
-    return (0, import_utils9.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils10.bytesToHex)(finalTokenTransactionHash);
   }
   async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
@@ -16640,13 +16971,13 @@ var TokenTransactionService = class {
       finalTokenTransactionHash,
       signingOperators
     );
-    return (0, import_utils9.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils10.bytesToHex)(finalTokenTransactionHash);
   }
   async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const partialTokenTransactionHash = hashTokenTransaction(
+    const partialTokenTransactionHash = hashTokenTransactionV0(
       tokenTransaction,
       true
     );
@@ -16727,7 +17058,7 @@ var TokenTransactionService = class {
       this.config.getThreshold()
     );
     const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransaction(
+    const finalTokenTransactionHash = hashTokenTransactionV0(
       finalTokenTransaction,
       false
     );
@@ -16795,7 +17126,9 @@ var TokenTransactionService = class {
     const startResponse = await sparkClient.start_transaction(
       {
         identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        partialTokenTransaction: tokenTransaction
+        partialTokenTransaction: tokenTransaction,
+        validityDurationSeconds: await this.config.getTokenValidityDurationSeconds(),
+        partialTokenTransactionOwnerSignatures: ownerSignaturesWithIndex
       },
       {
         retry: true,
@@ -16837,7 +17170,7 @@ var TokenTransactionService = class {
           const identityPublicKey = await this.config.signer.getIdentityPublicKey();
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils10.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils11.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let operatorSpecificSignatures = [];
@@ -16994,7 +17327,7 @@ var TokenTransactionService = class {
       []
     );
     unsortedTokenOutputs.forEach((output) => {
-      const tokenKey = (0, import_utils9.bytesToHex)(output.output.tokenPublicKey);
+      const tokenKey = (0, import_utils10.bytesToHex)(output.output.tokenPublicKey);
       const index = output.previousTransactionVout;
       tokenOutputs.set(tokenKey, [
         { ...output, previousTransactionVout: index }
@@ -17010,7 +17343,7 @@ var TokenTransactionService = class {
       });
     }
     const exactMatch = tokenOutputs.find(
-      (item) => (0, import_utils9.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
+      (item) => (0, import_utils10.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
     );
     if (exactMatch) {
       return [exactMatch];
@@ -17021,7 +17354,7 @@ var TokenTransactionService = class {
     for (const outputWithPreviousTransactionData of tokenOutputs) {
       if (remainingAmount <= 0n) break;
       selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= (0, import_utils9.bytesToNumberBE)(
+      remainingAmount -= (0, import_utils10.bytesToNumberBE)(
         outputWithPreviousTransactionData.output.tokenAmount
       );
     }
@@ -17037,13 +17370,13 @@ var TokenTransactionService = class {
     if (strategy === "SMALL_FIRST") {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils9.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils9.bytesToNumberBE)(b.output.tokenAmount)
+          (0, import_utils10.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils10.bytesToNumberBE)(b.output.tokenAmount)
         );
       });
     } else {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils9.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils9.bytesToNumberBE)(a.output.tokenAmount)
+          (0, import_utils10.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils10.bytesToNumberBE)(a.output.tokenAmount)
         );
       });
     }
@@ -17051,7 +17384,7 @@ var TokenTransactionService = class {
   // Helper function for deciding if the signer public key is the identity public key
   async signMessageWithKey(message, publicKey) {
     const tokenSignatures = this.config.getTokenSignatures();
-    if ((0, import_utils9.bytesToHex)(publicKey) === (0, import_utils9.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
+    if ((0, import_utils10.bytesToHex)(publicKey) === (0, import_utils10.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
       if (tokenSignatures === "SCHNORR") {
         return await this.config.signer.signSchnorrWithIdentityKey(message);
       } else {
@@ -17127,7 +17460,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils10.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils11.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -17143,7 +17476,7 @@ var TokenTransactionService = class {
         for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils10.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils11.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let ownerSignature;
@@ -17160,7 +17493,7 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: (0, import_utils10.hexToBytes)(operator.identityPublicKey)
+        operatorIdentityPublicKey: (0, import_utils11.hexToBytes)(operator.identityPublicKey)
       });
     }
     return inputTtxoSignaturesPerOperator;
@@ -17172,7 +17505,7 @@ function isTokenTransaction(tokenTransaction) {
 
 // src/services/connection.ts
 init_buffer();
-var import_core2 = require("@lightsparkdev/core");
+var import_core3 = require("@lightsparkdev/core");
 var import_sha23 = require("@noble/hashes/sha2");
 var import_nice_grpc_client_middleware_retry = require("nice-grpc-client-middleware-retry");
 var import_nice_grpc_common2 = require("nice-grpc-common");
@@ -19021,7 +19354,7 @@ var ConnectionManager = class {
   async createMockClient(address2) {
     const channel = await this.createChannelWithTLS(address2);
     const isNodeChannel = "close" in channel;
-    if (import_core2.isNode && isNodeChannel && !isBun) {
+    if (import_core3.isNode && isNodeChannel && !isBun) {
       const grpcModule = await import("nice-grpc");
       const { createClient } = "default" in grpcModule ? grpcModule.default : grpcModule;
       const client = createClient(MockServiceDefinition, channel);
@@ -19038,7 +19371,7 @@ var ConnectionManager = class {
   }
   async createChannelWithTLS(address2, certPath) {
     try {
-      if (import_core2.isNode && !isBun) {
+      if (import_core3.isNode && !isBun) {
         const grpcModule = await import("nice-grpc");
         const { ChannelCredentials, createChannel } = "default" in grpcModule ? grpcModule.default : grpcModule;
         if (certPath) {
@@ -19179,14 +19512,38 @@ var ConnectionManager = class {
   }
   async createSparkAuthnGrpcConnection(address2, certPath) {
     const channel = await this.createChannelWithTLS(address2, certPath);
+    const authnMiddleware = this.createAuthnMiddleware();
     return this.createGrpcClient(
       SparkAuthnServiceDefinition,
       channel,
-      false
+      false,
+      authnMiddleware
     );
   }
+  createAuthnMiddleware() {
+    if (import_core3.isNode) {
+      return async function* (call, options) {
+        const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
+          "X-Client-Env",
+          clientEnv
+        );
+        return yield* call.next(call.request, {
+          ...options,
+          metadata
+        });
+      }.bind(this);
+    } else {
+      return async function* (call, options) {
+        const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("X-Client-Env", clientEnv).set("Content-Type", "application/grpc-web+proto");
+        return yield* call.next(call.request, {
+          ...options,
+          metadata
+        });
+      }.bind(this);
+    }
+  }
   createMiddleware(address2, authToken) {
-    if (import_core2.isNode) {
+    if (import_core3.isNode) {
       return this.createNodeMiddleware(address2, authToken);
     } else {
       return this.createBrowserMiddleware(address2, authToken);
@@ -19194,21 +19551,29 @@ var ConnectionManager = class {
   }
   createNodeMiddleware(address2, initialAuthToken) {
     return async function* (call, options) {
+      const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
+        "X-Client-Env",
+        clientEnv
+      );
       try {
         return yield* call.next(call.request, {
           ...options,
-          metadata: (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
+          metadata: metadata.set(
             "Authorization",
             `Bearer ${this.clients.get(address2)?.authToken || initialAuthToken}`
-          ).set("User-Agent", "spark-js-sdk")
+          )
         });
       } catch (error) {
         if (error.message?.includes("token has expired")) {
           const newAuthToken = await this.authenticate(address2);
-          this.clients.get(address2).authToken = newAuthToken;
+          const clientData = this.clients.get(address2);
+          if (!clientData) {
+            throw new Error(`No client found for address: ${address2}`);
+          }
+          clientData.authToken = newAuthToken;
           return yield* call.next(call.request, {
             ...options,
-            metadata: (0, import_nice_grpc_common2.Metadata)(options.metadata).set("Authorization", `Bearer ${newAuthToken}`).set("User-Agent", "spark-js-sdk")
+            metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`)
           });
         }
         throw error;
@@ -19217,21 +19582,26 @@ var ConnectionManager = class {
   }
   createBrowserMiddleware(address2, initialAuthToken) {
     return async function* (call, options) {
+      const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("X-Client-Env", clientEnv).set("Content-Type", "application/grpc-web+proto");
       try {
         return yield* call.next(call.request, {
           ...options,
-          metadata: (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
+          metadata: metadata.set(
             "Authorization",
             `Bearer ${this.clients.get(address2)?.authToken || initialAuthToken}`
-          ).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto").set("User-Agent", "spark-js-sdk")
+          )
         });
       } catch (error) {
         if (error.message?.includes("token has expired")) {
           const newAuthToken = await this.authenticate(address2);
-          this.clients.get(address2).authToken = newAuthToken;
+          const clientData = this.clients.get(address2);
+          if (!clientData) {
+            throw new Error(`No client found for address: ${address2}`);
+          }
+          clientData.authToken = newAuthToken;
           return yield* call.next(call.request, {
             ...options,
-            metadata: (0, import_nice_grpc_common2.Metadata)(options.metadata).set("Authorization", `Bearer ${newAuthToken}`).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto").set("User-Agent", "spark-js-sdk")
+            metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`)
           });
         }
         throw error;
@@ -19246,7 +19616,7 @@ var ConnectionManager = class {
     };
     let options = {};
     const isNodeChannel = "close" in channel;
-    if (import_core2.isNode && isNodeChannel && !isBun) {
+    if (import_core3.isNode && isNodeChannel && !isBun) {
       const grpcModule = await import("nice-grpc");
       const { openTelemetryClientMiddleware } = await import("nice-grpc-opentelemetry");
       const { createClientFactory } = "default" in grpcModule ? grpcModule.default : grpcModule;