signet.js 0.3.0 → 0.3.1-beta.1

package/dist/index.cjs

@@ -177,7 +177,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 = "";
@@ -262,7 +262,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,
@@ -1391,7 +1391,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 (0, viem.keccak256)((0, viem.encodeAbiParameters)([
 		{ type: "address" },
 		{ type: "bytes" },
@@ -1598,7 +1630,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,
@@ -1652,6 +1684,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 = {
@@ -2765,17 +2798,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 (0, viem.keccak256)((0, viem.encodeAbiParameters)((0, viem.parseAbiParameters)("string, bytes, string, uint32, string, string, string, string"), [
-		address$1,
+		request.address,
 		payloadHex,
-		path,
-		keyVersion,
-		chainId,
-		algo,
-		dest,
-		params
+		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 (0, viem.keccak256)((0, viem.encodePacked)([
+		"string",
+		"bytes",
+		"string",
+		"uint32",
+		"string",
+		"string",
+		"string",
+		"string"
+	], [
+		request.sender,
+		payloadHex,
+		request.caip2Id,
+		request.keyVersion,
+		request.path,
+		request.algo,
+		request.dest,
+		request.params
 	]));
 }
 
@@ -3081,7 +3200,7 @@ var ChainSignatureContract$1 = class extends ChainSignatureContract {
 		dest: "",
 		params: ""
 	}) {
-		return generateRequestIdSolana({
+		return getRequestIdRespond({
 			payload: args.payload,
 			path: args.path,
 			keyVersion: args.key_version,
@@ -3098,6 +3217,8 @@ var ChainSignatureContract$1 = class extends ChainSignatureContract {
 //#region src/contracts/solana/index.ts
 var solana_exports = /* @__PURE__ */ __export({
 	ChainSignatureContract: () => ChainSignatureContract$1,
+	getRequestIdBidirectional: () => getRequestIdBidirectional,
+	getRequestIdRespond: () => getRequestIdRespond,
 	utils: () => utils
 });
 const utils = {

package/dist/index.d.cts

@@ -158,7 +158,7 @@ declare const najToUncompressedPubKeySEC1: (najPublicKey: NajPublicKey) => Uncom
  * @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)
  */
-declare function deriveChildPublicKey(rootUncompressedPubKeySEC1: UncompressedPubKeySEC1, predecessorId: string, path: string | undefined, chainId: string, keyVersion: number): UncompressedPubKeySEC1;
+declare function deriveChildPublicKey(rootUncompressedPubKeySEC1: UncompressedPubKeySEC1, predecessorId: string, path: string | undefined, chainId: string, _keyVersion: number): UncompressedPubKeySEC1;
 /**
  * Verifies that a secp256k1 signature was created by the expected derived address
  * by recovering the signing address and comparing it with the address derived from the contract.
@@ -771,6 +771,16 @@ interface SignatureErrorData {
   requestId: string;
   error: string;
 }
+interface RequestIdArgs {
+  address: Address;
+  payload: Hex;
+  path: string;
+  keyVersion: number;
+  chainId: bigint;
+  algo: string;
+  dest: string;
+  params: string;
+}
 //#endregion
 //#region src/contracts/evm/ChainSignaturesContract.d.ts
 /**
@@ -882,8 +892,43 @@ declare class ChainSignatureContract$2 extends ChainSignatureContract {
    */
   getSignatureFromEvents(requestId: Hex, fromBlock: bigint): Promise<RSVSignature | undefined>;
 }
+//#endregion
+//#region src/contracts/evm/utils.d.ts
+/**
+ * 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: '',
+ * })
+ * ```
+ */
+declare const getRequestIdRespond$1: (request: RequestIdArgs) => `0x${string}`;
 declare namespace index_d_exports$3 {
-  export { ChainSignatureContract$2 as ChainSignatureContract, utils$1 as utils };
+  export { ChainSignatureContract$2 as ChainSignatureContract, RequestIdArgs, getRequestIdRespond$1 as getRequestIdRespond, utils$1 as utils };
 }
 declare const utils$1: {
   ChainSignaturesContractABI: typeof ChainSignaturesContractABI_d_exports;
@@ -1640,8 +1685,96 @@ declare class ChainSignatureContract$1 extends ChainSignatureContract {
    */
   getRequestId(args: SignArgs, options?: SignOptions['sign']): string;
 }
+//#endregion
+//#region src/contracts/solana/utils.d.ts
+interface SolanaRequestIdArgs {
+  address: string;
+  payload: Uint8Array | number[];
+  path: string;
+  keyVersion: number;
+  chainId: string;
+  algo: string;
+  dest: string;
+  params: string;
+}
+interface SolanaBidirectionalRequestIdArgs {
+  sender: string;
+  payload: Uint8Array | number[];
+  caip2Id: string;
+  keyVersion: number;
+  path: string;
+  algo: string;
+  dest: string;
+  params: string;
+}
+/**
+ * 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: '',
+ * })
+ * ```
+ */
+declare function getRequestIdRespond(request: SolanaRequestIdArgs): string;
+/**
+ * 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: '',
+ * })
+ * ```
+ */
+declare function getRequestIdBidirectional(request: SolanaBidirectionalRequestIdArgs): string;
 declare namespace index_d_exports$4 {
-  export { ChainSignatureContract$1 as ChainSignatureContract, ChainSignaturesProject, utils };
+  export { ChainSignatureContract$1 as ChainSignatureContract, ChainSignaturesProject, SolanaBidirectionalRequestIdArgs, SolanaRequestIdArgs, getRequestIdBidirectional, getRequestIdRespond, utils };
 }
 declare const utils: {
   ChainSignaturesContractIdl: {

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import * as bitcoin from "bitcoinjs-lib";
 import { EncodeObject } from "@cosmjs/proto-signing";
 import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx.js";
 import BN from "bn.js";
+import "viem/chains";
 import { AnchorProvider, Idl } from "@coral-xyz/anchor";
 import { AccountMeta, Connection, PublicKey, Signer, TransactionInstruction } from "@solana/web3.js";
 
@@ -156,7 +157,7 @@ declare const najToUncompressedPubKeySEC1: (najPublicKey: NajPublicKey) => Uncom
  * @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)
  */
-declare function deriveChildPublicKey(rootUncompressedPubKeySEC1: UncompressedPubKeySEC1, predecessorId: string, path: string | undefined, chainId: string, keyVersion: number): UncompressedPubKeySEC1;
+declare function deriveChildPublicKey(rootUncompressedPubKeySEC1: UncompressedPubKeySEC1, predecessorId: string, path: string | undefined, chainId: string, _keyVersion: number): UncompressedPubKeySEC1;
 /**
  * Verifies that a secp256k1 signature was created by the expected derived address
  * by recovering the signing address and comparing it with the address derived from the contract.
@@ -769,6 +770,16 @@ interface SignatureErrorData {
   requestId: string;
   error: string;
 }
+interface RequestIdArgs {
+  address: Address;
+  payload: Hex;
+  path: string;
+  keyVersion: number;
+  chainId: bigint;
+  algo: string;
+  dest: string;
+  params: string;
+}
 //#endregion
 //#region src/contracts/evm/ChainSignaturesContract.d.ts
 /**
@@ -880,8 +891,43 @@ declare class ChainSignatureContract$2 extends ChainSignatureContract {
    */
   getSignatureFromEvents(requestId: Hex, fromBlock: bigint): Promise<RSVSignature | undefined>;
 }
+//#endregion
+//#region src/contracts/evm/utils.d.ts
+/**
+ * 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: '',
+ * })
+ * ```
+ */
+declare const getRequestIdRespond$1: (request: RequestIdArgs) => `0x${string}`;
 declare namespace index_d_exports$3 {
-  export { ChainSignatureContract$2 as ChainSignatureContract, utils$1 as utils };
+  export { ChainSignatureContract$2 as ChainSignatureContract, RequestIdArgs, getRequestIdRespond$1 as getRequestIdRespond, utils$1 as utils };
 }
 declare const utils$1: {
   ChainSignaturesContractABI: typeof ChainSignaturesContractABI_d_exports;
@@ -1638,8 +1684,96 @@ declare class ChainSignatureContract$1 extends ChainSignatureContract {
    */
   getRequestId(args: SignArgs, options?: SignOptions['sign']): string;
 }
+//#endregion
+//#region src/contracts/solana/utils.d.ts
+interface SolanaRequestIdArgs {
+  address: string;
+  payload: Uint8Array | number[];
+  path: string;
+  keyVersion: number;
+  chainId: string;
+  algo: string;
+  dest: string;
+  params: string;
+}
+interface SolanaBidirectionalRequestIdArgs {
+  sender: string;
+  payload: Uint8Array | number[];
+  caip2Id: string;
+  keyVersion: number;
+  path: string;
+  algo: string;
+  dest: string;
+  params: string;
+}
+/**
+ * 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: '',
+ * })
+ * ```
+ */
+declare function getRequestIdRespond(request: SolanaRequestIdArgs): string;
+/**
+ * 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: '',
+ * })
+ * ```
+ */
+declare function getRequestIdBidirectional(request: SolanaBidirectionalRequestIdArgs): string;
 declare namespace index_d_exports$4 {
-  export { ChainSignatureContract$1 as ChainSignatureContract, ChainSignaturesProject, utils };
+  export { ChainSignatureContract$1 as ChainSignatureContract, ChainSignaturesProject, SolanaBidirectionalRequestIdArgs, SolanaRequestIdArgs, getRequestIdBidirectional, getRequestIdRespond, utils };
 }
 declare const utils: {
   ChainSignaturesContractIdl: {

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 = {
@@ -2722,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,
-		path,
-		keyVersion,
-		chainId,
-		algo,
-		dest,
-		params
+		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,
+		request.caip2Id,
+		request.keyVersion,
+		request.path,
+		request.algo,
+		request.dest,
+		request.params
 	]));
 }
 
@@ -3038,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,
@@ -3055,6 +3174,8 @@ var ChainSignatureContract$1 = class extends ChainSignatureContract {
 //#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.3.0",
+  "version": "0.3.1-beta.1",
   "description": "A TypeScript library for handling multi-chain transactions and signatures using Signet MPC",
   "type": "module",
   "exports": {
@@ -61,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",