@buildonspark/spark-sdk 0.1.41 → 0.1.43

package/dist/services/wallet-config.cjs

@@ -192,6 +192,7 @@ var BASE_CONFIG = {
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
   tokenTransactionVersion: "V0",
+  tokenValidityDurationSeconds: 180,
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 1e4,
   expectedWithdrawRelativeBlockLocktime: 1e3,

package/dist/services/wallet-config.d.cts

@@ -1,15 +1,16 @@
 import { MayHaveLrc20WalletApiConfig, LRC20WalletApiConfig } from '@buildonspark/lrc20-sdk';
-import { M as MayHaveSspClientOptions, B as SspClientOptions } from '../RequestLightningSendInput-DXcLoiCe.cjs';
-import { a as NetworkType } from '../network-BiwBmoOg.cjs';
+import { M as MayHaveSspClientOptions, B as SspClientOptions } from '../RequestLightningSendInput-Na1mHdWg.cjs';
+import { a as NetworkType } from '../network-D5lKssVl.cjs';
 import '@lightsparkdev/core';
 import '../BitcoinNetwork-TnABML0T.cjs';
-import '../signer-BhLS7SYR.cjs';
+import '../signer-IO3oMRNj.cjs';
 import '@scure/bip32';
-import '../spark-DjR1b3TC.cjs';
+import '../spark-CDm4gqS6.cjs';
 import '@bufbuild/protobuf/wire';
 import 'nice-grpc-common';
 import '@scure/btc-signer';
 import 'bitcoinjs-lib';
+import '@buildonspark/lrc20-sdk/lrc/types';
 
 declare const ELECTRS_CREDENTIALS: {
     username: string;
@@ -35,6 +36,7 @@ type ConfigOptions = MayHaveLrc20WalletApiConfig & MayHaveSspClientOptions & {
     readonly lrc20Address?: string;
     readonly threshold?: number;
     readonly tokenSignatures?: "ECDSA" | "SCHNORR";
+    readonly tokenValidityDurationSeconds?: number;
     readonly tokenTransactionVersion?: "V0" | "V1";
     readonly electrsUrl?: string;
     readonly lrc20ApiConfig?: LRC20WalletApiConfig;

package/dist/services/wallet-config.d.ts

@@ -1,15 +1,16 @@
 import { MayHaveLrc20WalletApiConfig, LRC20WalletApiConfig } from '@buildonspark/lrc20-sdk';
-import { M as MayHaveSspClientOptions, B as SspClientOptions } from '../RequestLightningSendInput-mXUWn_cp.js';
-import { a as NetworkType } from '../network-BF2GYPye.js';
+import { M as MayHaveSspClientOptions, B as SspClientOptions } from '../RequestLightningSendInput-D7fZdT4A.js';
+import { a as NetworkType } from '../network-xkBSpaTn.js';
 import '@lightsparkdev/core';
 import '../BitcoinNetwork-TnABML0T.js';
-import '../signer-CylxIujU.js';
+import '../signer-wqesWifN.js';
 import '@scure/bip32';
-import '../spark-DjR1b3TC.js';
+import '../spark-CDm4gqS6.js';
 import '@bufbuild/protobuf/wire';
 import 'nice-grpc-common';
 import '@scure/btc-signer';
 import 'bitcoinjs-lib';
+import '@buildonspark/lrc20-sdk/lrc/types';
 
 declare const ELECTRS_CREDENTIALS: {
     username: string;
@@ -35,6 +36,7 @@ type ConfigOptions = MayHaveLrc20WalletApiConfig & MayHaveSspClientOptions & {
     readonly lrc20Address?: string;
     readonly threshold?: number;
     readonly tokenSignatures?: "ECDSA" | "SCHNORR";
+    readonly tokenValidityDurationSeconds?: number;
     readonly tokenTransactionVersion?: "V0" | "V1";
     readonly electrsUrl?: string;
     readonly lrc20ApiConfig?: LRC20WalletApiConfig;

package/dist/services/wallet-config.js

@@ -12,7 +12,7 @@ import {
   getSspIdentityPublicKey,
   getSspSchemaEndpoint,
   getSspUrl
-} from "../chunk-7EFSUADA.js";
+} from "../chunk-DOA6QXYQ.js";
 import "../chunk-MVRQ5US7.js";
 export {
   ELECTRS_CREDENTIALS,

package/dist/signer/signer.cjs

@@ -1114,12 +1114,16 @@ var init_wasm = __esm({
 var signer_exports = {};
 __export(signer_exports, {
   DefaultSparkSigner: () => DefaultSparkSigner,
+  MultisigReceiptInput: () => import_types2.MultisigReceiptInput,
+  PARITY: () => import_lrc20_sdk2.PARITY,
+  Receipt: () => import_lrc20_sdk2.Receipt,
   TaprootOutputKeysGenerator: () => TaprootOutputKeysGenerator,
-  TaprootSparkSigner: () => TaprootSparkSigner
+  TaprootSparkSigner: () => TaprootSparkSigner,
+  fromPrivateKey: () => import_lrc20_sdk2.fromPrivateKey
 });
 module.exports = __toCommonJS(signer_exports);
 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");
@@ -1128,14 +1132,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;
@@ -1167,12 +1184,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 ValidationError = class extends SparkSDKError {
@@ -1189,7 +1236,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
@@ -1199,10 +1246,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
@@ -1223,15 +1270,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
     });
   }
@@ -1240,7 +1287,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) {
@@ -1253,12 +1300,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
@@ -1277,7 +1324,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;
     }
@@ -1369,7 +1416,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) {
@@ -1439,7 +1488,7 @@ var TaprootOutputKeysGenerator = class {
     }
     const derivationPath = this.useAddressIndex ? `m/86'/0'/0'/0/${accountNumber}` : `m/86'/0'/${accountNumber}'/0/0`;
     const taprootInternalKey = hdkey.derive(derivationPath);
-    let tweakedPrivateKey = (0, import_utils5.taprootTweakPrivKey)(taprootInternalKey.privateKey);
+    let tweakedPrivateKey = (0, import_utils6.taprootTweakPrivKey)(taprootInternalKey.privateKey);
     let tweakedPublicKey = import_secp256k15.secp256k1.getPublicKey(tweakedPrivateKey);
     if (tweakedPublicKey[0] === 3) {
       tweakedPrivateKey = (0, import_secp256k16.privateNegate)(tweakedPrivateKey);
@@ -1526,28 +1575,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) {
@@ -1589,8 +1638,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;
   }
@@ -1635,7 +1684,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) {
@@ -1655,31 +1704,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;
   }
@@ -1691,14 +1740,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({
@@ -1716,7 +1765,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", {
@@ -1730,7 +1779,7 @@ var DefaultSparkSigner = class {
       });
     }
     const keyPackage = {
-      secretKey: (0, import_utils4.hexToBytes)(signingPrivateKey),
+      secretKey: (0, import_utils5.hexToBytes)(signingPrivateKey),
       publicKey,
       verifyingKey
     };
@@ -1774,7 +1823,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,
@@ -1789,28 +1838,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();
     }
@@ -1829,12 +1878,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) {
@@ -1843,12 +1892,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;
   }
@@ -1865,8 +1914,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,
@@ -1917,19 +1966,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);
@@ -1943,6 +1992,10 @@ var TaprootSparkSigner = class extends DefaultSparkSigner {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DefaultSparkSigner,
+  MultisigReceiptInput,
+  PARITY,
+  Receipt,
   TaprootOutputKeysGenerator,
-  TaprootSparkSigner
+  TaprootSparkSigner,
+  fromPrivateKey
 });

