signet.js 0.2.0 → 0.3.1-beta.1

package/dist/index.js

@@ -1,7 +1,7 @@
 import { t as __export } from "./chunk-BAz01cYq.js";
 import { base58 } from "@scure/base";
 import elliptic from "elliptic";
-import { concat, concatHex, createPublicClient, encodeAbiParameters, encodeFunctionData, getAddress, hashMessage, hashTypedData, hexToBigInt, http, isAddress, keccak256, numberToHex, pad, parseAbiParameters, parseTransaction, recoverAddress, serializeTransaction, toBytes, withRetry } from "viem";
+import { concat, concatHex, createPublicClient, encodeAbiParameters, encodeFunctionData, encodePacked, getAddress, hashMessage, hashTypedData, hexToBigInt, http, isAddress, keccak256, numberToHex, pad, parseAbiParameters, parseTransaction, recoverAddress, serializeTransaction, toBytes, withRetry } from "viem";
 import * as bitcoin from "bitcoinjs-lib";
 import coinselect from "coinselect";
 import { encodeSecp256k1Pubkey } from "@cosmjs/amino";
@@ -134,7 +134,7 @@ const EPSILON_DERIVATION_PREFIX_V2 = "sig.network v2.0.0 epsilon derivation";
 * @param keyVersion - Key version controlling which derivation prefix to use (legacy v1 for 0, CAIP-2 v2 otherwise)
 * @returns The derived child public key in uncompressed SEC1 format (04 || x || y)
 */
