@buildonspark/spark-sdk 0.1.41 → 0.1.43

package/dist/{chunk-J5W5Q2ZP.js → chunk-DQYKQJRZ.js}

@@ -2,19 +2,19 @@ import {
   calculateAvailableTokenAmount,
   checkIfSelectedOutputsAreAvailable,
   collectResponses
-} from "./chunk-ATEHMLKP.js";
+} from "./chunk-6AFUC5M2.js";
 import {
   decodeSparkAddress
-} from "./chunk-TM4TOEOX.js";
+} from "./chunk-O4RYNJNB.js";
 import {
   bigIntToPrivateKey,
   recoverSecret
-} from "./chunk-MGPRLH6Q.js";
+} from "./chunk-QNNSEJ4P.js";
 import {
   InternalValidationError,
   NetworkError,
   ValidationError
-} from "./chunk-TWF35O6M.js";
+} from "./chunk-GSI4OLXZ.js";
 import {
   Buffer
 } from "./chunk-MVRQ5US7.js";
@@ -30,6 +30,19 @@ import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
 // src/utils/token-hashing.ts
 import { sha256 } from "@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"
@@ -277,6 +290,275 @@ function hashTokenTransaction(tokenTransaction, partialHash = false) {
   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 = 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", {
+        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 = 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 = 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 = 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 = sha256.create();
+    hashObj2.update(pubKey);
+    allHashes.push(hashObj2.digest());
+  }
+  const hashObj = 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 expiryHashObj = 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 = 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 hashOperatorSpecificTokenTransactionSignablePayload(payload) {
   if (!payload) {
     throw new ValidationError(
@@ -900,7 +1182,7 @@ var TokenTransactionService = class {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const partialTokenTransactionHash = hashTokenTransaction(
+    const partialTokenTransactionHash = hashTokenTransactionV0(
       tokenTransaction,
       true
     );
@@ -981,7 +1263,7 @@ var TokenTransactionService = class {
       this.config.getThreshold()
     );
     const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransaction(
+    const finalTokenTransactionHash = hashTokenTransactionV0(
       finalTokenTransaction,
       false
     );
@@ -1049,7 +1331,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,

package/dist/{chunk-TWF35O6M.js → chunk-GSI4OLXZ.js}

@@ -1,4 +1,5 @@
 // src/errors/base.ts
+import { bytesToHex } from "@noble/hashes/utils";
 var SparkSDKError = class extends Error {
   context;
   originalError;
@@ -30,12 +31,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${bytesToHex(arr)})`;
+}
 
 // src/errors/types.ts
 var NetworkError = class extends SparkSDKError {

package/dist/{chunk-2ZXXLPG2.js → chunk-GYQR4B4P.js}

@@ -2,12 +2,13 @@ import {
   SparkServiceDefinition
 } from "./chunk-ABZA6R5S.js";
 import {
+  clientEnv,
   isBun,
   isReactNative
-} from "./chunk-HKAKEKCE.js";
+} from "./chunk-VFJQNBFX.js";
 import {
   NetworkError
-} from "./chunk-TWF35O6M.js";
+} from "./chunk-GSI4OLXZ.js";
 
 // src/services/lrc-connection.ts
 import { isNode } from "@lightsparkdev/core";
@@ -101,7 +102,7 @@ var Lrc20ConnectionManager = class {
     return async function* (call, options) {
       return yield* call.next(call.request, {
         ...options,
-        metadata: Metadata(options.metadata).set("User-Agent", "spark-js-sdk")
+        metadata: Metadata(options.metadata).set("X-Client-Env", clientEnv)
       });
     }.bind(this);
   }
@@ -109,7 +110,7 @@ var Lrc20ConnectionManager = class {
     return async function* (call, options) {
       return yield* call.next(call.request, {
         ...options,
-        metadata: Metadata(options.metadata).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(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto").set("X-Client-Env", clientEnv)
       });
     }.bind(this);
   }

package/dist/{chunk-ROKY5KS4.js → chunk-HRQRRDSS.js}

@@ -2,17 +2,18 @@ import {
   SparkTokenServiceDefinition
 } from "./chunk-VA7MV4MZ.js";
 import {
+  Empty,
+  SparkServiceDefinition
+} from "./chunk-M6A4KFIG.js";
+import {
+  clientEnv,
   isBun,
   isReactNative
-} from "./chunk-HKAKEKCE.js";
+} from "./chunk-VFJQNBFX.js";
 import {
   AuthenticationError,
   NetworkError
-} from "./chunk-TWF35O6M.js";
-import {
-  Empty,
-  SparkServiceDefinition
-} from "./chunk-M6A4KFIG.js";
+} from "./chunk-GSI4OLXZ.js";
 
 // src/services/connection.ts
 import { isNode } from "@lightsparkdev/core";
@@ -969,12 +970,36 @@ var ConnectionManager = class {
   }
   async createSparkAuthnGrpcConnection(address, certPath) {
     const channel = await this.createChannelWithTLS(address, certPath);
+    const authnMiddleware = this.createAuthnMiddleware();
     return this.createGrpcClient(
       SparkAuthnServiceDefinition,
       channel,
-      false
+      false,
+      authnMiddleware
     );
   }
+  createAuthnMiddleware() {
+    if (isNode) {
+      return async function* (call, options) {
+        const metadata = 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 = 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(address, authToken) {
     if (isNode) {
       return this.createNodeMiddleware(address, authToken);
@@ -984,21 +1009,29 @@ var ConnectionManager = class {
   }
   createNodeMiddleware(address, initialAuthToken) {
     return async function* (call, options) {
+      const metadata = Metadata(options.metadata).set(
+        "X-Client-Env",
+        clientEnv
+      );
       try {
         return yield* call.next(call.request, {
           ...options,
-          metadata: Metadata(options.metadata).set(
+          metadata: metadata.set(
             "Authorization",
             `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`
-          ).set("User-Agent", "spark-js-sdk")
+          )
         });
       } catch (error) {
         if (error.message?.includes("token has expired")) {
           const newAuthToken = await this.authenticate(address);
-          this.clients.get(address).authToken = newAuthToken;
+          const clientData = this.clients.get(address);
+          if (!clientData) {
+            throw new Error(`No client found for address: ${address}`);
+          }
+          clientData.authToken = newAuthToken;
           return yield* call.next(call.request, {
             ...options,
-            metadata: Metadata(options.metadata).set("Authorization", `Bearer ${newAuthToken}`).set("User-Agent", "spark-js-sdk")
+            metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`)
           });
         }
         throw error;
@@ -1007,21 +1040,26 @@ var ConnectionManager = class {
   }
   createBrowserMiddleware(address, initialAuthToken) {
     return async function* (call, options) {
+      const metadata = 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: Metadata(options.metadata).set(
+          metadata: metadata.set(
             "Authorization",
             `Bearer ${this.clients.get(address)?.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(address);
-          this.clients.get(address).authToken = newAuthToken;
+          const clientData = this.clients.get(address);
+          if (!clientData) {
+            throw new Error(`No client found for address: ${address}`);
+          }
+          clientData.authToken = newAuthToken;
           return yield* call.next(call.request, {
             ...options,
-            metadata: 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;

package/dist/{chunk-YEZDPUFY.js → chunk-IRW5TWMH.js}

@@ -1,23 +1,23 @@
+import {
+  encodeSparkAddress
+} from "./chunk-O4RYNJNB.js";
 import {
   getNetwork,
   getNetworkFromAddress
-} from "./chunk-HK6LPV6Z.js";
+} from "./chunk-Z5HIAYFT.js";
 import {
   ELECTRS_CREDENTIALS,
   getElectrsUrl
-} from "./chunk-7EFSUADA.js";
+} from "./chunk-DOA6QXYQ.js";
 import {
   BitcoinNetwork_default
 } from "./chunk-HMLOC6TE.js";
-import {
-  encodeSparkAddress
-} from "./chunk-TM4TOEOX.js";
-import {
-  ValidationError
-} from "./chunk-TWF35O6M.js";
 import {
   TreeNode
 } from "./chunk-M6A4KFIG.js";
+import {
+  ValidationError
+} from "./chunk-GSI4OLXZ.js";
 import {
   Buffer
 } from "./chunk-MVRQ5US7.js";

package/dist/{chunk-7VMYMQLF.js → chunk-NSJF5F5O.js}

@@ -1,6 +1,6 @@
 import {
   ValidationError
-} from "./chunk-TWF35O6M.js";
+} from "./chunk-GSI4OLXZ.js";
 
 // src/utils/adaptor-signature.ts
 import { mod } from "@noble/curves/abstract/modular";

package/dist/{chunk-TM4TOEOX.js → chunk-O4RYNJNB.js}

@@ -1,9 +1,9 @@
-import {
-  ValidationError
-} from "./chunk-TWF35O6M.js";
 import {
   SparkAddress
 } from "./chunk-M6A4KFIG.js";
+import {
+  ValidationError
+} from "./chunk-GSI4OLXZ.js";
 
 // src/address/address.ts
 import { secp256k1 } from "@noble/curves/secp256k1";

package/dist/{chunk-MGPRLH6Q.js → chunk-QNNSEJ4P.js}

@@ -1,6 +1,6 @@
 import {
   ValidationError
-} from "./chunk-TWF35O6M.js";
+} from "./chunk-GSI4OLXZ.js";
 
 // src/utils/secret-sharing.ts
 import { bytesToHex, equalBytes } from "@noble/curves/abstract/utils";

package/dist/{chunk-UKT6OFLO.js → chunk-TIUBYNN5.js}

@@ -1,19 +1,19 @@
+import {
+  isReactNative
+} from "./chunk-VFJQNBFX.js";
 import {
   generateAdaptorFromSignature,
   getRandomSigningNonce,
   getSigningCommitmentFromNonce,
   subtractPrivateKeys
-} from "./chunk-7VMYMQLF.js";
-import {
-  isReactNative
-} from "./chunk-HKAKEKCE.js";
+} from "./chunk-NSJF5F5O.js";
 import {
   splitSecretWithProofs
-} from "./chunk-MGPRLH6Q.js";
+} from "./chunk-QNNSEJ4P.js";
 import {
   ConfigurationError,
   ValidationError
-} from "./chunk-TWF35O6M.js";
+} from "./chunk-GSI4OLXZ.js";
 import {
   Buffer
 } from "./chunk-MVRQ5US7.js";
@@ -38,6 +38,8 @@ import {
 } from "@buildonspark/lrc20-sdk";
 import { sha256 } from "@noble/hashes/sha2";
 import { taprootTweakPrivKey } from "@scure/btc-signer/utils";
+import { Receipt as Receipt2, PARITY as PARITY2, fromPrivateKey as fromPrivateKey2 } from "@buildonspark/lrc20-sdk";
+import { MultisigReceiptInput } from "@buildonspark/lrc20-sdk/lrc/types";
 var sparkFrostModule = void 0;
 var getSparkFrostModule = async () => {
   if (isReactNative) {
@@ -612,5 +614,9 @@ var TaprootSparkSigner = class extends DefaultSparkSigner {
 export {
   TaprootOutputKeysGenerator,
   DefaultSparkSigner,
-  TaprootSparkSigner
+  TaprootSparkSigner,
+  Receipt2 as Receipt,
+  PARITY2 as PARITY,
+  fromPrivateKey2 as fromPrivateKey,
+  MultisigReceiptInput
 };