package/dist/signer/signer.d.cts

@@ -1,8 +1,9 @@
 import '@scure/bip32';
-import '../spark-DjR1b3TC.cjs';
-export { A as AggregateFrostParams, D as DefaultSparkSigner, k as SignFrostParams, h as SigningCommitment, i as SigningNonce, S as SparkSigner, l as SplitSecretWithProofsParams, j as TaprootOutputKeysGenerator, T as TaprootSparkSigner } from '../signer-BhLS7SYR.cjs';
-import '@buildonspark/lrc20-sdk';
+import '../spark-CDm4gqS6.cjs';
+export { A as AggregateFrostParams, D as DefaultSparkSigner, k as SignFrostParams, h as SigningCommitment, i as SigningNonce, S as SparkSigner, l as SplitSecretWithProofsParams, j as TaprootOutputKeysGenerator, T as TaprootSparkSigner } from '../signer-IO3oMRNj.cjs';
+export { PARITY, Receipt, TokenSigner, fromPrivateKey } from '@buildonspark/lrc20-sdk';
 import '@scure/btc-signer';
 import 'bitcoinjs-lib';
+export { MultisigReceiptInput } from '@buildonspark/lrc20-sdk/lrc/types';
 import '@bufbuild/protobuf/wire';
 import 'nice-grpc-common';

