@sig-net/signet.js 0.5.0-rc1

package/dist/index.js

@@ -0,0 +1,3167 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { base58, hex } from "@scure/base";
+import { bytesToHex, concatHex, createPublicClient, encodeAbiParameters, encodeFunctionData, encodePacked, getAddress, hashMessage, hashTypedData, http, keccak256, numberToHex, parseAbiParameters, parseTransaction, recoverAddress, serializeTransaction, toBytes, withRetry } from "viem";
+import * as bitcoin from "bitcoinjs-lib";
+import coinselect from "coinselect";
+import { encodeSecp256k1Pubkey } from "@cosmjs/amino";
+import { ripemd160, sha256 } from "@cosmjs/crypto";
+import { fromBase64, fromHex, toBase64, toBech32, toHex } from "@cosmjs/encoding";
+import { Registry, encodePubkey, makeAuthInfoBytes, makeSignBytes, makeSignDoc } from "@cosmjs/proto-signing";
+import { GasPrice, StargateClient, calculateFee } from "@cosmjs/stargate";
+import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
+import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { assetLists, chains } from "chain-registry";
+import "viem/chains";
+import * as anchor from "@coral-xyz/anchor";
+import { EventParser, Program } from "@coral-xyz/anchor";
+import { Connection, PublicKey, Transaction, TransactionExpiredTimeoutError } from "@solana/web3.js";
+//#region src/constants.ts
+var constants_exports = /* @__PURE__ */ __exportAll({
+	CHAINS: () => CHAINS,
+	CONTRACT_ADDRESSES: () => CONTRACT_ADDRESSES,
+	ENVS: () => ENVS,
+	KDF_CHAIN_IDS: () => KDF_CHAIN_IDS,
+	ROOT_PUBLIC_KEYS: () => ROOT_PUBLIC_KEYS
+});
+const ENVS = {
+	TESTNET_DEV: "TESTNET_DEV",
+	TESTNET: "TESTNET",
+	MAINNET: "MAINNET"
+};
+const CHAINS = {
+	ETHEREUM: "ETHEREUM",
+	SOLANA: "SOLANA",
+	CANTON: "CANTON"
+};
+/**
+* Root public keys for the Sig Network Smart Contracts across different environments.
+*
+* These keys should never change.
+*/
+const ROOT_PUBLIC_KEYS = {
+	[ENVS.TESTNET_DEV]: "secp256k1:54hU5wcCmVUPFWLDALXMh1fFToZsVXrx9BbTbHzSfQq1Kd1rJZi52iPa4QQxo6s5TgjWqgpY8HamYuUDzG6fAaUq",
+	[ENVS.TESTNET]: "secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5",
+	[ENVS.MAINNET]: "secp256k1:4tY4qMzusmgX5wYdG35663Y3Qar3CTbpApotwk9ZKLoF79XA4DjG8XoByaKdNHKQX9Lz5hd7iJqsWdTKyA7dKa6Z"
+};
+/**
+* Chain IDs used in the key derivation function (KDF) for deriving child public keys to
+* distinguish between different chains.
+*
+* @see {@link deriveChildPublicKey} in cryptography.ts for usage details
+*/
+const KDF_CHAIN_IDS = {
+	[CHAINS.ETHEREUM]: "eip155:1",
+	[CHAINS.SOLANA]: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+	[CHAINS.CANTON]: "canton:global"
+};
+/**
+* Contract addresses for different chains and environments.
+*
+* - Testnet Dev: Used for internal development, very unstable
+* - Testnet: Used for external development, stable
+* - Mainnet: Production contract address
+*
+* @see ChainSignatureContract documentation for implementation details
+*/
+const CONTRACT_ADDRESSES = {
+	[CHAINS.ETHEREUM]: {
+		[ENVS.TESTNET_DEV]: "0x69C6b28Fdc74618817fa380De29a653060e14009",
+		[ENVS.TESTNET]: "0x83458E8Bf8206131Fe5c05127007FA164c0948A2",
+		[ENVS.MAINNET]: "0xf8bdC0612361a1E49a8E01423d4C0cFc5dF4791A"
+	},
+	[CHAINS.SOLANA]: {
+		[ENVS.TESTNET_DEV]: "SigDuEPNeDjh3oJv7MUraPN7zaTFomS6ZWfpXwjUg4B",
+		[ENVS.TESTNET]: "SigTVbfRK9LsXWpSv9KgpabrQcFKr5hDdUwMhYsXyKg",
+		[ENVS.MAINNET]: "SigMcRMjKfnC7RDG5q4yUMZM1s5KJ9oYTPP4NmJRDRw"
+	},
+	[CHAINS.CANTON]: {
+		[ENVS.TESTNET_DEV]: "",
+		[ENVS.TESTNET]: "",
+		[ENVS.MAINNET]: ""
+	}
+};
+//#endregion
+//#region src/utils/cryptography.ts
+var cryptography_exports = /* @__PURE__ */ __exportAll({
+	compressPubKey: () => compressPubKey,
+	deriveChildPublicKey: () => deriveChildPublicKey,
+	normalizeToUncompressedPubKey: () => normalizeToUncompressedPubKey,
+	toRSV: () => toRSV,
+	verifyRecoveredAddress: () => verifyRecoveredAddress
+});
+const toRSV = (signature) => {
+	if ("bigR" in signature && "x" in signature.bigR && "s" in signature && typeof signature.s === "bigint") return {
+		r: signature.bigR.x.toString(16).padStart(64, "0"),
+		s: signature.s.toString(16).padStart(64, "0"),
+		v: signature.recoveryId + 27
+	};
+	throw new Error("Invalid signature format");
+};
+/**
+* Compresses an uncompressed public key to its compressed format following SEC1 standards.
+* In SEC1, a compressed public key consists of a prefix (02 or 03) followed by the x-coordinate.
+* The prefix indicates whether the y-coordinate is even (02) or odd (03).
+*
+* @param uncompressedPubKeySEC1 - The uncompressed public key in hex format, with or without '04' prefix
+* @returns The compressed public key in hex format
+* @throws Error if the uncompressed public key length is invalid
+*/
+const compressPubKey = (uncompressedPubKeySEC1) => {
+	const slicedPubKey = uncompressedPubKeySEC1.slice(2);
+	if (slicedPubKey.length !== 128) throw new Error("Invalid uncompressed public key length");
+	const x = slicedPubKey.slice(0, 64);
+	const y = slicedPubKey.slice(64);
+	return (parseInt(y.slice(-1), 16) % 2 === 0 ? "02" : "03") + x;
+};
+/**
+* Normalizes any supported public key format to an uncompressed SEC1 public key.
+*
+* Supported formats:
+* - NAJ format: `secp256k1:base58...`
+* - Uncompressed SEC1: `04` prefix + 128 hex chars (64 bytes)
+* - Compressed SEC1: `02` or `03` prefix + 64 hex chars (32 bytes)
+*/
+const normalizeToUncompressedPubKey = (key) => {
+	if (key.startsWith("secp256k1:")) {
+		const decodedKey = base58.decode(key.split(":")[1]);
+		return `04${hex.encode(decodedKey)}`;
+	}
+	if (key.startsWith("04") && key.length === 130) return key;
+	if ((key.startsWith("02") || key.startsWith("03")) && key.length === 66) return secp256k1.Point.fromHex(key).toHex(false);
+	throw new Error(`Unsupported public key format. Expected NAJ (secp256k1:base58...), uncompressed (04 + 128 hex), or compressed (02/03 + 64 hex) key. Received: ${key.slice(0, 20)}...`);
+};
+const EPSILON_DERIVATION_PREFIX = "sig.network v2.0.0 epsilon derivation";
+/**
+* Derives a child public key from a parent public key using the Sig.Network epsilon derivation scheme.
+* The parent public keys are defined in @constants.ts
+*
+* @param rootUncompressedPubKeySEC1 - The parent public key in uncompressed SEC1 format (e.g. 04 || x || y)
+* @param predecessorId - The predecessor ID is the address of the account calling the signer contract (e.g EOA or Contract Address)
+* @param path - Optional derivation path suffix (defaults to empty string)
+* @param chainId - CAIP-2 chain identifier used for derivation
+* @param keyVersion - Key version (must be >= 1 for v2 derivation)
+* @returns The derived child public key in uncompressed SEC1 format (04 || x || y)
+*/
+function deriveChildPublicKey(rootUncompressedPubKeySEC1, predecessorId, path = "", chainId, keyVersion) {
+	if (!Object.values(KDF_CHAIN_IDS).includes(chainId)) throw new Error("Invalid chain ID");
+	if (keyVersion < 1) throw new Error("key_version 0 (legacy v1 derivation) is not supported. Use key_version >= 1.");
+	const derivationPath = `${EPSILON_DERIVATION_PREFIX}:${chainId}:${predecessorId}:${path}`;
+	const scalarHex = keccak256(new TextEncoder().encode(derivationPath)).slice(2);
+	const oldPoint = secp256k1.Point.fromHex(rootUncompressedPubKeySEC1);
+	const scalarTimesG = secp256k1.Point.BASE.multiply(BigInt(`0x${scalarHex}`));
+	return oldPoint.add(scalarTimesG).toHex(false);
+}
+/**
+* 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.
+*
+* @param signature - The RSV signature to verify
+* @param payload - The original message that was signed (as byte array)
+* @param requesterAddress - The address of the requester
+* @param path - The derivation path used for key generation
+* @param contract - The contract instance for deriving addresses
+* @returns Promise resolving to true if the recovered address matches the expected address
+*/
+async function verifyRecoveredAddress(signature, payload, requesterAddress, path, contract, keyVersion) {
+	try {
+		const { address: expectedAddress } = await new EVM({
+			publicClient: createPublicClient({ transport: http("https://dontcare.com") }),
+			contract
+		}).deriveAddressAndPublicKey(requesterAddress, path, keyVersion);
+		return (await recoverAddress({
+			hash: new Uint8Array(payload),
+			signature: {
+				r: `0x${signature.r}`,
+				s: `0x${signature.s}`,
+				yParity: signature.v - 27
+			}
+		})).toLowerCase() === expectedAddress.toLowerCase();
+	} catch (error) {
+		console.error("Signature verification failed:", error);
+		return false;
+	}
+}
+//#endregion
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ __exportAll({ cryptography: () => cryptography_exports });
+//#endregion
+//#region src/chain-adapters/ChainAdapter.ts
+var ChainAdapter = class {};
+//#endregion
+//#region src/chain-adapters/EVM/utils.ts
+async function fetchEVMFeeProperties(client, transaction) {
+	const [gas, feeData] = await Promise.all([client.estimateGas(transaction), client.estimateFeesPerGas()]);
+	return {
+		gas,
+		maxFeePerGas: feeData.maxFeePerGas ?? BigInt(1e10),
+		maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ?? BigInt(1e10)
+	};
+}
+//#endregion
+//#region src/chain-adapters/EVM/EVM.ts
+/**
+* Implementation of the ChainAdapter interface for EVM-compatible networks.
+* Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
+*/
+var EVM = class extends ChainAdapter {
+	client;
+	contract;
+	/**
+	* Creates a new EVM chain instance
+	* @param params - Configuration parameters
+	* @param params.publicClient - A Viem PublicClient instance for reading from the blockchain
+	* @param params.contract - Instance of the chain signature contract for MPC operations
+	*/
+	constructor({ publicClient, contract }) {
+		super();
+		this.contract = contract;
+		this.client = publicClient;
+	}
+	async attachGasAndNonce(transaction) {
+		const fees = await fetchEVMFeeProperties(this.client, transaction);
+		const nonce = await this.client.getTransactionCount({ address: transaction.from });
+		const { from: _from, ...rest } = transaction;
+		return {
+			...fees,
+			nonce,
+			chainId: Number(await this.client.getChainId()),
+			type: "eip1559",
+			...rest
+		};
+	}
+	transformRSVSignature(signature) {
+		return {
+			r: `0x${signature.r}`,
+			s: `0x${signature.s}`,
+			yParity: signature.v - 27
+		};
+	}
+	assembleSignature(signature) {
+		const { r, s, yParity } = this.transformRSVSignature(signature);
+		if (yParity === void 0) throw new Error("Missing yParity");
+		return concatHex([
+			r,
+			s,
+			numberToHex(yParity + 27, { size: 1 })
+		]);
+	}
+	async deriveAddressAndPublicKey(predecessor, path, keyVersion) {
+		const uncompressedPubKey = await this.contract.getDerivedPublicKey({
+			path,
+			predecessor,
+			keyVersion
+		});
+		if (!uncompressedPubKey) throw new Error("Failed to get derived public key");
+		return {
+			address: getAddress(`0x${keccak256(`0x${uncompressedPubKey.startsWith("04") ? uncompressedPubKey.slice(2) : uncompressedPubKey}`).slice(-40)}`),
+			publicKey: uncompressedPubKey
+		};
+	}
+	async getBalance(address) {
+		return {
+			balance: await this.client.getBalance({ address }),
+			decimals: 18
+		};
+	}
+	serializeTransaction(transaction) {
+		return serializeTransaction(transaction);
+	}
+	deserializeTransaction(serialized) {
+		return parseTransaction(serialized);
+	}
+	async prepareTransactionForSigning(transactionRequest) {
+		const transaction = await this.attachGasAndNonce(transactionRequest);
+		const txHash = toBytes(keccak256(serializeTransaction(transaction)));
+		return {
+			transaction,
+			hashesToSign: [Array.from(txHash)]
+		};
+	}
+	async prepareMessageForSigning(message) {
+		return { hashToSign: Array.from(toBytes(hashMessage(message))) };
+	}
+	async prepareTypedDataForSigning(typedDataRequest) {
+		return { hashToSign: Array.from(toBytes(hashTypedData(typedDataRequest))) };
+	}
+	finalizeTransactionSigning({ transaction, rsvSignatures }) {
+		return serializeTransaction(transaction, this.transformRSVSignature(rsvSignatures[0]));
+	}
+	finalizeMessageSigning({ rsvSignature }) {
+		return this.assembleSignature(rsvSignature);
+	}
+	finalizeTypedDataSigning({ rsvSignature }) {
+		return this.assembleSignature(rsvSignature);
+	}
+	async broadcastTx(txSerialized) {
+		try {
+			return await this.client.sendRawTransaction({ serializedTransaction: txSerialized });
+		} catch (error) {
+			console.error("Transaction broadcast failed:", error);
+			throw new Error("Failed to broadcast transaction.", { cause: error });
+		}
+	}
+};
+//#endregion
+//#region src/chain-adapters/EVM/index.ts
+var EVM_exports = /* @__PURE__ */ __exportAll({
+	EVM: () => EVM,
+	fetchEVMFeeProperties: () => fetchEVMFeeProperties
+});
+//#endregion
+//#region src/chain-adapters/Bitcoin/utils.ts
+function parseBTCNetwork(network) {
+	switch (network.toLowerCase()) {
+		case "mainnet": return bitcoin.networks.bitcoin;
+		case "testnet": return bitcoin.networks.testnet;
+		case "regtest": return bitcoin.networks.regtest;
+		default: throw new Error(`Unknown Bitcoin network: ${network}`);
+	}
+}
+//#endregion
+//#region src/chain-adapters/Bitcoin/Bitcoin.ts
+/**
+* Implementation of the ChainAdapter interface for Bitcoin network.
+* Handles interactions with both Bitcoin mainnet and testnet, supporting P2WPKH transactions.
+*/
+var Bitcoin = class Bitcoin extends ChainAdapter {
+	static SATOSHIS_PER_BTC = 1e8;
+	network;
+	btcRpcAdapter;
+	contract;
+	/**
+	* Creates a new Bitcoin chain instance
+	* @param params - Configuration parameters
+	* @param params.network - Network identifier (mainnet/testnet)
+	* @param params.contract - Instance of the chain signature contract for MPC operations
+	* @param params.btcRpcAdapter - Bitcoin RPC adapter for network interactions
+	*/
+	constructor({ network, contract, btcRpcAdapter }) {
+		super();
+		this.network = network;
+		this.btcRpcAdapter = btcRpcAdapter;
+		this.contract = contract;
+	}
+	/**
+	* Converts satoshis to BTC
+	* @param satoshis - Amount in satoshis
+	* @returns Amount in BTC
+	*/
+	static toBTC(satoshis) {
+		return satoshis / Bitcoin.SATOSHIS_PER_BTC;
+	}
+	/**
+	* Converts BTC to satoshis
+	* @param btc - Amount in BTC
+	* @returns Amount in satoshis (rounded)
+	*/
+	static toSatoshi(btc) {
+		return Math.round(btc * Bitcoin.SATOSHIS_PER_BTC);
+	}
+	async fetchTransaction(transactionId) {
+		const data = await this.btcRpcAdapter.getTransaction(transactionId);
+		const tx = new bitcoin.Transaction();
+		data.vout.forEach((vout) => {
+			const scriptPubKey = Buffer.from(vout.scriptpubkey, "hex");
+			tx.addOutput(scriptPubKey, BigInt(vout.value));
+		});
+		return tx;
+	}
+	static transformRSVSignature(signature) {
+		const r = signature.r.padStart(64, "0");
+		const s = signature.s.padStart(64, "0");
+		const rawSignature = Buffer.from(r + s, "hex");
+		if (rawSignature.length !== 64) throw new Error("Invalid signature length.");
+		return rawSignature;
+	}
+	/**
+	* Creates a Partially Signed Bitcoin Transaction (PSBT)
+	* @param params - Parameters for creating the PSBT
+	* @param params.transactionRequest - Transaction request containing inputs and outputs
+	* @returns Created PSBT instance
+	*/
+	async createPSBT({ transactionRequest }) {
+		const { inputs, outputs } = transactionRequest.inputs && transactionRequest.outputs ? transactionRequest : await this.btcRpcAdapter.selectUTXOs(transactionRequest.from, [{
+			address: transactionRequest.to,
+			value: parseFloat(transactionRequest.value)
+		}]);
+		const psbt = new bitcoin.Psbt({ network: parseBTCNetwork(this.network) });
+		await Promise.all(inputs.map(async (input) => {
+			if (!input.scriptPubKey) input.scriptPubKey = (await this.fetchTransaction(input.txid)).outs[input.vout].script;
+			psbt.addInput({
+				hash: input.txid,
+				index: input.vout,
+				witnessUtxo: {
+					script: input.scriptPubKey,
+					value: BigInt(input.value)
+				}
+			});
+		}));
+		outputs.forEach((out) => {
+			if ("address" in out) psbt.addOutput({
+				address: out.address,
+				value: BigInt(out.value)
+			});
+			else if ("script" in out) psbt.addOutput({
+				script: out.script,
+				value: BigInt(out.value)
+			});
+			else if (transactionRequest.from !== void 0) psbt.addOutput({
+				value: BigInt(out.value),
+				address: transactionRequest.from
+			});
+		});
+		return psbt;
+	}
+	async getBalance(address) {
+		return {
+			balance: BigInt(await this.btcRpcAdapter.getBalance(address)),
+			decimals: 8
+		};
+	}
+	async deriveAddressAndPublicKey(predecessor, path, keyVersion) {
+		const uncompressedPubKey = await this.contract.getDerivedPublicKey({
+			path,
+			predecessor,
+			keyVersion
+		});
+		if (!uncompressedPubKey) throw new Error("Failed to get derived public key");
+		const derivedKey = compressPubKey(uncompressedPubKey);
+		const publicKeyBuffer = Buffer.from(derivedKey, "hex");
+		const network = parseBTCNetwork(this.network);
+		const { address } = bitcoin.payments.p2wpkh({
+			pubkey: publicKeyBuffer,
+			network
+		});
+		if (!address) throw new Error("Failed to generate Bitcoin address");
+		return {
+			address,
+			publicKey: derivedKey
+		};
+	}
+	serializeTransaction(transaction) {
+		return JSON.stringify({
+			psbt: transaction.psbt.toHex(),
+			publicKey: transaction.publicKey
+		});
+	}
+	deserializeTransaction(serialized) {
+		const transactionJSON = JSON.parse(serialized);
+		return {
+			psbt: bitcoin.Psbt.fromHex(transactionJSON.psbt),
+			publicKey: transactionJSON.publicKey
+		};
+	}
+	async prepareTransactionForSigning(transactionRequest) {
+		const publicKeyBuffer = Buffer.from(transactionRequest.publicKey, "hex");
+		const psbt = await this.createPSBT({ transactionRequest });
+		const psbtHex = psbt.toHex();
+		const hashesToSign = [];
+		const mockKeyPair = (index) => ({
+			publicKey: publicKeyBuffer,
+			sign: (hash) => {
+				hashesToSign[index] = Array.from(hash);
+				return /* @__PURE__ */ new Uint8Array(64);
+			}
+		});
+		for (let index = 0; index < psbt.inputCount; index++) psbt.signInput(index, mockKeyPair(index));
+		return {
+			transaction: {
+				psbt: bitcoin.Psbt.fromHex(psbtHex),
+				publicKey: transactionRequest.publicKey
+			},
+			hashesToSign
+		};
+	}
+	finalizeTransactionSigning({ transaction: { psbt, publicKey }, rsvSignatures }) {
+		const publicKeyBuffer = Buffer.from(publicKey, "hex");
+		const keyPair = (index) => ({
+			publicKey: publicKeyBuffer,
+			sign: () => {
+				const mpcSignature = rsvSignatures[index];
+				return Bitcoin.transformRSVSignature(mpcSignature);
+			}
+		});
+		for (let index = 0; index < psbt.inputCount; index++) psbt.signInput(index, keyPair(index));
+		psbt.finalizeAllInputs();
+		return psbt.extractTransaction().toHex();
+	}
+	async broadcastTx(txSerialized) {
+		return await this.btcRpcAdapter.broadcastTransaction(txSerialized);
+	}
+};
+//#endregion
+//#region src/chain-adapters/Bitcoin/BTCRpcAdapter/BTCRpcAdapter.ts
+var BTCRpcAdapter = class {};
+//#endregion
+//#region src/chain-adapters/Bitcoin/BTCRpcAdapter/Mempool/Mempool.ts
+var Mempool = class extends BTCRpcAdapter {
+	providerUrl;
+	constructor(providerUrl) {
+		super();
+		this.providerUrl = providerUrl;
+	}
+	async fetchFeeRate(confirmationTarget = 6) {
+		const data = await (await fetch(`${this.providerUrl}/v1/fees/recommended`)).json();
+		if (confirmationTarget <= 1) return data.fastestFee;
+		else if (confirmationTarget <= 3) return data.halfHourFee;
+		else if (confirmationTarget <= 6) return data.hourFee;
+		else return data.economyFee;
+	}
+	async fetchUTXOs(address) {
+		try {
+			return await (await fetch(`${this.providerUrl}/address/${address}/utxo`)).json();
+		} catch (error) {
+			console.error("Failed to fetch UTXOs:", error);
+			return [];
+		}
+	}
+	async selectUTXOs(from, targets, confirmationTarget = 6) {
+		const utxos = await this.fetchUTXOs(from);
+		const feeRate = await this.fetchFeeRate(confirmationTarget);
+		const ret = coinselect(utxos, targets, Math.ceil(feeRate + 1));
+		if (!ret.inputs || !ret.outputs) throw new Error("Invalid transaction: coinselect failed to find a suitable set of inputs and outputs. This could be due to insufficient funds, or no inputs being available that meet the criteria.");
+		return {
+			inputs: ret.inputs,
+			outputs: ret.outputs
+		};
+	}
+	async broadcastTransaction(transactionHex) {
+		const response = await fetch(`${this.providerUrl}/tx`, {
+			method: "POST",
+			body: transactionHex
+		});
+		if (response.ok) return await response.text();
+		throw new Error(`Failed to broadcast transaction: ${await response.text()}`);
+	}
+	async getBalance(address) {
+		const data = await (await fetch(`${this.providerUrl}/address/${address}`)).json();
+		return data.chain_stats.funded_txo_sum - data.chain_stats.spent_txo_sum;
+	}
+	async getTransaction(txid) {
+		return await (await fetch(`${this.providerUrl}/tx/${txid}`)).json();
+	}
+};
+//#endregion
+//#region src/chain-adapters/Bitcoin/BTCRpcAdapter/index.ts
+const BTCRpcAdapters = { Mempool };
+//#endregion
+//#region src/chain-adapters/Bitcoin/index.ts
+var Bitcoin_exports = /* @__PURE__ */ __exportAll({
+	BTCRpcAdapter: () => BTCRpcAdapter,
+	BTCRpcAdapters: () => BTCRpcAdapters,
+	Bitcoin: () => Bitcoin
+});
+//#endregion
+//#region src/chain-adapters/Cosmos/utils.ts
+const fetchChainInfo = async (chainId) => {
+	const chainInfo = chains.find((chain) => chain.chainId === chainId);
+	if (!chainInfo) throw new Error(`Chain info not found for chainId: ${chainId}`);
+	const { bech32Prefix: prefix, chainId: expectedChainId } = chainInfo;
+	const denom = chainInfo.staking?.stakingTokens?.[0]?.denom;
+	const rpcUrl = chainInfo.apis?.rpc?.[0]?.address;
+	const restUrl = chainInfo.apis?.rest?.[0]?.address;
+	const gasPrice = chainInfo.fees?.feeTokens?.[0]?.averageGasPrice;
+	if (!prefix || !denom || !rpcUrl || !restUrl || !expectedChainId || gasPrice === void 0) throw new Error(`Missing required chain information for ${chainInfo.chainName}`);
+	const asset = assetLists.find((al) => al.chainName === chainInfo.chainName)?.assets.find((asset) => asset.base === denom);
+	const decimals = asset?.denomUnits.find((unit) => unit.denom === asset.display)?.exponent;
+	if (decimals === void 0) throw new Error(`Could not find decimals for ${denom} on chain ${chainInfo.chainName}`);
+	return {
+		prefix,
+		denom,
+		rpcUrl,
+		restUrl,
+		expectedChainId,
+		gasPrice,
+		decimals
+	};
+};
+//#endregion
+//#region src/chain-adapters/Cosmos/Cosmos.ts
+/**
+* Implementation of the ChainAdapter interface for Cosmos-based networks.
+* Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
+*/
+var Cosmos = class extends ChainAdapter {
+	registry;
+	chainId;
+	contract;
+	endpoints;
+	/**
+	* Creates a new Cosmos chain instance
+	* @param params - Configuration parameters
+	* @param params.chainId - Chain id for the Cosmos network
+	* @param params.contract - Instance of the chain signature contract for MPC operations
+	* @param params.endpoints - Optional RPC and REST endpoints
+	* @param params.endpoints.rpcUrl - Optional RPC endpoint URL
+	* @param params.endpoints.restUrl - Optional REST endpoint URL
+	*/
+	constructor({ chainId, contract, endpoints }) {
+		super();
+		this.contract = contract;
+		this.registry = new Registry();
+		this.chainId = chainId;
+		this.endpoints = endpoints;
+	}
+	transformRSVSignature(rsvSignature) {
+		return new Uint8Array([...fromHex(rsvSignature.r), ...fromHex(rsvSignature.s)]);
+	}
+	async getChainInfo() {
+		return {
+			...await fetchChainInfo(this.chainId),
+			...this.endpoints
+		};
+	}
+	async getBalance(address) {
+		try {
+			const { restUrl, denom, decimals } = await this.getChainInfo();
+			const response = await fetch(`${restUrl}/cosmos/bank/v1beta1/balances/${address}`);
+			if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+			const amount = (await response.json()).balances.find((b) => b.denom === denom)?.amount ?? "0";
+			return {
+				balance: BigInt(amount),
+				decimals
+			};
+		} catch (error) {
+			console.error("Failed to fetch Cosmos balance:", error);
+			throw new Error("Failed to fetch Cosmos balance", { cause: error });
+		}
+	}
+	async deriveAddressAndPublicKey(predecessor, path, keyVersion) {
+		const { prefix } = await this.getChainInfo();
+		const uncompressedPubKey = await this.contract.getDerivedPublicKey({
+			path,
+			predecessor,
+			keyVersion
+		});
+		if (!uncompressedPubKey) throw new Error("Failed to get derived public key");
+		const derivedKey = compressPubKey(uncompressedPubKey);
+		return {
+			address: toBech32(prefix, ripemd160(sha256(fromHex(derivedKey)))),
+			publicKey: derivedKey
+		};
+	}
+	serializeTransaction(transaction) {
+		return toBase64(TxRaw.encode(transaction).finish());
+	}
+	deserializeTransaction(serialized) {
+		return TxRaw.decode(fromBase64(serialized));
+	}
+	async prepareTransactionForSigning(transactionRequest) {
+		const { denom, rpcUrl, gasPrice } = await this.getChainInfo();
+		const publicKeyBytes = fromHex(transactionRequest.publicKey);
+		const fee = calculateFee(transactionRequest.gas || 2e5, GasPrice.fromString(`${gasPrice}${denom}`));
+		const accountOnChain = await (await StargateClient.connect(rpcUrl)).getAccount(transactionRequest.address);
+		if (!accountOnChain) throw new Error(`Account ${transactionRequest.address} does not exist on chain`);
+		const { accountNumber, sequence } = accountOnChain;
+		const txBodyEncodeObject = {
+			typeUrl: "/cosmos.tx.v1beta1.TxBody",
+			value: {
+				messages: transactionRequest.messages,
+				memo: transactionRequest.memo || ""
+			}
+		};
+		const txBodyBytes = this.registry.encode(txBodyEncodeObject);
+		const authInfoBytes = makeAuthInfoBytes([{
+			pubkey: encodePubkey(encodeSecp256k1Pubkey(publicKeyBytes)),
+			sequence
+		}], fee.amount, Number(fee.gas), void 0, void 0, SignMode.SIGN_MODE_DIRECT);
+		const signBytes = makeSignBytes(makeSignDoc(txBodyBytes, authInfoBytes, this.chainId, accountNumber));
+		const payload = Array.from(sha256(signBytes));
+		return {
+			transaction: TxRaw.fromPartial({
+				bodyBytes: txBodyBytes,
+				authInfoBytes,
+				signatures: []
+			}),
+			hashesToSign: [payload]
+		};
+	}
+	finalizeTransactionSigning({ transaction, rsvSignatures }) {
+		transaction.signatures = rsvSignatures.map((sig) => this.transformRSVSignature(sig));
+		return toHex(TxRaw.encode(transaction).finish());
+	}
+	async broadcastTx(txSerialized) {
+		try {
+			const { rpcUrl } = await this.getChainInfo();
+			const client = await StargateClient.connect(rpcUrl);
+			const txBytes = fromHex(txSerialized);
+			const broadcastResponse = await client.broadcastTx(txBytes);
+			if (broadcastResponse.code !== 0) throw new Error(`Broadcast error: ${broadcastResponse.rawLog ?? "unknown error (check events)"}`);
+			return broadcastResponse.transactionHash;
+		} catch (error) {
+			console.error("Transaction broadcast failed:", error);
+			throw new Error("Failed to broadcast transaction.", { cause: error });
+		}
+	}
+};
+//#endregion
+//#region src/chain-adapters/Cosmos/index.ts
+var Cosmos_exports = /* @__PURE__ */ __exportAll({ Cosmos: () => Cosmos });
+//#endregion
+//#region src/chain-adapters/index.ts
+var chain_adapters_exports = /* @__PURE__ */ __exportAll({
+	ChainAdapter: () => ChainAdapter,
+	btc: () => Bitcoin_exports,
+	cosmos: () => Cosmos_exports,
+	evm: () => EVM_exports
+});
+//#endregion
+//#region src/contracts/ChainSignatureContract.ts
+/**
+* Base contract interface required for compatibility with ChainAdapter instances like EVM and Bitcoin.
+*
+* See {@link EVM} and {@link Bitcoin} for example implementations.
+*/
+var BaseChainSignatureContract = class {};
+/**
+* Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
+*/
+var ChainSignatureContract$2 = class extends BaseChainSignatureContract {};
+//#endregion
+//#region src/contracts/evm/ChainSignaturesContractABI.ts
+var ChainSignaturesContractABI_exports = /* @__PURE__ */ __exportAll({ abi: () => abi });
+const abi = [
+	{
+		inputs: [{
+			internalType: "address",
+			name: "_mpc_network",
+			type: "address"
+		}, {
+			internalType: "uint256",
+			name: "_signatureDeposit",
+			type: "uint256"
+		}],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
+	{
+		inputs: [],
+		name: "AccessControlBadConfirmation",
+		type: "error"
+	},
+	{
+		inputs: [{
+			internalType: "address",
+			name: "account",
+			type: "address"
+		}, {
+			internalType: "bytes32",
+			name: "neededRole",
+			type: "bytes32"
+		}],
+		name: "AccessControlUnauthorizedAccount",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "role",
+				type: "bytes32"
+			},
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "previousAdminRole",
+				type: "bytes32"
+			},
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "newAdminRole",
+				type: "bytes32"
+			}
+		],
+		name: "RoleAdminChanged",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "role",
+				type: "bytes32"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "account",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			}
+		],
+		name: "RoleGranted",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "role",
+				type: "bytes32"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "account",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			}
+		],
+		name: "RoleRevoked",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "requestId",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "responder",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "error",
+				type: "string"
+			}
+		],
+		name: "SignatureError",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: false,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "bytes32",
+				name: "payload",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "uint32",
+				name: "keyVersion",
+				type: "uint32"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "deposit",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "chainId",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "path",
+				type: "string"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "algo",
+				type: "string"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "dest",
+				type: "string"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "params",
+				type: "string"
+			}
+		],
+		name: "SignatureRequested",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "bytes32",
+				name: "requestId",
+				type: "bytes32"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "responder",
+				type: "address"
+			},
+			{
+				components: [
+					{
+						components: [{
+							internalType: "uint256",
+							name: "x",
+							type: "uint256"
+						}, {
+							internalType: "uint256",
+							name: "y",
+							type: "uint256"
+						}],
+						internalType: "struct ChainSignatures.AffinePoint",
+						name: "bigR",
+						type: "tuple"
+					},
+					{
+						internalType: "uint256",
+						name: "s",
+						type: "uint256"
+					},
+					{
+						internalType: "uint8",
+						name: "recoveryId",
+						type: "uint8"
+					}
+				],
+				indexed: false,
+				internalType: "struct ChainSignatures.Signature",
+				name: "signature",
+				type: "tuple"
+			}
+		],
+		name: "SignatureResponded",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [{
+			indexed: true,
+			internalType: "address",
+			name: "owner",
+			type: "address"
+		}, {
+			indexed: false,
+			internalType: "uint256",
+			name: "amount",
+			type: "uint256"
+		}],
+		name: "Withdraw",
+		type: "event"
+	},
+	{
+		inputs: [],
+		name: "DEFAULT_ADMIN_ROLE",
+		outputs: [{
+			internalType: "bytes32",
+			name: "",
+			type: "bytes32"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bytes32",
+			name: "role",
+			type: "bytes32"
+		}],
+		name: "getRoleAdmin",
+		outputs: [{
+			internalType: "bytes32",
+			name: "",
+			type: "bytes32"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "getSignatureDeposit",
+		outputs: [{
+			internalType: "uint256",
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bytes32",
+			name: "role",
+			type: "bytes32"
+		}, {
+			internalType: "address",
+			name: "account",
+			type: "address"
+		}],
+		name: "grantRole",
+		outputs: [],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bytes32",
+			name: "role",
+			type: "bytes32"
+		}, {
+			internalType: "address",
+			name: "account",
+			type: "address"
+		}],
+		name: "hasRole",
+		outputs: [{
+			internalType: "bool",
+			name: "",
+			type: "bool"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bytes32",
+			name: "role",
+			type: "bytes32"
+		}, {
+			internalType: "address",
+			name: "callerConfirmation",
+			type: "address"
+		}],
+		name: "renounceRole",
+		outputs: [],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			components: [{
+				internalType: "bytes32",
+				name: "requestId",
+				type: "bytes32"
+			}, {
+				components: [
+					{
+						components: [{
+							internalType: "uint256",
+							name: "x",
+							type: "uint256"
+						}, {
+							internalType: "uint256",
+							name: "y",
+							type: "uint256"
+						}],
+						internalType: "struct ChainSignatures.AffinePoint",
+						name: "bigR",
+						type: "tuple"
+					},
+					{
+						internalType: "uint256",
+						name: "s",
+						type: "uint256"
+					},
+					{
+						internalType: "uint8",
+						name: "recoveryId",
+						type: "uint8"
+					}
+				],
+				internalType: "struct ChainSignatures.Signature",
+				name: "signature",
+				type: "tuple"
+			}],
+			internalType: "struct ChainSignatures.Response[]",
+			name: "_responses",
+			type: "tuple[]"
+		}],
+		name: "respond",
+		outputs: [],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			components: [{
+				internalType: "bytes32",
+				name: "requestId",
+				type: "bytes32"
+			}, {
+				internalType: "string",
+				name: "errorMessage",
+				type: "string"
+			}],
+			internalType: "struct ChainSignatures.ErrorResponse[]",
+			name: "_errors",
+			type: "tuple[]"
+		}],
+		name: "respondError",
+		outputs: [],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bytes32",
+			name: "role",
+			type: "bytes32"
+		}, {
+			internalType: "address",
+			name: "account",
+			type: "address"
+		}],
+		name: "revokeRole",
+		outputs: [],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint256",
+			name: "_amount",
+			type: "uint256"
+		}],
+		name: "setSignatureDeposit",
+		outputs: [],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			components: [
+				{
+					internalType: "bytes32",
+					name: "payload",
+					type: "bytes32"
+				},
+				{
+					internalType: "string",
+					name: "path",
+					type: "string"
+				},
+				{
+					internalType: "uint32",
+					name: "keyVersion",
+					type: "uint32"
+				},
+				{
+					internalType: "string",
+					name: "algo",
+					type: "string"
+				},
+				{
+					internalType: "string",
+					name: "dest",
+					type: "string"
+				},
+				{
+					internalType: "string",
+					name: "params",
+					type: "string"
+				}
+			],
+			internalType: "struct ChainSignatures.SignRequest",
+			name: "_request",
+			type: "tuple"
+		}],
+		name: "sign",
+		outputs: [],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "bytes4",
+			name: "interfaceId",
+			type: "bytes4"
+		}],
+		name: "supportsInterface",
+		outputs: [{
+			internalType: "bool",
+			name: "",
+			type: "bool"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			internalType: "uint256",
+			name: "_amount",
+			type: "uint256"
+		}, {
+			internalType: "address",
+			name: "_receiver",
+			type: "address"
+		}],
+		name: "withdraw",
+		outputs: [],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+//#endregion
+//#region src/contracts/evm/errors.ts
+var errors_exports$1 = /* @__PURE__ */ __exportAll({
+	ChainSignatureError: () => ChainSignatureError,
+	SignatureContractError: () => SignatureContractError,
+	SignatureNotFoundError: () => SignatureNotFoundError$1,
+	SigningError: () => SigningError$1
+});
+var ChainSignatureError = class extends Error {
+	requestId;
+	receipt;
+	constructor(message, requestId, receipt) {
+		super(message);
+		this.name = "ChainSignatureError";
+		this.requestId = requestId;
+		this.receipt = receipt;
+	}
+};
+var SignatureNotFoundError$1 = class extends ChainSignatureError {
+	constructor(requestId, receipt) {
+		super("Signature not found after maximum retries", requestId, receipt);
+		this.name = "SignatureNotFoundError";
+	}
+};
+var SignatureContractError = class extends ChainSignatureError {
+	errorCode;
+	constructor(errorCode, requestId, receipt) {
+		super(`Signature error: ${errorCode}`, requestId, receipt);
+		this.name = "SignatureContractError";
+		this.errorCode = errorCode;
+	}
+};
+var SigningError$1 = class extends ChainSignatureError {
+	originalError;
+	constructor(requestId, receipt, originalError) {
+		super("Error signing request", requestId, receipt);
+		this.name = "SigningError";
+		this.originalError = originalError;
+	}
+};
+//#endregion
+//#region src/utils/publicKey.ts
+const getRootPublicKey = (contractAddress, chain) => {
+	const environment = Object.entries(CONTRACT_ADDRESSES[chain]).find(([_, address]) => address.toLowerCase() === contractAddress.toLowerCase())?.[0];
+	if (environment) return ROOT_PUBLIC_KEYS[environment];
+};
+//#endregion
+//#region src/contracts/evm/utils.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: '',
+* })
+* ```
+*/
+const getRequestIdRespond$1 = (request) => {
+	return keccak256(encodeAbiParameters([
+		{ type: "address" },
+		{ type: "bytes" },
+		{ type: "string" },
+		{ type: "uint32" },
+		{ type: "uint256" },
+		{ type: "string" },
+		{ type: "string" },
+		{ type: "string" }
+	], [
+		request.address,
+		request.payload,
+		request.path,
+		Number(request.keyVersion),
+		request.chainId,
+		request.algo,
+		request.dest,
+		request.params
+	]));
+};
+//#endregion
+//#region src/contracts/evm/ChainSignaturesContract.ts
+/**
+* Implementation of the ChainSignatureContract for EVM chains.
+*
+* When signing data, the contract emits a SignatureRequested event with a requestId.
+* This requestId is used to track the signature request and retrieve the signature
+* once it's available. The sign method handles this process automatically by polling
+* for the signature using the requestId.
+*/
+var ChainSignatureContract$1 = class extends ChainSignatureContract$2 {
+	publicClient;
+	walletClient;
+	contractAddress;
+	rootPublicKey;
+	/**
+	* Creates a new instance of the ChainSignatureContract for EVM chains.
+	*
+	* @param args - Configuration options for the contract
+	* @param args.publicClient - A Viem PublicClient instance for reading from the blockchain
+	* @param args.walletClient - A Viem WalletClient instance for sending transactions
+	* @param args.contractAddress - The address of the deployed ChainSignatures contract (e.g. `0x857ED3A242B59cC24144814a0DF41C397a3811E6`)
+	* @param args.rootPublicKey - Optional root public key. If not provided, it will be derived from the contract address
+	*/
+	constructor(args) {
+		super();
+		this.publicClient = args.publicClient;
+		this.walletClient = args.walletClient;
+		this.contractAddress = args.contractAddress;
+		const rootPublicKey = args.rootPublicKey || getRootPublicKey(this.contractAddress, CHAINS.ETHEREUM);
+		if (!rootPublicKey) throw new Error(`Invalid public key, please provide a valid root public key or contract address`);
+		this.rootPublicKey = normalizeToUncompressedPubKey(rootPublicKey);
+	}
+	async getCurrentSignatureDeposit() {
+		return await this.publicClient.readContract({
+			address: this.contractAddress,
+			abi,
+			functionName: "getSignatureDeposit"
+		});
+	}
+	async getDerivedPublicKey(args) {
+		return deriveChildPublicKey(await this.getPublicKey(), args.predecessor.toLowerCase(), args.path, KDF_CHAIN_IDS.ETHEREUM, args.keyVersion);
+	}
+	async getPublicKey() {
+		return this.rootPublicKey;
+	}
+	async getLatestKeyVersion() {
+		const version = await this.publicClient.readContract({
+			address: this.contractAddress,
+			abi,
+			functionName: "latestKeyVersion"
+		});
+		return Number(version);
+	}
+	/**
+	* Sends a sign request transaction and return the transaction hash.
+	*
+	* @param args - The signature arguments
+	* @param options - The signing options
+	* @returns The transaction hash
+	*/
+	async createSignatureRequest(args, options = { sign: {
+		algo: "",
+		dest: "",
+		params: ""
+	} }) {
+		if (!this.walletClient?.account) throw new Error("Wallet client required for signing operations");
+		const requestParams = await this.getSignRequestParams(args, options.sign);
+		const requestId = this.getRequestId(args, options.sign);
+		return {
+			txHash: await this.walletClient.sendTransaction({
+				...options.transaction,
+				account: this.walletClient.account,
+				to: requestParams.target,
+				data: requestParams.data,
+				value: requestParams.value,
+				chain: this.walletClient.chain
+			}),
+			requestId
+		};
+	}
+	/**
+	* Sends a transaction to the contract 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.
+	*/
+	async sign(args, options = {
+		sign: {
+			algo: "",
+			dest: "",
+			params: ""
+		},
+		retry: {
+			delay: 5e3,
+			retryCount: 12
+		}
+	}) {
+		const { txHash, requestId } = await this.createSignatureRequest(args, options);
+		const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+		try {
+			const pollResult = await this.pollForRequestId({
+				requestId,
+				payload: args.payload,
+				path: args.path,
+				keyVersion: args.key_version,
+				fromBlock: receipt.blockNumber,
+				options: options.retry
+			});
+			if (!pollResult) throw new SignatureNotFoundError$1(requestId, receipt);
+			if ("error" in pollResult) throw new SignatureContractError(pollResult.error, requestId, receipt);
+			return pollResult;
+		} catch (error) {
+			if (error instanceof SignatureNotFoundError$1 || error instanceof SignatureContractError) throw error;
+			else throw new SigningError$1(requestId, receipt, error instanceof Error ? error : void 0);
+		}
+	}
+	async pollForRequestId({ requestId, payload, path, keyVersion, fromBlock, options }) {
+		const delay = options?.delay ?? 5e3;
+		const retryCount = options?.retryCount ?? 12;
+		const result = await withRetry(async () => {
+			const result = await this.getSignatureFromEvents(requestId, fromBlock);
+			if (result) {
+				if (!await verifyRecoveredAddress(result, payload, this.walletClient.account?.address, path, this, keyVersion)) throw new Error("Signature not found yet");
+				return result;
+			} else throw new Error("Signature not found yet");
+		}, {
+			delay,
+			retryCount,
+			shouldRetry: ({ count, error }) => {
+				console.log(`Retrying get signature: ${count}/${retryCount}`);
+				return error.message === "Signature not found yet";
+			}
+		});
+		if (result) return result;
+		return await this.getErrorFromEvents(requestId, fromBlock);
+	}
+	async getSignRequestParams(args, options = {
+		algo: "",
+		dest: "",
+		params: ""
+	}) {
+		const request = {
+			payload: bytesToHex(new Uint8Array(args.payload)),
+			path: args.path,
+			keyVersion: args.key_version,
+			algo: options.algo ?? "",
+			dest: options.dest ?? "",
+			params: options.params ?? ""
+		};
+		return {
+			target: this.contractAddress,
+			data: encodeFunctionData({
+				abi,
+				functionName: "sign",
+				args: [request]
+			}),
+			value: await this.getCurrentSignatureDeposit()
+		};
+	}
+	/**
+	* Generates the request ID for a signature request allowing to track the response.
+	*
+	* @param args - The signature request object containing:
+	*   @param args.payload - The data payload to be signed as a hex string
+	*   @param args.path - The derivation path for the key
+	*   @param args.keyVersion - The version of the key to use
+	* @param options - The signature request object containing:
+	*   @param options.algo - The signing algorithm to use
+	*   @param options.dest - The destination for the signature
+	*   @param options.params - Additional parameters for the signing process
+	* @returns A hex string representing the unique request ID
+	*
+	* @example
+	* ```typescript
+	* const requestId = ChainSignatureContract.getRequestId({
+	*   payload: bytesToHex(new Uint8Array(args.payload)),
+	*   path: '',
+	*   keyVersion: 0
+	* });
+	* console.log(requestId); // 0x...
+	* ```
+	*/
+	getRequestId(args, options = {
+		algo: "",
+		dest: "",
+		params: ""
+	}) {
+		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 getRequestIdRespond$1({
+			payload: bytesToHex(new Uint8Array(args.payload)),
+			path: args.path,
+			keyVersion: args.key_version,
+			algo: options.algo ?? "",
+			dest: options.dest ?? "",
+			params: options.params ?? "",
+			address: this.walletClient.account.address,
+			chainId: BigInt(this.publicClient.chain.id)
+		});
+	}
+	async getErrorFromEvents(requestId, fromBlock) {
+		const errorLogs = await this.publicClient.getContractEvents({
+			address: this.contractAddress,
+			abi,
+			eventName: "SignatureError",
+			args: { requestId },
+			fromBlock,
+			toBlock: "latest"
+		});
+		if (errorLogs.length > 0) {
+			const { args: errorData } = errorLogs[errorLogs.length - 1];
+			return errorData;
+		}
+	}
+	/**
+	* Searches for SignatureResponded events that match the given requestId.
+	* It works in conjunction with the getRequestId method which generates the unique
+	* identifier for a signature request.
+	*
+	* @param requestId - The identifier for the signature request
+	* @param fromBlock - The block number to start searching from
+	* @returns The RSV signature if found, undefined otherwise
+	*/
+	async getSignatureFromEvents(requestId, fromBlock) {
+		const logs = await this.publicClient.getContractEvents({
+			address: this.contractAddress,
+			abi,
+			eventName: "SignatureResponded",
+			args: { requestId },
+			fromBlock,
+			toBlock: "latest"
+		});
+		if (logs.length > 0) {
+			const { args: signatureData } = logs[logs.length - 1];
+			return toRSV(signatureData.signature);
+		}
+	}
+};
+//#endregion
+//#region src/contracts/evm/index.ts
+var evm_exports = /* @__PURE__ */ __exportAll({
+	ChainSignatureContract: () => ChainSignatureContract$1,
+	getRequestIdRespond: () => getRequestIdRespond$1,
+	utils: () => utils$1
+});
+const utils$1 = {
+	ChainSignaturesContractABI: ChainSignaturesContractABI_exports,
+	errors: errors_exports$1
+};
+//#endregion
+//#region src/contracts/solana/errors.ts
+var errors_exports = /* @__PURE__ */ __exportAll({
+	ResponseError: () => ResponseError,
+	SignatureNotFoundError: () => SignatureNotFoundError,
+	SigningError: () => SigningError
+});
+var SignatureNotFoundError = class extends Error {
+	requestId;
+	hash;
+	constructor(requestId, metadata) {
+		const message = requestId ? `Signature not found for request ID: ${requestId}` : "Signature not found";
+		super(message);
+		this.name = "SignatureNotFoundError";
+		this.requestId = requestId;
+		this.hash = metadata?.hash;
+	}
+};
+var SigningError = class extends Error {
+	requestId;
+	hash;
+	originalError;
+	constructor(requestId, metadata, originalError) {
+		super(`Signing error for request ID: ${requestId}`);
+		this.name = "SigningError";
+		this.requestId = requestId;
+		this.hash = metadata?.hash;
+		this.originalError = originalError;
+	}
+};
+var ResponseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ResponseError";
+	}
+};
+//#endregion
+//#region src/contracts/solana/types/chain_signatures_project.json
+var chain_signatures_project_exports = /* @__PURE__ */ __exportAll({
+	accounts: () => accounts,
+	address: () => address,
+	default: () => chain_signatures_project_default,
+	errors: () => errors,
+	events: () => events,
+	instructions: () => instructions,
+	metadata: () => metadata,
+	types: () => types
+});
+var address = "H5tHfpYoEnarrrzcV7sWBcZhiKMvL2aRpUYvb1ydWkwS";
+var metadata = {
+	"name": "chain_signatures",
+	"version": "0.4.0",
+	"spec": "0.1.0",
+	"description": "Chain signatures program for cross-chain signing on Solana",
+	"repository": "https://github.com/sig-net/signet-solana-program"
+};
+var instructions = [
+	{
+		"name": "get_signature_deposit",
+		"docs": ["* @dev Function to get the current signature deposit amount.\n     * @return The current signature deposit amount."],
+		"discriminator": [
+			45,
+			243,
+			86,
+			86,
+			58,
+			57,
+			172,
+			253
+		],
+		"accounts": [{
+			"name": "program_state",
+			"pda": { "seeds": [{
+				"kind": "const",
+				"value": [
+					112,
+					114,
+					111,
+					103,
+					114,
+					97,
+					109,
+					45,
+					115,
+					116,
+					97,
+					116,
+					101
+				]
+			}] }
+		}],
+		"args": [],
+		"returns": "u64"
+	},
+	{
+		"name": "initialize",
+		"docs": ["* @dev Function to initialize the program state.\n     * @param signature_deposit The deposit required for signature requests.\n     * @param chain_id The CAIP-2 chain identifier."],
+		"discriminator": [
+			175,
+			175,
+			109,
+			31,
+			13,
+			152,
+			155,
+			237
+		],
+		"accounts": [
+			{
+				"name": "program_state",
+				"writable": true,
+				"pda": { "seeds": [{
+					"kind": "const",
+					"value": [
+						112,
+						114,
+						111,
+						103,
+						114,
+						97,
+						109,
+						45,
+						115,
+						116,
+						97,
+						116,
+						101
+					]
+				}] }
+			},
+			{
+				"name": "admin",
+				"writable": true,
+				"signer": true
+			},
+			{
+				"name": "system_program",
+				"address": "11111111111111111111111111111111"
+			}
+		],
+		"args": [{
+			"name": "signature_deposit",
+			"type": "u64"
+		}, {
+			"name": "chain_id",
+			"type": "string"
+		}]
+	},
+	{
+		"name": "respond",
+		"docs": ["* @dev Function to respond to signature requests.\n     * @param request_ids The array of request IDs.\n     * @param signatures The array of signature responses.\n     * @notice When multiple entries reuse a request id, events emit in canonical signature order (PSBT-style)."],
+		"discriminator": [
+			72,
+			65,
+			227,
+			97,
+			42,
+			255,
+			147,
+			12
+		],
+		"accounts": [
+			{
+				"name": "responder",
+				"signer": true
+			},
+			{
+				"name": "event_authority",
+				"pda": { "seeds": [{
+					"kind": "const",
+					"value": [
+						95,
+						95,
+						101,
+						118,
+						101,
+						110,
+						116,
+						95,
+						97,
+						117,
+						116,
+						104,
+						111,
+						114,
+						105,
+						116,
+						121
+					]
+				}] }
+			},
+			{ "name": "program" }
+		],
+		"args": [{
+			"name": "request_ids",
+			"type": { "vec": { "array": ["u8", 32] } }
+		}, {
+			"name": "signatures",
+			"type": { "vec": { "defined": { "name": "Signature" } } }
+		}]
+	},
+	{
+		"name": "respond_bidirectional",
+		"docs": ["* @dev Function to finalize bidirectional flow\n     * @param request_id The ID of the signature request to respond to\n     * @param serialized_output output of the previously executed transaction\n     * @param signature ECDSA signature of the serialized output and request_id (keccak256(request_id.concat(serialized_output)))"],
+		"discriminator": [
+			138,
+			0,
+			45,
+			246,
+			236,
+			211,
+			109,
+			81
+		],
+		"accounts": [{
+			"name": "responder",
+			"signer": true
+		}],
+		"args": [
+			{
+				"name": "request_id",
+				"type": { "array": ["u8", 32] }
+			},
+			{
+				"name": "serialized_output",
+				"type": "bytes"
+			},
+			{
+				"name": "signature",
+				"type": { "defined": { "name": "Signature" } }
+			}
+		]
+	},
+	{
+		"name": "respond_error",
+		"docs": ["* @dev Function to emit signature generation errors.\n     * @param errors The array of signature generation errors."],
+		"discriminator": [
+			3,
+			170,
+			41,
+			132,
+			72,
+			184,
+			252,
+			69
+		],
+		"accounts": [{
+			"name": "responder",
+			"signer": true
+		}],
+		"args": [{
+			"name": "errors",
+			"type": { "vec": { "defined": { "name": "ErrorResponse" } } }
+		}]
+	},
+	{
+		"name": "sign",
+		"docs": ["* @dev Function to request a signature.\n     * @param payload The payload to be signed.\n     * @param key_version The version of the key used for signing.\n     * @param path The derivation path for the user account.\n     * @param algo The algorithm used for signing.\n     * @param dest The response destination.\n     * @param params Additional parameters."],
+		"discriminator": [
+			5,
+			221,
+			155,
+			46,
+			237,
+			91,
+			28,
+			236
+		],
+		"accounts": [
+			{
+				"name": "program_state",
+				"writable": true,
+				"pda": { "seeds": [{
+					"kind": "const",
+					"value": [
+						112,
+						114,
+						111,
+						103,
+						114,
+						97,
+						109,
+						45,
+						115,
+						116,
+						97,
+						116,
+						101
+					]
+				}] }
+			},
+			{
+				"name": "requester",
+				"writable": true,
+				"signer": true
+			},
+			{
+				"name": "fee_payer",
+				"writable": true,
+				"signer": true,
+				"optional": true
+			},
+			{
+				"name": "system_program",
+				"address": "11111111111111111111111111111111"
+			},
+			{
+				"name": "event_authority",
+				"pda": { "seeds": [{
+					"kind": "const",
+					"value": [
+						95,
+						95,
+						101,
+						118,
+						101,
+						110,
+						116,
+						95,
+						97,
+						117,
+						116,
+						104,
+						111,
+						114,
+						105,
+						116,
+						121
+					]
+				}] }
+			},
+			{ "name": "program" }
+		],
+		"args": [
+			{
+				"name": "payload",
+				"type": { "array": ["u8", 32] }
+			},
+			{
+				"name": "key_version",
+				"type": "u32"
+			},
+			{
+				"name": "path",
+				"type": "string"
+			},
+			{
+				"name": "algo",
+				"type": "string"
+			},
+			{
+				"name": "dest",
+				"type": "string"
+			},
+			{
+				"name": "params",
+				"type": "string"
+			}
+		]
+	},
+	{
+		"name": "sign_bidirectional",
+		"docs": ["* @dev Function to initiate bidirectional flow\n     * @param serialized_transaction transaction to be signed\n     * @param caip2_id chain identifier\n     * @param key_version The version of the key used for signing.\n     * @param path The derivation path for the user account.\n     * @param algo The algorithm used for signing.\n     * @param dest The response destination.\n     * @param params Additional parameters.\n     * @param program_id Program ID to callback after execution (not yet enabled).\n     * @param output_deserialization_schema schema for transaction output deserialization\n     * @param respond_serialization_schema serialization schema for respond_bidirectional payload"],
+		"discriminator": [
+			21,
+			104,
+			182,
+			213,
+			189,
+			143,
+			219,
+			48
+		],
+		"accounts": [
+			{
+				"name": "program_state",
+				"writable": true,
+				"pda": { "seeds": [{
+					"kind": "const",
+					"value": [
+						112,
+						114,
+						111,
+						103,
+						114,
+						97,
+						109,
+						45,
+						115,
+						116,
+						97,
+						116,
+						101
+					]
+				}] }
+			},
+			{
+				"name": "requester",
+				"writable": true,
+				"signer": true
+			},
+			{
+				"name": "fee_payer",
+				"writable": true,
+				"signer": true,
+				"optional": true
+			},
+			{
+				"name": "system_program",
+				"address": "11111111111111111111111111111111"
+			},
+			{
+				"name": "instructions",
+				"optional": true
+			},
+			{
+				"name": "event_authority",
+				"pda": { "seeds": [{
+					"kind": "const",
+					"value": [
+						95,
+						95,
+						101,
+						118,
+						101,
+						110,
+						116,
+						95,
+						97,
+						117,
+						116,
+						104,
+						111,
+						114,
+						105,
+						116,
+						121
+					]
+				}] }
+			},
+			{ "name": "program" }
+		],
+		"args": [
+			{
+				"name": "serialized_transaction",
+				"type": "bytes"
+			},
+			{
+				"name": "caip2_id",
+				"type": "string"
+			},
+			{
+				"name": "key_version",
+				"type": "u32"
+			},
+			{
+				"name": "path",
+				"type": "string"
+			},
+			{
+				"name": "algo",
+				"type": "string"
+			},
+			{
+				"name": "dest",
+				"type": "string"
+			},
+			{
+				"name": "params",
+				"type": "string"
+			},
+			{
+				"name": "program_id",
+				"type": "pubkey"
+			},
+			{
+				"name": "output_deserialization_schema",
+				"type": "bytes"
+			},
+			{
+				"name": "respond_serialization_schema",
+				"type": "bytes"
+			}
+		]
+	},
+	{
+		"name": "update_deposit",
+		"docs": ["* @dev Function to set the signature deposit amount.\n     * @param new_deposit The new deposit amount."],
+		"discriminator": [
+			126,
+			116,
+			15,
+			164,
+			238,
+			179,
+			155,
+			59
+		],
+		"accounts": [
+			{
+				"name": "program_state",
+				"writable": true,
+				"pda": { "seeds": [{
+					"kind": "const",
+					"value": [
+						112,
+						114,
+						111,
+						103,
+						114,
+						97,
+						109,
+						45,
+						115,
+						116,
+						97,
+						116,
+						101
+					]
+				}] }
+			},
+			{
+				"name": "admin",
+				"writable": true,
+				"signer": true,
+				"relations": ["program_state"]
+			},
+			{
+				"name": "system_program",
+				"address": "11111111111111111111111111111111"
+			}
+		],
+		"args": [{
+			"name": "new_deposit",
+			"type": "u64"
+		}]
+	},
+	{
+		"name": "withdraw_funds",
+		"docs": ["* @dev Function to withdraw funds from the program.\n     * @param amount The amount to withdraw."],
+		"discriminator": [
+			241,
+			36,
+			29,
+			111,
+			208,
+			31,
+			104,
+			217
+		],
+		"accounts": [
+			{
+				"name": "program_state",
+				"writable": true,
+				"pda": { "seeds": [{
+					"kind": "const",
+					"value": [
+						112,
+						114,
+						111,
+						103,
+						114,
+						97,
+						109,
+						45,
+						115,
+						116,
+						97,
+						116,
+						101
+					]
+				}] }
+			},
+			{
+				"name": "admin",
+				"writable": true,
+				"signer": true,
+				"relations": ["program_state"]
+			},
+			{
+				"name": "recipient",
+				"docs": ["function by checking it is not the zero address."],
+				"writable": true
+			},
+			{
+				"name": "system_program",
+				"address": "11111111111111111111111111111111"
+			}
+		],
+		"args": [{
+			"name": "amount",
+			"type": "u64"
+		}]
+	}
+];
+var accounts = [{
+	"name": "ProgramState",
+	"discriminator": [
+		77,
+		209,
+		137,
+		229,
+		149,
+		67,
+		167,
+		230
+	]
+}];
+var events = [
+	{
+		"name": "DepositUpdatedEvent",
+		"discriminator": [
+			215,
+			193,
+			53,
+			27,
+			221,
+			101,
+			249,
+			108
+		]
+	},
+	{
+		"name": "FundsWithdrawnEvent",
+		"discriminator": [
+			86,
+			232,
+			194,
+			4,
+			211,
+			69,
+			172,
+			202
+		]
+	},
+	{
+		"name": "RespondBidirectionalEvent",
+		"discriminator": [
+			195,
+			195,
+			28,
+			1,
+			102,
+			100,
+			189,
+			234
+		]
+	},
+	{
+		"name": "SignBidirectionalEvent",
+		"discriminator": [
+			135,
+			205,
+			217,
+			152,
+			96,
+			187,
+			11,
+			124
+		]
+	},
+	{
+		"name": "SignatureErrorEvent",
+		"discriminator": [
+			42,
+			28,
+			210,
+			105,
+			9,
+			196,
+			189,
+			51
+		]
+	},
+	{
+		"name": "SignatureRequestedEvent",
+		"discriminator": [
+			171,
+			129,
+			105,
+			91,
+			154,
+			49,
+			160,
+			34
+		]
+	},
+	{
+		"name": "SignatureRespondedEvent",
+		"discriminator": [
+			118,
+			146,
+			248,
+			151,
+			194,
+			93,
+			18,
+			86
+		]
+	}
+];
+var errors = [
+	{
+		"code": 6e3,
+		"name": "InsufficientDeposit",
+		"msg": "Insufficient deposit amount"
+	},
+	{
+		"code": 6001,
+		"name": "InvalidInputLength",
+		"msg": "Arrays must have the same length"
+	},
+	{
+		"code": 6002,
+		"name": "Unauthorized",
+		"msg": "Unauthorized access"
+	},
+	{
+		"code": 6003,
+		"name": "InsufficientFunds",
+		"msg": "Insufficient funds for withdrawal"
+	},
+	{
+		"code": 6004,
+		"name": "InvalidRecipient",
+		"msg": "Invalid recipient address"
+	},
+	{
+		"code": 6005,
+		"name": "InvalidTransaction",
+		"msg": "Invalid transaction data"
+	},
+	{
+		"code": 6006,
+		"name": "MissingInstructionSysvar",
+		"msg": "Missing instruction sysvar"
+	}
+];
+var types = [
+	{
+		"name": "AffinePoint",
+		"type": {
+			"kind": "struct",
+			"fields": [{
+				"name": "x",
+				"type": { "array": ["u8", 32] }
+			}, {
+				"name": "y",
+				"type": { "array": ["u8", 32] }
+			}]
+		}
+	},
+	{
+		"name": "DepositUpdatedEvent",
+		"docs": ["* @dev Emitted when the deposit amount is updated.\n * @param old_deposit The previous deposit amount.\n * @param new_deposit The new deposit amount."],
+		"type": {
+			"kind": "struct",
+			"fields": [{
+				"name": "old_deposit",
+				"type": "u64"
+			}, {
+				"name": "new_deposit",
+				"type": "u64"
+			}]
+		}
+	},
+	{
+		"name": "ErrorResponse",
+		"type": {
+			"kind": "struct",
+			"fields": [{
+				"name": "request_id",
+				"type": { "array": ["u8", 32] }
+			}, {
+				"name": "error_message",
+				"type": "string"
+			}]
+		}
+	},
+	{
+		"name": "FundsWithdrawnEvent",
+		"docs": ["* @dev Emitted when a withdrawal is made.\n * @param amount The amount withdrawn.\n * @param recipient The address of the recipient."],
+		"type": {
+			"kind": "struct",
+			"fields": [{
+				"name": "amount",
+				"type": "u64"
+			}, {
+				"name": "recipient",
+				"type": "pubkey"
+			}]
+		}
+	},
+	{
+		"name": "ProgramState",
+		"type": {
+			"kind": "struct",
+			"fields": [
+				{
+					"name": "admin",
+					"type": "pubkey"
+				},
+				{
+					"name": "signature_deposit",
+					"type": "u64"
+				},
+				{
+					"name": "chain_id",
+					"type": "string"
+				}
+			]
+		}
+	},
+	{
+		"name": "RespondBidirectionalEvent",
+		"docs": ["* @dev Emitted when a read response is received.\n * @param request_id The ID of the request. Must be calculated off-chain.\n * @param responder The address of the responder.\n * @param serialized_output The serialized output.\n * @param signature The signature."],
+		"type": {
+			"kind": "struct",
+			"fields": [
+				{
+					"name": "request_id",
+					"type": { "array": ["u8", 32] }
+				},
+				{
+					"name": "responder",
+					"type": "pubkey"
+				},
+				{
+					"name": "serialized_output",
+					"type": "bytes"
+				},
+				{
+					"name": "signature",
+					"type": { "defined": { "name": "Signature" } }
+				}
+			]
+		}
+	},
+	{
+		"name": "SignBidirectionalEvent",
+		"docs": ["* @dev Emitted when a sign_bidirectional request is made.\n * @param sender The address of the sender.\n * @param serialized_transaction The serialized transaction to be signed.\n * @param caip2_id The SLIP-44 chain ID.\n * @param key_version The version of the key used for signing.\n * @param deposit The deposit amount.\n * @param path The derivation path for the user account.\n * @param algo The algorithm used for signing.\n * @param dest The response destination.\n * @param params Additional parameters.\n * @param program_id Program ID to callback after execution (not yet enabled).\n * @param output_deserialization_schema Schema for transaction output deserialization.\n * @param respond_serialization_schema Serialization schema for respond_bidirectional payload."],
+		"type": {
+			"kind": "struct",
+			"fields": [
+				{
+					"name": "sender",
+					"type": "pubkey"
+				},
+				{
+					"name": "serialized_transaction",
+					"type": "bytes"
+				},
+				{
+					"name": "caip2_id",
+					"type": "string"
+				},
+				{
+					"name": "key_version",
+					"type": "u32"
+				},
+				{
+					"name": "deposit",
+					"type": "u64"
+				},
+				{
+					"name": "path",
+					"type": "string"
+				},
+				{
+					"name": "algo",
+					"type": "string"
+				},
+				{
+					"name": "dest",
+					"type": "string"
+				},
+				{
+					"name": "params",
+					"type": "string"
+				},
+				{
+					"name": "program_id",
+					"type": "pubkey"
+				},
+				{
+					"name": "output_deserialization_schema",
+					"type": "bytes"
+				},
+				{
+					"name": "respond_serialization_schema",
+					"type": "bytes"
+				}
+			]
+		}
+	},
+	{
+		"name": "Signature",
+		"type": {
+			"kind": "struct",
+			"fields": [
+				{
+					"name": "big_r",
+					"type": { "defined": { "name": "AffinePoint" } }
+				},
+				{
+					"name": "s",
+					"type": { "array": ["u8", 32] }
+				},
+				{
+					"name": "recovery_id",
+					"type": "u8"
+				}
+			]
+		}
+	},
+	{
+		"name": "SignatureErrorEvent",
+		"docs": ["* @dev Emitted when a signature error is received.\n * @notice Any address can emit this event. Do not rely on it for business logic.\n * @param request_id The ID of the request. Must be calculated off-chain.\n * @param responder The address of the responder.\n * @param error The error message."],
+		"type": {
+			"kind": "struct",
+			"fields": [
+				{
+					"name": "request_id",
+					"type": { "array": ["u8", 32] }
+				},
+				{
+					"name": "responder",
+					"type": "pubkey"
+				},
+				{
+					"name": "error",
+					"type": "string"
+				}
+			]
+		}
+	},
+	{
+		"name": "SignatureRequestedEvent",
+		"docs": ["* @dev Emitted when a signature is requested.\n * @param sender The address of the sender.\n * @param payload The payload to be signed.\n * @param key_version The version of the key used for signing.\n * @param deposit The deposit amount.\n * @param chain_id The CAIP-2 ID of the blockchain.\n * @param path The derivation path for the user account.\n * @param algo The algorithm used for signing.\n * @param dest The response destination.\n * @param params Additional parameters.\n * @param fee_payer Optional fee payer account."],
+		"type": {
+			"kind": "struct",
+			"fields": [
+				{
+					"name": "sender",
+					"type": "pubkey"
+				},
+				{
+					"name": "payload",
+					"type": { "array": ["u8", 32] }
+				},
+				{
+					"name": "key_version",
+					"type": "u32"
+				},
+				{
+					"name": "deposit",
+					"type": "u64"
+				},
+				{
+					"name": "chain_id",
+					"type": "string"
+				},
+				{
+					"name": "path",
+					"type": "string"
+				},
+				{
+					"name": "algo",
+					"type": "string"
+				},
+				{
+					"name": "dest",
+					"type": "string"
+				},
+				{
+					"name": "params",
+					"type": "string"
+				},
+				{
+					"name": "fee_payer",
+					"type": { "option": "pubkey" }
+				}
+			]
+		}
+	},
+	{
+		"name": "SignatureRespondedEvent",
+		"docs": ["* @dev Emitted when a signature response is received.\n * @notice Any address can emit this event. Clients should always verify the validity of the signature.\n * @param request_id The ID of the request. Must be calculated off-chain.\n * @param responder The address of the responder.\n * @param signature The signature response."],
+		"type": {
+			"kind": "struct",
+			"fields": [
+				{
+					"name": "request_id",
+					"type": { "array": ["u8", 32] }
+				},
+				{
+					"name": "responder",
+					"type": "pubkey"
+				},
+				{
+					"name": "signature",
+					"type": { "defined": { "name": "Signature" } }
+				}
+			]
+		}
+	}
+];
+var chain_signatures_project_default = {
+	address,
+	metadata,
+	instructions,
+	accounts,
+	events,
+	errors,
+	types
+};
+//#endregion
+//#region src/contracts/solana/CpiEventParser.ts
+const EMIT_CPI_INSTRUCTION_DISCRIMINATOR = Buffer.from([
+	228,
+	69,
+	165,
+	46,
+	81,
+	203,
+	154,
+	29
+]);
+var CpiEventParser = class {
+	/**
+	* Parse CPI events from an already-fetched transaction (emit_cpi! pattern).
+	*/
+	static parseCpiEventsFromTransaction(tx, targetProgramId, program) {
+		const events = [];
+		if (!tx?.meta?.innerInstructions) return events;
+		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.push(parsedEvent);
+		}
+		return events;
+	}
+	/**
+	* 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
+			});
+			return this.parseCpiEventsFromTransaction(tx, targetProgramId, program);
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* Parse CPI event from instruction data
+	* Structure: [8 bytes: anchor discriminator][8 bytes: event discriminator][event data]
+	*/
+	static parseInstruction(instructionData, program) {
+		try {
+			const ixData = anchor.utils.bytes.bs58.decode(instructionData);
+			if (ixData.length < 16) return null;
+			const ixDiscriminator = ixData.subarray(0, 8);
+			if (Buffer.compare(ixDiscriminator, EMIT_CPI_INSTRUCTION_DISCRIMINATOR) !== 0) return null;
+			const eventDiscriminator = ixData.subarray(8, 16);
+			if (!program.idl.events?.find((event) => {
+				const idlDiscriminator = Buffer.from(event.discriminator);
+				return Buffer.compare(eventDiscriminator, idlDiscriminator) === 0;
+			})) return null;
+			const fullEventData = ixData.subarray(8);
+			return program.coder.events.decode(anchor.utils.bytes.base64.encode(fullEventData));
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Subscribe to CPI events for a program
+	*/
+	static subscribeToCpiEvents(connection, program, eventHandlers) {
+		return connection.onLogs(program.programId, (logs, context) => {
+			if (logs.err) return;
+			(async () => {
+				const events = await this.fetchAndParseCpiEvents(connection, logs.signature, program.programId.toString(), program);
+				for (const event of events) {
+					const handler = eventHandlers.get(event.name);
+					if (handler) try {
+						await handler(event.data, context.slot);
+					} catch {}
+				}
+			})();
+		}, "confirmed");
+	}
+};
+//#endregion
+//#region src/contracts/solana/utils.ts
+/**
+* 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 = bytesToHex(new Uint8Array(request.payload));
+	return keccak256(encodeAbiParameters(parseAbiParameters("string, bytes, string, uint32, string, string, string, string"), [
+		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 = bytesToHex(new Uint8Array(request.payload));
+	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
+	]));
+}
+//#endregion
+//#region src/contracts/solana/ChainSignaturesContract.ts
+var ChainSignatureContract = class extends ChainSignatureContract$2 {
+	provider;
+	program;
+	programId;
+	rootPublicKey;
+	requesterAddress;
+	_connection;
+	/**
+	* Creates a new instance of the ChainSignatureContract for Solana chains.
+	*
+	* @param args - Configuration options for the contract
+	* @param args.provider - An Anchor Provider for interacting with Solana
+	* @param args.programId - The program ID as a string or PublicKey
+	* @param args.config - Optional configuration
+	* @param args.config.rootPublicKey - Optional root public key. If not provided, it will be derived from the program ID
+	* @param args.config.requesterAddress - Provider wallet address is always the fee payer but requester can be overridden
+	* @param args.config.idl - Optional custom IDL. If not provided, the default ChainSignatures IDL will be used
+	* @param args.config.disableRetryOnRateLimit - If true, disables @solana/web3.js automatic retry on 429 responses. Recommended when using the built-in backfill mechanism.
+	*/
+	constructor(args) {
+		super();
+		this.provider = args.provider;
+		this.requesterAddress = args.config?.requesterAddress ?? this.provider.wallet.publicKey.toString();
+		this.programId = typeof args.programId === "string" ? new PublicKey(args.programId) : args.programId;
+		const idl = args.config?.idl || chain_signatures_project_default;
+		this.program = new Program({
+			...idl,
+			address: this.programId.toString()
+		}, this.provider);
+		const rootPublicKey = args.config?.rootPublicKey || getRootPublicKey(this.programId.toString(), CHAINS.SOLANA);
+		if (!rootPublicKey) throw new Error(`Invalid public key, please provide a valid root public key or program ID`);
+		this.rootPublicKey = normalizeToUncompressedPubKey(rootPublicKey);
+		if (args.config?.disableRetryOnRateLimit !== void 0) this._connection = new Connection(this.provider.connection.rpcEndpoint, {
+			commitment: this.provider.connection.commitment,
+			disableRetryOnRateLimit: args.config.disableRetryOnRateLimit,
+			fetch: async (input, init) => {
+				const res = await globalThis.fetch(input, init);
+				if (res.status === 429) {
+					let method = "unknown";
+					try {
+						const body = JSON.parse(init?.body);
+						method = Array.isArray(body) ? body.map((r) => r.method).join(", ") : body.method ?? "unknown";
+					} catch {}
+					console.warn(`\n[429 TRACE] RPC method: ${method}\n${(/* @__PURE__ */ new Error()).stack}`);
+				}
+				return res;
+			}
+		});
+		else this._connection = this.provider.connection;
+	}
+	/**
+	* Gets the connection, using the override if `disableRetryOnRateLimit` was configured.
+	*/
+	get connection() {
+		return this._connection;
+	}
+	async getCurrentSignatureDeposit() {
+		try {
+			const programStatePDA = await this.getProgramStatePDA();
+			const programState = await this.program.account.programState.fetch(programStatePDA);
+			return BigInt(programState.signatureDeposit.toString());
+		} catch (error) {
+			throw new Error(`Failed to get signature deposit: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+	}
+	/**
+	* Get the Program State PDA
+	*/
+	async getProgramStatePDA() {
+		const [pda] = PublicKey.findProgramAddressSync([new TextEncoder().encode("program-state")], this.programId);
+		return pda;
+	}
+	async getDerivedPublicKey(args) {
+		return deriveChildPublicKey(await this.getPublicKey(), args.predecessor, args.path, KDF_CHAIN_IDS.SOLANA, args.keyVersion);
+	}
+	async getPublicKey() {
+		return this.rootPublicKey;
+	}
+	async getSignRequestInstruction(args, options) {
+		const fixedRemainingAccounts = [{
+			pubkey: PublicKey.findProgramAddressSync([new TextEncoder().encode("__event_authority")], this.program.programId)[0],
+			isWritable: false,
+			isSigner: false
+		}, {
+			pubkey: this.program.programId,
+			isWritable: false,
+			isSigner: false
+		}];
+		return await this.program.methods.sign(Array.from(args.payload), args.key_version, args.path, options?.sign?.algo || "", options?.sign?.dest || "", options?.sign?.params || "").accounts({
+			requester: this.requesterAddress,
+			feePayer: this.provider.wallet.publicKey,
+			program: this.programId
+		}).remainingAccounts([...fixedRemainingAccounts, ...options?.remainingAccounts ?? []]).instruction();
+	}
+	/**
+	* Sends a transaction to the program to request a signature, then
+	* 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 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,
+			dest,
+			params
+		});
+		const instruction = await this.getSignRequestInstruction(args, {
+			sign: {
+				algo,
+				dest,
+				params
+			},
+			remainingAccounts: options?.remainingAccounts
+		});
+		const transaction = new Transaction().add(instruction);
+		transaction.feePayer = this.provider.wallet.publicKey;
+		const hash = await this.sendAndConfirmWithoutWebSocket(transaction, options?.remainingSigners);
+		try {
+			const result = await this.waitForEvent({
+				eventName: "signatureRespondedEvent",
+				requestId,
+				signer: this.programId,
+				afterSignature: hash,
+				timeoutMs,
+				backfillIntervalMs: delay
+			});
+			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) throw error;
+			else throw new SigningError(requestId, { hash }, error instanceof Error ? error : void 0);
+		}
+	}
+	async sendAndConfirmWithoutWebSocket(transaction, signers) {
+		const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+		transaction.recentBlockhash = blockhash;
+		transaction = await this.provider.wallet.signTransaction(transaction);
+		if (signers && signers.length > 0) transaction.partialSign(...signers);
+		const signature = await this.connection.sendRawTransaction(transaction.serialize(), {
+			skipPreflight: false,
+			preflightCommitment: "processed",
+			maxRetries: 3
+		});
+		const startTime = Date.now();
+		const timeout = 3e4;
+		while (Date.now() - startTime < timeout) {
+			const status = await this.connection.getSignatureStatus(signature);
+			if (status.value?.err) throw new Error(`Transaction failed: ${JSON.stringify(status.value.err)}`);
+			if (status.value?.confirmationStatus === "confirmed" || status.value?.confirmationStatus === "finalized") return signature;
+			await new Promise((resolve) => setTimeout(resolve, 2e3));
+		}
+		throw new TransactionExpiredTimeoutError(signature, timeout / 1e3);
+	}
+	/**
+	* Waits for a specific event matching the given requestId by combining
+	* a WebSocket listener (real-time) with polling backfill (resilience).
+	*/
+	async waitForEvent(options) {
+		const { eventName, requestId, signer, afterSignature, timeoutMs = 6e4, backfillIntervalMs = 3e4, backfillLimit = 50, healthCheckIntervalMs = 1e4, 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);
+					});
+					return true;
+				}
+				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 runBackfill = async () => {
+				if (settled) return;
+				const parser = new EventParser(this.program.programId, this.program.coder);
+				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 {}
+			};
+			let lastWsCallbackTime = Date.now();
+			let currentSubId;
+			const subscribeToLogs = () => {
+				const parser = new EventParser(this.program.programId, this.program.coder);
+				currentSubId = this.connection.onLogs(signer, (logs, _context) => {
+					if (settled) return;
+					lastWsCallbackTime = Date.now();
+					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(() => {
+					if (currentSubId !== void 0) this.connection.removeOnLogsListener(currentSubId);
+				});
+			};
+			subscribeToLogs();
+			let fastBackfillId;
+			const startFastBackfill = () => {
+				if (fastBackfillId !== void 0) return;
+				fastBackfillId = setInterval(() => {
+					runBackfill();
+				}, 5e3);
+				cleanupFns.push(() => {
+					if (fastBackfillId !== void 0) {
+						clearInterval(fastBackfillId);
+						fastBackfillId = void 0;
+					}
+				});
+			};
+			const stopFastBackfill = () => {
+				if (fastBackfillId !== void 0) {
+					clearInterval(fastBackfillId);
+					fastBackfillId = void 0;
+				}
+			};
+			const healthCheckId = setInterval(() => {
+				if (settled) return;
+				this.connection.getSlot("confirmed").then(() => {
+					if (Date.now() - lastWsCallbackTime < healthCheckIntervalMs * 3) stopFastBackfill();
+				}).catch(() => {
+					if (currentSubId !== void 0) {
+						this.connection.removeOnLogsListener(currentSubId);
+						currentSubId = void 0;
+					}
+					subscribeToLogs();
+					startFastBackfill();
+				});
+			}, healthCheckIntervalMs);
+			cleanupFns.push(() => {
+				clearInterval(healthCheckId);
+			});
+			const safetyBackfillId = setInterval(() => {
+				runBackfill();
+			}, backfillIntervalMs);
+			cleanupFns.push(() => {
+				clearInterval(safetyBackfillId);
+			});
+		});
+	}
+	mapRespondToResult(data, requestId) {
+		if ("0x" + hex.encode(new Uint8Array(data.requestId)) !== requestId) return void 0;
+		return {
+			r: hex.encode(new Uint8Array(data.signature.bigR.x)),
+			s: hex.encode(new Uint8Array(data.signature.s)),
+			v: data.signature.recoveryId + 27
+		};
+	}
+	mapRespondErrorToResult(data, requestId) {
+		const eventRequestIdHex = "0x" + hex.encode(new Uint8Array(data.requestId));
+		if (eventRequestIdHex !== requestId) return void 0;
+		return {
+			requestId: eventRequestIdHex,
+			error: data.error
+		};
+	}
+	mapRespondBidirectionalToResult(data, requestId) {
+		if ("0x" + hex.encode(new Uint8Array(data.requestId)) !== 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.
+	*/
+	getRequestId(args, options = {
+		algo: "",
+		dest: "",
+		params: ""
+	}) {
+		return getRequestIdRespond({
+			payload: args.payload,
+			path: args.path,
+			keyVersion: args.key_version,
+			algo: options.algo || "",
+			dest: options.dest || "",
+			params: options.params || "",
+			address: this.requesterAddress,
+			chainId: KDF_CHAIN_IDS.SOLANA
+		});
+	}
+};
+//#endregion
+//#region src/contracts/solana/index.ts
+var solana_exports = /* @__PURE__ */ __exportAll({
+	ChainSignatureContract: () => ChainSignatureContract,
+	getRequestIdBidirectional: () => getRequestIdBidirectional,
+	getRequestIdRespond: () => getRequestIdRespond,
+	utils: () => utils
+});
+const utils = {
+	ChainSignaturesContractIdl: chain_signatures_project_exports,
+	errors: errors_exports
+};
+//#endregion
+//#region src/contracts/index.ts
+var contracts_exports = /* @__PURE__ */ __exportAll({
+	ChainSignatureContract: () => ChainSignatureContract$2,
+	evm: () => evm_exports,
+	solana: () => solana_exports
+});
+//#endregion
+export { chain_adapters_exports as chainAdapters, constants_exports as constants, contracts_exports as contracts, utils_exports as utils };