-function deriveChildPublicKey(rootUncompressedPubKeySEC1, predecessorId, path = "", chainId, keyVersion) {
+function deriveChildPublicKey(rootUncompressedPubKeySEC1, predecessorId, path = "", chainId, _keyVersion) {
 	const ec = new EC("secp256k1");
 	const derivationPath = `${EPSILON_DERIVATION_PREFIX_V2}:${chainId}:${predecessorId}:${path}`;
 	let scalarHex = "";
@@ -219,7 +219,7 @@ var EVM = class extends ChainAdapter {
 	async attachGasAndNonce(transaction) {
 		const fees = await fetchEVMFeeProperties(this.client, transaction);
 		const nonce = await this.client.getTransactionCount({ address: transaction.from });
-		const { from, ...rest } = transaction;
+		const { from: _from, ...rest } = transaction;
 		return {
 			...fees,
 			nonce,
@@ -1348,7 +1348,39 @@ const getRootPublicKey = (contractAddress, chain) => {
 
 //#endregion
 //#region src/contracts/evm/utils.ts
-const getRequestId = (request) => {
+/**
+* Generates a unique request ID for EVM signature requests using keccak256 hashing.
+*
+* The request ID is computed by ABI-encoding the request parameters and hashing
+* the result. This ID is used to track signature requests and match them with
+* responses from the MPC network.
+*
+* @param request - The signature request parameters
+* @param request.address - The address of the requester (EVM address format)
+* @param request.payload - The data payload to be signed as a hex string
+* @param request.path - The derivation path for the signing key
+* @param request.keyVersion - The version of the signing key
+* @param request.chainId - The chain ID where the request originated
+* @param request.algo - The signing algorithm identifier
+* @param request.dest - The destination identifier for the signature
+* @param request.params - Additional parameters for the signing process
+* @returns The keccak256 hash of the encoded request as a hex string
+*
+* @example
+* ```typescript
+* const requestId = getRequestIdRespond({
+*   address: '0x1234...abcd',
+*   payload: '0xdeadbeef',
+*   path: 'ethereum,1',
+*   keyVersion: 0,
+*   chainId: 1n,
+*   algo: '',
+*   dest: '',
+*   params: '',
+* })
+* ```
+*/
+const getRequestIdRespond$1 = (request) => {
 	return keccak256(encodeAbiParameters([
 		{ type: "address" },
 		{ type: "bytes" },
@@ -1555,7 +1587,7 @@ var ChainSignatureContract$2 = class extends ChainSignatureContract {
 	}) {
 		if (!this.walletClient.account) throw new Error("Wallet client account required to compute requestId");
 		if (!this.publicClient.chain?.id) throw new Error("Public client chain required to compute requestId");
-		return getRequestId({
+		return getRequestIdRespond$1({
 			payload: `0x${Buffer.from(args.payload).toString("hex")}`,
 			path: args.path,
 			keyVersion: args.key_version,
@@ -1609,6 +1641,7 @@ var ChainSignatureContract$2 = class extends ChainSignatureContract {
 //#region src/contracts/evm/index.ts
 var evm_exports = /* @__PURE__ */ __export({
 	ChainSignatureContract: () => ChainSignatureContract$2,
+	getRequestIdRespond: () => getRequestIdRespond$1,
 	utils: () => utils$1
 });
 const utils$1 = {
@@ -2652,24 +2685,33 @@ const EMIT_CPI_INSTRUCTION_DISCRIMINATOR = Buffer.from([
 ]);
 var CpiEventParser = class {
 	/**
-	* Parse CPI events from a transaction (emit_cpi! pattern)
+	* Parse CPI events from an already-fetched transaction (emit_cpi! pattern).
 	*/
-	static async parseCpiEvents(connection, signature, targetProgramId, program) {
+	static parseCpiEventsFromTransaction(tx, targetProgramId, program) {
 		const events$1 = [];
+		if (!tx?.meta?.innerInstructions) return events$1;
+		for (const innerIxSet of tx.meta.innerInstructions) for (const instruction of innerIxSet.instructions) {
+			if (!("programId" in instruction) || !("data" in instruction)) continue;
+			if (instruction.programId.toString() !== targetProgramId) continue;
+			const parsedEvent = this.parseInstruction(instruction.data, program);
+			if (parsedEvent) events$1.push(parsedEvent);
+		}
+		return events$1;
+	}
+	/**
+	* Fetch a transaction by signature and parse its CPI events.
+	* Used by the subscription path where only the signature is available.
+	*/
+	static async fetchAndParseCpiEvents(connection, signature, targetProgramId, program) {
 		try {
 			const tx = await connection.getParsedTransaction(signature, {
 				commitment: "confirmed",
 				maxSupportedTransactionVersion: 0
 			});
-			if (!tx?.meta?.innerInstructions) return events$1;
-			for (const innerIxSet of tx.meta.innerInstructions) for (const instruction of innerIxSet.instructions) {
-				if (!("programId" in instruction) || !("data" in instruction)) continue;
-				if (instruction.programId.toString() !== targetProgramId) continue;
-				const parsedEvent = this.parseInstruction(instruction.data, program);
-				if (parsedEvent) events$1.push(parsedEvent);
-			}
-		} catch {}
-		return events$1;
+			return this.parseCpiEventsFromTransaction(tx, targetProgramId, program);
+		} catch {
+			return [];
+		}
 	}
 	/**
 	* Parse CPI event from instruction data
@@ -2699,7 +2741,7 @@ var CpiEventParser = class {
 		return connection.onLogs(program.programId, (logs, context) => {
 			if (logs.err) return;
 			(async () => {
-				const events$1 = await this.parseCpiEvents(connection, logs.signature, program.programId.toString(), program);
+				const events$1 = await this.fetchAndParseCpiEvents(connection, logs.signature, program.programId.toString(), program);
 				for (const event of events$1) {
 					const handler = eventHandlers.get(event.name);
 					if (handler) try {
@@ -2713,17 +2755,103 @@ var CpiEventParser = class {
 
 //#endregion
 //#region src/contracts/solana/utils.ts
-function generateRequestIdSolana({ address: address$1, payload, path, keyVersion, chainId, algo, dest, params }) {
-	const payloadHex = "0x" + Buffer.from(payload).toString("hex");
+/**
+* Generates a unique request ID for Solana signature requests using keccak256 hashing.
+*
+* The request ID is computed by ABI-encoding the request parameters and hashing
+* the result. This ID is used to track signature requests and match them with
+* responses from the MPC network.
+*
+* @param request - The signature request parameters
+* @param request.address - The sender's address (Solana public key as string)
+* @param request.payload - The data payload to be signed
+* @param request.path - The derivation path for the signing key
+* @param request.keyVersion - The version of the signing key
+* @param request.chainId - The CAIP-2 chain identifier (e.g., 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
+* @param request.algo - The signing algorithm identifier
+* @param request.dest - The destination identifier for the signature
+* @param request.params - Additional parameters for the signing process
+* @returns The keccak256 hash of the encoded request as a hex string
+*
+* @example
+* ```typescript
+* const requestId = getRequestIdRespond({
+*   address: 'So11111111111111111111111111111111111111112',
+*   payload: new Uint8Array([1, 2, 3, 4]),
+*   path: 'solana,1',
+*   keyVersion: 0,
+*   chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+*   algo: '',
+*   dest: '',
+*   params: '',
+* })
+* ```
+*/
+function getRequestIdRespond(request) {
+	const payloadHex = "0x" + Buffer.from(request.payload).toString("hex");
 	return keccak256(encodeAbiParameters(parseAbiParameters("string, bytes, string, uint32, string, string, string, string"), [
-		address$1,
+		request.address,
+		payloadHex,
+		request.path,
+		request.keyVersion,
+		request.chainId,
+		request.algo,
+		request.dest,
+		request.params
+	]));
+}
+/**
+* Generates a unique request ID for bidirectional sign operations using keccak256 hashing.
+*
+* Unlike `getRequestIdRespond`, this function uses packed encoding (solidityPacked)
+* instead of standard ABI encoding. This is used for cross-chain bidirectional
+* signing flows where the request originates from a different chain.
+*
+* @param request - The bidirectional signature request parameters
+* @param request.sender - The sender's address (Solana public key as string)
+* @param request.payload - The data payload to be signed
+* @param request.caip2Id - The CAIP-2 chain identifier (e.g., 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
+* @param request.keyVersion - The version of the signing key
+* @param request.path - The derivation path for the signing key
+* @param request.algo - The signing algorithm identifier
+* @param request.dest - The destination identifier for the signature
+* @param request.params - Additional parameters for the signing process
+* @returns The keccak256 hash of the packed encoded request as a hex string
+*
+* @example
+* ```typescript
+* const requestId = getRequestIdBidirectional({
+*   sender: 'So11111111111111111111111111111111111111112',
+*   payload: new Uint8Array([1, 2, 3, 4]),
+*   caip2Id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+*   keyVersion: 0,
+*   path: 'ethereum,1',
+*   algo: '',
+*   dest: '',
+*   params: '',
+* })
+* ```
+*/
+function getRequestIdBidirectional(request) {
+	const payloadHex = `0x${Buffer.from(request.payload).toString("hex")}`;
+	return keccak256(encodePacked([
+		"string",
+		"bytes",
+		"string",
+		"uint32",
+		"string",
+		"string",
+		"string",
+		"string"
+	], [
+		request.sender,
 		payloadHex,
-		path,
-		keyVersion,
-		chainId,
-		algo,
-		dest,
-		params
+		request.caip2Id,
+		request.keyVersion,
+		request.path,
+		request.algo,
+		request.dest,
+		request.params
 	]));
 }
 
@@ -2799,15 +2927,15 @@ var ChainSignatureContract$1 = class extends ChainSignatureContract {
 	}
 	/**
 	* Sends a transaction to the program to request a signature, then
-	* polls for the signature result. If the signature is not found within the retry
-	* parameters, it will throw an error.
+	* races a WebSocket listener against polling backfill to find the result.
+	* If the signature is not found within the timeout, it will throw an error.
 	*/
 	async sign(args, options) {
 		const algo = options?.sign?.algo ?? "";
 		const dest = options?.sign?.dest ?? "";
 		const params = options?.sign?.params ?? "";
 		const delay = options?.retry?.delay ?? 5e3;
-		const retryCount = options?.retry?.retryCount ?? 12;
+		const timeoutMs = delay * (options?.retry?.retryCount ?? 12);
 		if (options?.remainingAccounts?.filter((acc) => acc.isSigner)?.some((acc) => !options?.remainingSigners?.some((signer) => signer.publicKey.equals(acc.pubkey)))) throw new Error("All accounts marked as signers must have a corresponding signer");
 		const requestId = this.getRequestId(args, {
 			algo,
@@ -2825,24 +2953,38 @@ var ChainSignatureContract$1 = class extends ChainSignatureContract {
 		const transaction = new Transaction().add(instruction);
 		transaction.feePayer = this.provider.wallet.publicKey;
 		const hash = await this.sendAndConfirmWithoutWebSocket(transaction, options?.remainingSigners);
+		const controller = new AbortController();
+		const successPromise = this.waitForEvent({
+			eventName: "signatureRespondedEvent",
+			requestId,
+			signer: this.programId,
+			afterSignature: hash,
+			timeoutMs,
+			backfillIntervalMs: delay,
+			signal: controller.signal
+		});
+		const errorPromise = this.waitForEvent({
+			eventName: "signatureErrorEvent",
+			requestId,
+			signer: this.programId,
+			afterSignature: hash,
+			timeoutMs,
+			backfillIntervalMs: delay,
+			signal: controller.signal
+		}).then((err) => {
+			throw new SignatureContractError(err.error, requestId, { hash });
+		});
+		successPromise.catch(() => {});
+		errorPromise.catch(() => {});
 		try {
-			const pollResult = await this.pollForRequestId({
-				requestId,
-				payload: args.payload,
-				path: args.path,
-				afterSignature: hash,
-				options: {
-					delay,
-					retryCount
-				}
-			});
-			if (!pollResult) throw new SignatureNotFoundError(requestId, { hash });
-			if ("error" in pollResult) throw new SignatureContractError(pollResult.error, requestId, { hash });
-			if (!await verifyRecoveredAddress(pollResult, args.payload, this.requesterAddress, args.path, this, args.key_version)) throw new SigningError(requestId, { hash }, /* @__PURE__ */ new Error("Signature verification failed: recovered address does not match expected address"));
-			return pollResult;
+			const result = await Promise.race([successPromise, errorPromise]);
+			if (!await verifyRecoveredAddress(result, args.payload, this.requesterAddress, args.path, this, args.key_version)) throw new SigningError(requestId, { hash }, /* @__PURE__ */ new Error("Signature verification failed: recovered address does not match expected address"));
+			return result;
 		} catch (error) {
 			if (error instanceof SignatureNotFoundError || error instanceof SignatureContractError) throw error;
 			else throw new SigningError(requestId, { hash }, error instanceof Error ? error : void 0);
+		} finally {
+			controller.abort();
 		}
 	}
 	async sendAndConfirmWithoutWebSocket(transaction, signers) {
@@ -2866,70 +3008,147 @@ var ChainSignatureContract$1 = class extends ChainSignatureContract {
 		throw new TransactionExpiredTimeoutError(signature, timeout / 1e3);
 	}
 	/**
-	* Polls for signature or error events matching the given requestId starting from the solana transaction with signature afterSignature.
-	* Returns a signature, error data, or undefined if nothing is found.
+	* Waits for a specific event matching the given requestId by combining
+	* a WebSocket listener (real-time) with polling backfill (resilience).
 	*/
-	async pollForRequestId({ requestId, payload: _payload, path: _path, afterSignature, options }) {
-		const delay = options?.delay ?? 5e3;
-		const retryCount = options?.retryCount ?? 12;
-		let lastCheckedSignature = afterSignature;
-		for (let i = 0; i < retryCount; i++) {
-			try {
-				const signatures = await this.connection.getSignaturesForAddress(this.programId, {
-					until: lastCheckedSignature,
-					limit: 50
-				}, "confirmed");
-				if (signatures.length > 0) lastCheckedSignature = signatures[signatures.length - 1].signature;
-				for (const sig of signatures) {
-					const tx = await this.connection.getParsedTransaction(sig.signature, {
-						commitment: "confirmed",
-						maxSupportedTransactionVersion: 0
+	async waitForEvent(options) {
+		const { eventName, requestId, signer, afterSignature, timeoutMs = 6e4, backfillIntervalMs = 5e3, backfillLimit = 50, signal } = options;
+		return await new Promise((resolve, reject) => {
+			let settled = false;
+			const seenSignatures = /* @__PURE__ */ new Set();
+			let lastCheckedSignature = afterSignature;
+			const cleanupFns = [];
+			const cleanup = () => {
+				for (const fn of cleanupFns) try {
+					fn();
+				} catch {}
+			};
+			const settle = (action) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				action();
+			};
+			const processEvent = (name, data, txSignature) => {
+				if (settled) return false;
+				if (txSignature && seenSignatures.has(txSignature)) return false;
+				if (txSignature) seenSignatures.add(txSignature);
+				if (name !== eventName) return false;
+				const result = this.mapEventForName(eventName, data, requestId);
+				if (result !== void 0) {
+					settle(() => {
+						resolve(result);
 					});
-					if (tx?.meta?.logMessages) {
-						const result = await this.parseLogsForEvents(tx.meta.logMessages, requestId, sig.signature);
-						if (result) return result;
-					}
+					return true;
 				}
-			} catch (error) {
-				console.error("Error checking for events:", error);
-			}
-			if (i < retryCount - 1) {
-				console.log(`Retrying get signature: ${i + 1}/${retryCount}`);
-				await new Promise((resolve) => setTimeout(resolve, delay));
+				return false;
+			};
+			if (signal) {
+				if (signal.aborted) {
+					settle(() => {
+						reject(signal.reason ?? /* @__PURE__ */ new Error("Aborted"));
+					});
+					return;
+				}
+				const onAbort = () => {
+					settle(() => {
+						reject(signal.reason ?? /* @__PURE__ */ new Error("Aborted"));
+					});
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				cleanupFns.push(() => {
+					signal.removeEventListener("abort", onAbort);
+				});
 			}
-		}
+			const timeoutId = setTimeout(() => {
+				settle(() => {
+					reject(new SignatureNotFoundError(requestId));
+				});
+			}, timeoutMs);
+			cleanupFns.push(() => {
+				clearTimeout(timeoutId);
+			});
+			const parser = new EventParser(this.program.programId, this.program.coder);
+			const subId = this.connection.onLogs(signer, (logs, _context) => {
+				if (settled) return;
+				if (logs.err) return;
+				for (const evt of parser.parseLogs(logs.logs)) {
+					if (!evt) continue;
+					if (processEvent(evt.name, evt.data, logs.signature)) return;
+				}
+				CpiEventParser.fetchAndParseCpiEvents(this.connection, logs.signature, this.programId.toString(), this.program).then((cpiEvents) => {
+					for (const event of cpiEvents) if (processEvent(event.name, event.data, logs.signature)) return;
+				});
+			}, "confirmed");
+			cleanupFns.push(() => {
+				this.connection.removeOnLogsListener(subId);
+			});
+			const runBackfill = async () => {
+				if (settled) return;
+				try {
+					const signatures = await this.connection.getSignaturesForAddress(signer, {
+						until: lastCheckedSignature,
+						limit: backfillLimit
+					}, "confirmed");
+					if (signatures.length > 0) lastCheckedSignature = signatures[0].signature;
+					for (const sig of signatures) {
+						if (settled) return;
+						if (seenSignatures.has(sig.signature)) continue;
+						const tx = await this.connection.getParsedTransaction(sig.signature, {
+							commitment: "confirmed",
+							maxSupportedTransactionVersion: 0
+						});
+						if (!tx) continue;
+						const cpiEvents = CpiEventParser.parseCpiEventsFromTransaction(tx, this.programId.toString(), this.program);
+						for (const event of cpiEvents) if (processEvent(event.name, event.data, sig.signature)) return;
+						const logs = tx.meta?.logMessages;
+						if (logs) for (const evt of parser.parseLogs(logs)) {
+							if (!evt) continue;
+							if (processEvent(evt.name, evt.data, sig.signature)) return;
+						}
+					}
+				} catch {}
+			};
+			runBackfill();
+			const intervalId = setInterval(() => {
+				runBackfill();
+			}, backfillIntervalMs);
+			cleanupFns.push(() => {
+				clearInterval(intervalId);
+			});
+		});
 	}
-	/**
-	* Parses transaction logs for signature or error events.
-	*/
-	async parseLogsForEvents(logs, requestId, signature) {
-		const cpiEvents = await CpiEventParser.parseCpiEvents(this.connection, signature, this.programId.toString(), this.program);
-		for (const event of cpiEvents) {
-			const mapped = this.mapEventToResult(event.name, event.name === "signatureRespondedEvent" ? event.data : event.data, requestId);
-			if (mapped) return mapped;
-		}
-		const parser = new EventParser(this.program.programId, this.program.coder);
-		for (const evt of parser.parseLogs(logs)) {
-			if (!evt) continue;
-			const mapped = this.mapEventToResult(evt.name, evt.name === "signatureRespondedEvent" ? evt.data : evt.data, requestId);
-			if (mapped) return mapped;
-		}
+	mapRespondToResult(data, requestId) {
+		if ("0x" + Buffer.from(data.requestId).toString("hex") !== requestId) return void 0;
+		return {
+			r: Buffer.from(data.signature.bigR.x).toString("hex"),
+			s: Buffer.from(data.signature.s).toString("hex"),
+			v: data.signature.recoveryId + 27
+		};
 	}
-	mapEventToResult(name, data, requestId) {
+	mapRespondErrorToResult(data, requestId) {
 		const eventRequestIdHex = "0x" + Buffer.from(data.requestId).toString("hex");
-		if (name === "signatureRespondedEvent" && eventRequestIdHex === requestId) {
-			const d = data;
-			return {
-				r: Buffer.from(d.signature.bigR.x).toString("hex"),
-				s: Buffer.from(d.signature.s).toString("hex"),
-				v: d.signature.recoveryId + 27
-			};
-		}
-		if (name === "signatureErrorEvent" && eventRequestIdHex === requestId) return {
+		if (eventRequestIdHex !== requestId) return void 0;
+		return {
 			requestId: eventRequestIdHex,
 			error: data.error
 		};
 	}
+	mapRespondBidirectionalToResult(data, requestId) {
+		if ("0x" + Buffer.from(data.requestId).toString("hex") !== requestId) return void 0;
+		return {
+			serializedOutput: data.serializedOutput,
+			signature: data.signature
+		};
+	}
+	mapEventForName(eventName, data, requestId) {
+		switch (eventName) {
+			case "signatureRespondedEvent": return this.mapRespondToResult(data, requestId);
+			case "signatureErrorEvent": return this.mapRespondErrorToResult(data, requestId);
+			case "respondBidirectionalEvent": return this.mapRespondBidirectionalToResult(data, requestId);
+			default: return;
+		}
+	}
 	/**
 	* Generates the request ID for a signature request allowing to track the response.
 	*/
@@ -2938,7 +3157,7 @@ var ChainSignatureContract$1 = class extends ChainSignatureContract {
 		dest: "",
 		params: ""
 	}) {
-		return generateRequestIdSolana({
+		return getRequestIdRespond({
 			payload: args.payload,
 			path: args.path,
 			keyVersion: args.key_version,
@@ -2949,52 +3168,14 @@ var ChainSignatureContract$1 = class extends ChainSignatureContract {
 			chainId: KDF_CHAIN_IDS.SOLANA
 		});
 	}
-	/**
-	* Subscribes to program events using Anchor's EventParser for regular events,
-	* and CPI parsing for emit_cpi!-emitted events. Returns an unsubscribe fn.
-	*/
-	async subscribeToEvents(handlers) {
-		const commitment = "confirmed";
-		const cpiHandlers = /* @__PURE__ */ new Map();
-		if (handlers.onSignatureResponded) {
-			const onSignatureResponded = handlers.onSignatureResponded;
-			cpiHandlers.set("signatureRespondedEvent", async (e, s) => {
-				await onSignatureResponded(e, s);
-			});
-		}
-		if (handlers.onSignatureError) {
-			const onSignatureError = handlers.onSignatureError;
-			cpiHandlers.set("signatureErrorEvent", async (e, s) => {
-				await onSignatureError(e, s);
-			});
-		}
-		const cpiSubId = CpiEventParser.subscribeToCpiEvents(this.connection, this.program, cpiHandlers);
-		const parser = new EventParser(this.program.programId, this.program.coder);
-		const subId = this.connection.onLogs(this.program.programId, (logs, context) => {
-			if (logs.err) return;
-			for (const evt of parser.parseLogs(logs.logs)) {
-				if (!evt) continue;
-				if (evt.name === "signatureRespondedEvent") {
-					const onSignatureResponded = handlers.onSignatureResponded;
-					if (onSignatureResponded) onSignatureResponded(evt.data, context.slot);
-				}
-				if (evt.name === "signatureErrorEvent") {
-					const onSignatureError = handlers.onSignatureError;
-					if (onSignatureError) onSignatureError(evt.data, context.slot);
-				}
-			}
-		}, commitment);
-		return async () => {
-			await this.connection.removeOnLogsListener(subId);
-			await this.connection.removeOnLogsListener(cpiSubId);
-		};
-	}
 };
 
 //#endregion
 //#region src/contracts/solana/index.ts
 var solana_exports = /* @__PURE__ */ __export({
 	ChainSignatureContract: () => ChainSignatureContract$1,
+	getRequestIdBidirectional: () => getRequestIdBidirectional,
+	getRequestIdRespond: () => getRequestIdRespond,
 	utils: () => utils
 });
 const utils = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signet.js",
-  "version": "0.2.0",
+  "version": "0.3.1-beta.1",
   "description": "A TypeScript library for handling multi-chain transactions and signatures using Signet MPC",
   "type": "module",
   "exports": {
@@ -37,7 +37,9 @@
     "docs:dev": "vocs dev",
     "docs:build": "vocs build",
     "docs:preview": "vocs preview",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "lint": "eslint 'src/**/*.ts'",
+    "typecheck": "tsc --noEmit"
   },
   "author": "Sig Network",
   "license": "MIT",
@@ -59,28 +61,26 @@
     "@aa-sdk/core": "^4.13.0",
     "@account-kit/infra": "^4.13.0",
     "@account-kit/smart-contracts": "^4.13.0",
+    "@eslint/js": "^9.18.0",
     "@noble/curves": "^1.8.1",
     "@nomicfoundation/hardhat-toolbox": "^5.0.0",
     "@types/bn.js": "^5.1.5",
     "@types/elliptic": "^6.4.18",
     "@types/node": "^22.10.10",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "babel-jest": "^29.7.0",
+    "@types/react": "^19.0.0",
     "dotenv": "^16.4.5",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-config-standard-with-typescript": "^43.0.1",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-promise": "^6.1.1",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.0",
+    "eslint-plugin-import-x": "^4.6.0",
     "hardhat": "^2.22.18",
-    "jest": "^29.7.0",
-    "prettier": "^3.2.5",
+    "prettier": "^3.8.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
     "tsdown": "^0.16.6",
-    "typescript": "^5.4.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.21.0",
     "vitest": "^3.0.4",
-    "vocs": "1.0.0-alpha.62"
+    "vocs": "^1.4.1"
   },
   "dependencies": {
     "@coral-xyz/anchor": "^0.31.0",