package/dist/signer/signer.d.ts

@@ -1,8 +1,9 @@
 import '@scure/bip32';
-import '../spark-DjR1b3TC.js';
-export { A as AggregateFrostParams, D as DefaultSparkSigner, k as SignFrostParams, h as SigningCommitment, i as SigningNonce, S as SparkSigner, l as SplitSecretWithProofsParams, j as TaprootOutputKeysGenerator, T as TaprootSparkSigner } from '../signer-CylxIujU.js';
-import '@buildonspark/lrc20-sdk';
+import '../spark-CDm4gqS6.js';
+export { A as AggregateFrostParams, D as DefaultSparkSigner, k as SignFrostParams, h as SigningCommitment, i as SigningNonce, S as SparkSigner, l as SplitSecretWithProofsParams, j as TaprootOutputKeysGenerator, T as TaprootSparkSigner } from '../signer-wqesWifN.js';
+export { PARITY, Receipt, TokenSigner, fromPrivateKey } from '@buildonspark/lrc20-sdk';
 import '@scure/btc-signer';
 import 'bitcoinjs-lib';
+export { MultisigReceiptInput } from '@buildonspark/lrc20-sdk/lrc/types';
 import '@bufbuild/protobuf/wire';
 import 'nice-grpc-common';

package/dist/signer/signer.js

@@ -1,16 +1,24 @@
 import {
   DefaultSparkSigner,
+  MultisigReceiptInput,
+  PARITY,
+  Receipt,
   TaprootOutputKeysGenerator,
-  TaprootSparkSigner
-} from "../chunk-UKT6OFLO.js";
-import "../chunk-7VMYMQLF.js";
-import "../chunk-HKAKEKCE.js";
-import "../chunk-MGPRLH6Q.js";
+  TaprootSparkSigner,
+  fromPrivateKey
+} from "../chunk-TIUBYNN5.js";
+import "../chunk-VFJQNBFX.js";
+import "../chunk-NSJF5F5O.js";
+import "../chunk-QNNSEJ4P.js";
 import "../chunk-VTUGIIWI.js";
-import "../chunk-TWF35O6M.js";
+import "../chunk-GSI4OLXZ.js";
 import "../chunk-MVRQ5US7.js";
 export {
   DefaultSparkSigner,
+  MultisigReceiptInput,
+  PARITY,
+  Receipt,
   TaprootOutputKeysGenerator,
-  TaprootSparkSigner
+  TaprootSparkSigner,
+  fromPrivateKey
 };

package/dist/{signer-CylxIujU.d.ts → signer-IO3oMRNj.d.cts}

@@ -1,8 +1,9 @@
 import { HDKey } from '@scure/bip32';
-import { b as TreeNode } from './spark-DjR1b3TC.js';
+import { d as TreeNode } from './spark-CDm4gqS6.cjs';
 import { TokenSigner, Receipt } from '@buildonspark/lrc20-sdk';
 import { Transaction } from '@scure/btc-signer';
 import { Psbt } from 'bitcoinjs-lib';
+import '@buildonspark/lrc20-sdk/lrc/types';
 
 interface ISigningCommitment {
     hiding: Uint8Array;

package/dist/{signer-BhLS7SYR.d.cts → signer-wqesWifN.d.ts}

@@ -1,8 +1,9 @@
 import { HDKey } from '@scure/bip32';
-import { b as TreeNode } from './spark-DjR1b3TC.cjs';
+import { d as TreeNode } from './spark-CDm4gqS6.js';
 import { TokenSigner, Receipt } from '@buildonspark/lrc20-sdk';
 import { Transaction } from '@scure/btc-signer';
 import { Psbt } from 'bitcoinjs-lib';
+import '@buildonspark/lrc20-sdk/lrc/types';
 
 interface ISigningCommitment {
     hiding: Uint8Array;