signet.js 0.0.12 → 0.3.0

package/dist/index.cjs

@@ -0,0 +1,3140 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let __scure_base = require("@scure/base");
+let elliptic = require("elliptic");
+elliptic = __toESM(elliptic);
+let viem = require("viem");
+let bitcoinjs_lib = require("bitcoinjs-lib");
+bitcoinjs_lib = __toESM(bitcoinjs_lib);
+let coinselect = require("coinselect");
+coinselect = __toESM(coinselect);
+let __cosmjs_amino = require("@cosmjs/amino");
+let __cosmjs_crypto = require("@cosmjs/crypto");
+let __cosmjs_encoding = require("@cosmjs/encoding");
+let __cosmjs_proto_signing = require("@cosmjs/proto-signing");
+let __cosmjs_stargate = require("@cosmjs/stargate");
+let bech32 = require("bech32");
+let cosmjs_types_cosmos_tx_signing_v1beta1_signing_js = require("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
+let cosmjs_types_cosmos_tx_v1beta1_tx_js = require("cosmjs-types/cosmos/tx/v1beta1/tx.js");
+let chain_registry = require("chain-registry");
+let bn_js = require("bn.js");
+bn_js = __toESM(bn_js);
+require("viem/chains");
+let __coral_xyz_anchor = require("@coral-xyz/anchor");
+__coral_xyz_anchor = __toESM(__coral_xyz_anchor);
+let __solana_web3_js = require("@solana/web3.js");
+
+//#region src/constants.ts
+var constants_exports = /* @__PURE__ */ __export({
+	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"
+};
+/**
+* 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"
+};
+/**
+* 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"
+	}
+};
+
+//#endregion
+//#region src/utils/cryptography.ts
+var cryptography_exports = /* @__PURE__ */ __export({
+	compressPubKey: () => compressPubKey,
+	deriveChildPublicKey: () => deriveChildPublicKey,
+	najToUncompressedPubKeySEC1: () => najToUncompressedPubKeySEC1,
+	toRSV: () => toRSV,
+	verifyRecoveredAddress: () => verifyRecoveredAddress
+});
+const { ec: EC } = elliptic.default;
+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;
+};
+/**
+* Converts a NAJ public key to an uncompressed SEC1 public key.
+*
+* @param najPublicKey - The NAJ public key to convert (e.g. secp 256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5)
+* @returns The uncompressed SEC1 public key (e.g. 04 || x || y)
+*/
+const najToUncompressedPubKeySEC1 = (najPublicKey) => {
+	const decodedKey = __scure_base.base58.decode(najPublicKey.split(":")[1]);
+	return `04${Buffer.from(decodedKey).toString("hex")}`;
+};
+const EPSILON_DERIVATION_PREFIX_V2 = "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 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) {
+	const ec = new EC("secp256k1");
+	const derivationPath = `${EPSILON_DERIVATION_PREFIX_V2}:${chainId}:${predecessorId}:${path}`;
+	let scalarHex = "";
+	if (chainId === KDF_CHAIN_IDS.ETHEREUM) scalarHex = (0, viem.keccak256)(Buffer.from(derivationPath)).slice(2);
+	else if (chainId === KDF_CHAIN_IDS.SOLANA) scalarHex = (0, viem.keccak256)(Buffer.from(derivationPath)).slice(2);
+	else throw new Error("Invalid chain ID");
+	const x = rootUncompressedPubKeySEC1.substring(2, 66);
+	const y = rootUncompressedPubKeySEC1.substring(66);
+	const oldPublicKeyPoint = ec.curve.point(x, y);
+	const scalarTimesG = ec.g.mul(scalarHex);
+	const newPublicKeyPoint = oldPublicKeyPoint.add(scalarTimesG);
+	return `04${newPublicKeyPoint.getX().toString("hex").padStart(64, "0")}${newPublicKeyPoint.getY().toString("hex").padStart(64, "0")}`;
+}
+/**
+* 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: (0, viem.createPublicClient)({ transport: (0, viem.http)("https://dontcare.com") }),
+			contract
+		}).deriveAddressAndPublicKey(requesterAddress, path, keyVersion);
+		return (await (0, viem.recoverAddress)({
+			hash: new Uint8Array(payload),
+			signature: {
+				r: `0x${signature.r}`,
+				s: `0x${signature.s}`,
+				yParity: signature.v
+			}
+		})).toLowerCase() === expectedAddress.toLowerCase();
+	} catch (error) {
+		console.error("Signature verification failed:", error);
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ __export({ 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 {
+	/**
+	* 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, ...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 (0, viem.concatHex)([
+			r,
+			s,
+			(0, viem.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");
+		const publicKeyNoPrefix = uncompressedPubKey.startsWith("04") ? uncompressedPubKey.slice(2) : uncompressedPubKey;
+		return {
+			address: (0, viem.getAddress)(`0x${(0, viem.keccak256)(Buffer.from(publicKeyNoPrefix, "hex")).slice(-40)}`),
+			publicKey: uncompressedPubKey
+		};
+	}
+	async getBalance(address$1) {
+		return {
+			balance: await this.client.getBalance({ address: address$1 }),
+			decimals: 18
+		};
+	}
+	serializeTransaction(transaction) {
+		return (0, viem.serializeTransaction)(transaction);
+	}
+	deserializeTransaction(serialized) {
+		return (0, viem.parseTransaction)(serialized);
+	}
+	async prepareTransactionForSigning(transactionRequest) {
+		const transaction = await this.attachGasAndNonce(transactionRequest);
+		const txHash = (0, viem.toBytes)((0, viem.keccak256)((0, viem.serializeTransaction)(transaction)));
+		return {
+			transaction,
+			hashesToSign: [Array.from(txHash)]
+		};
+	}
+	async prepareMessageForSigning(message) {
+		return { hashToSign: Array.from((0, viem.toBytes)((0, viem.hashMessage)(message))) };
+	}
+	async prepareTypedDataForSigning(typedDataRequest) {
+		return { hashToSign: Array.from((0, viem.toBytes)((0, viem.hashTypedData)(typedDataRequest))) };
+	}
+	/**
+	* This implementation is a common step for Biconomy and Alchemy.
+	* Key differences between implementations:
+	* - Signature format: Biconomy omits 0x00 prefix when concatenating, Alchemy includes it
+	* - Version support: Biconomy only supports v6, Alchemy supports both v6 and v7
+	* - Validation: Biconomy uses modules for signature validation, Alchemy uses built-in validation
+	*/
+	async prepareUserOpForSigning(userOp, entryPointAddress, chainIdArgs) {
+		const chainId = chainIdArgs ?? await this.client.getChainId();
+		const entryPoint = entryPointAddress || "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+		const userOpHash = (0, viem.keccak256)((0, viem.encodeAbiParameters)([
+			{ type: "bytes32" },
+			{ type: "address" },
+			{ type: "uint256" }
+		], [
+			(0, viem.keccak256)((0, viem.encodeAbiParameters)([
+				{ type: "address" },
+				{ type: "uint256" },
+				{ type: "bytes32" },
+				{ type: "bytes32" },
+				{ type: "bytes32" },
+				{ type: "uint256" },
+				{ type: "bytes32" },
+				{ type: "bytes32" }
+			], [
+				userOp.sender,
+				(0, viem.hexToBigInt)(userOp.nonce),
+				(0, viem.keccak256)("factory" in userOp && "factoryData" in userOp && userOp.factory && userOp.factoryData ? (0, viem.concat)([userOp.factory, userOp.factoryData]) : "initCode" in userOp ? userOp.initCode : "0x"),
+				(0, viem.keccak256)(userOp.callData),
+				(0, viem.concat)([(0, viem.pad)(userOp.verificationGasLimit, { size: 16 }), (0, viem.pad)(userOp.callGasLimit, { size: 16 })]),
+				(0, viem.hexToBigInt)(userOp.preVerificationGas),
+				(0, viem.concat)([(0, viem.pad)(userOp.maxPriorityFeePerGas, { size: 16 }), (0, viem.pad)(userOp.maxFeePerGas, { size: 16 })]),
+				(0, viem.keccak256)("paymaster" in userOp && userOp.paymaster && (0, viem.isAddress)(userOp.paymaster) ? (0, viem.concat)([
+					userOp.paymaster,
+					(0, viem.pad)(userOp.paymasterVerificationGasLimit, { size: 16 }),
+					(0, viem.pad)(userOp.paymasterPostOpGasLimit, { size: 16 }),
+					userOp.paymasterData
+				]) : "paymasterAndData" in userOp ? userOp.paymasterAndData : "0x")
+			])),
+			entryPoint,
+			BigInt(chainId)
+		]));
+		return {
+			userOp,
+			hashToSign: Array.from((0, viem.toBytes)((0, viem.hashMessage)({ raw: userOpHash })))
+		};
+	}
+	finalizeTransactionSigning({ transaction, rsvSignatures }) {
+		return (0, viem.serializeTransaction)(transaction, this.transformRSVSignature(rsvSignatures[0]));
+	}
+	finalizeMessageSigning({ rsvSignature }) {
+		return this.assembleSignature(rsvSignature);
+	}
+	finalizeTypedDataSigning({ rsvSignature }) {
+		return this.assembleSignature(rsvSignature);
+	}
+	finalizeUserOpSigning({ userOp, rsvSignature }) {
+		const { r, s, yParity } = this.transformRSVSignature(rsvSignature);
+		if (yParity === void 0) throw new Error("Missing yParity");
+		return {
+			...userOp,
+			signature: (0, viem.concatHex)([
+				"0x00",
+				r,
+				s,
+				(0, viem.numberToHex)(Number(yParity + 27), { size: 1 })
+			])
+		};
+	}
+	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.");
+		}
+	}
+};
+
+//#endregion
+//#region src/chain-adapters/EVM/index.ts
+var EVM_exports = /* @__PURE__ */ __export({
+	EVM: () => EVM,
+	fetchEVMFeeProperties: () => fetchEVMFeeProperties
+});
+
+//#endregion
+//#region src/chain-adapters/Bitcoin/utils.ts
+function parseBTCNetwork(network) {
+	switch (network.toLowerCase()) {
+		case "mainnet": return bitcoinjs_lib.networks.bitcoin;
+		case "testnet": return bitcoinjs_lib.networks.testnet;
+		case "regtest": return bitcoinjs_lib.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 {
+		this.SATOSHIS_PER_BTC = 1e8;
+	}
+	/**
+	* 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 bitcoinjs_lib.Transaction();
+		data.vout.forEach((vout) => {
+			const scriptPubKey = Buffer.from(vout.scriptpubkey, "hex");
+			tx.addOutput(scriptPubKey, Number(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 bitcoinjs_lib.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: input.value
+				}
+			});
+		}));
+		outputs.forEach((out) => {
+			if ("address" in out) psbt.addOutput({
+				address: out.address,
+				value: out.value
+			});
+			else if ("script" in out) psbt.addOutput({
+				script: out.script,
+				value: out.value
+			});
+			else if (transactionRequest.from !== void 0) psbt.addOutput({
+				value: Number(out.value),
+				address: transactionRequest.from
+			});
+		});
+		return psbt;
+	}
+	async getBalance(address$1) {
+		return {
+			balance: BigInt(await this.btcRpcAdapter.getBalance(address$1)),
+			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: address$1 } = bitcoinjs_lib.payments.p2wpkh({
+			pubkey: publicKeyBuffer,
+			network
+		});
+		if (!address$1) throw new Error("Failed to generate Bitcoin address");
+		return {
+			address: address$1,
+			publicKey: derivedKey
+		};
+	}
+	serializeTransaction(transaction) {
+		return JSON.stringify({
+			psbt: transaction.psbt.toHex(),
+			publicKey: transaction.publicKey
+		});
+	}
+	deserializeTransaction(serialized) {
+		const transactionJSON = JSON.parse(serialized);
+		return {
+			psbt: bitcoinjs_lib.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 Buffer.alloc(64);
+			}
+		});
+		for (let index = 0; index < psbt.inputCount; index++) psbt.signInput(index, mockKeyPair(index));
+		return {
+			transaction: {
+				psbt: bitcoinjs_lib.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 {
+	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$1) {
+		try {
+			return await (await fetch(`${this.providerUrl}/address/${address$1}/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 = (0, coinselect.default)(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$1) {
+		const data = await (await fetch(`${this.providerUrl}/address/${address$1}`)).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__ */ __export({
+	BTCRpcAdapter: () => BTCRpcAdapter,
+	BTCRpcAdapters: () => BTCRpcAdapters,
+	Bitcoin: () => Bitcoin
+});
+
+//#endregion
+//#region src/chain-adapters/Cosmos/utils.ts
+const fetchChainInfo = async (chainId) => {
+	const chainInfo = chain_registry.chains.find((chain) => chain.chain_id === chainId);
+	if (!chainInfo) throw new Error(`Chain info not found for chainId: ${chainId}`);
+	const { bech32_prefix: prefix, chain_id: expectedChainId } = chainInfo;
+	const denom = chainInfo.staking?.staking_tokens?.[0]?.denom;
+	const rpcUrl = chainInfo.apis?.rpc?.[0]?.address;
+	const restUrl = chainInfo.apis?.rest?.[0]?.address;
+	const gasPrice = chainInfo.fees?.fee_tokens?.[0]?.average_gas_price;
+	if (!prefix || !denom || !rpcUrl || !restUrl || !expectedChainId || gasPrice === void 0) throw new Error(`Missing required chain information for ${chainInfo.chain_name}`);
+	const asset = chain_registry.assets.find((asset$1) => asset$1.chain_name === chainInfo.chain_name)?.assets.find((asset$1) => asset$1.base === denom);
+	const decimals = asset?.denom_units.find((unit) => unit.denom === asset.display)?.exponent;
+	if (decimals === void 0) throw new Error(`Could not find decimals for ${denom} on chain ${chainInfo.chain_name}`);
+	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 {
+	/**
+	* 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 __cosmjs_proto_signing.Registry();
+		this.chainId = chainId;
+		this.endpoints = endpoints;
+	}
+	transformRSVSignature(rsvSignature) {
+		return new Uint8Array([...(0, __cosmjs_encoding.fromHex)(rsvSignature.r), ...(0, __cosmjs_encoding.fromHex)(rsvSignature.s)]);
+	}
+	async getChainInfo() {
+		return {
+			...await fetchChainInfo(this.chainId),
+			...this.endpoints
+		};
+	}
+	async getBalance(address$1) {
+		try {
+			const { restUrl, denom, decimals } = await this.getChainInfo();
+			const response = await fetch(`${restUrl}/cosmos/bank/v1beta1/balances/${address$1}`);
+			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");
+		}
+	}
+	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);
+		const ripemd160Hash = (0, __cosmjs_crypto.ripemd160)((0, __cosmjs_crypto.sha256)((0, __cosmjs_encoding.fromHex)(derivedKey)));
+		return {
+			address: bech32.bech32.encode(prefix, bech32.bech32.toWords(ripemd160Hash)),
+			publicKey: derivedKey
+		};
+	}
+	serializeTransaction(transaction) {
+		return (0, __cosmjs_encoding.toBase64)(cosmjs_types_cosmos_tx_v1beta1_tx_js.TxRaw.encode(transaction).finish());
+	}
+	deserializeTransaction(serialized) {
+		return cosmjs_types_cosmos_tx_v1beta1_tx_js.TxRaw.decode((0, __cosmjs_encoding.fromBase64)(serialized));
+	}
+	async prepareTransactionForSigning(transactionRequest) {
+		const { denom, rpcUrl, gasPrice } = await this.getChainInfo();
+		const publicKeyBytes = (0, __cosmjs_encoding.fromHex)(transactionRequest.publicKey);
+		const fee = (0, __cosmjs_stargate.calculateFee)(transactionRequest.gas || 2e5, __cosmjs_stargate.GasPrice.fromString(`${gasPrice}${denom}`));
+		const accountOnChain = await (await __cosmjs_stargate.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 = (0, __cosmjs_proto_signing.makeAuthInfoBytes)([{
+			pubkey: (0, __cosmjs_proto_signing.encodePubkey)((0, __cosmjs_amino.encodeSecp256k1Pubkey)(publicKeyBytes)),
+			sequence
+		}], fee.amount, Number(fee.gas), void 0, void 0, cosmjs_types_cosmos_tx_signing_v1beta1_signing_js.SignMode.SIGN_MODE_DIRECT);
+		const signBytes = (0, __cosmjs_proto_signing.makeSignBytes)((0, __cosmjs_proto_signing.makeSignDoc)(txBodyBytes, authInfoBytes, this.chainId, accountNumber));
+		const payload = Array.from((0, __cosmjs_crypto.sha256)(signBytes));
+		return {
+			transaction: cosmjs_types_cosmos_tx_v1beta1_tx_js.TxRaw.fromPartial({
+				bodyBytes: txBodyBytes,
+				authInfoBytes,
+				signatures: []
+			}),
+			hashesToSign: [payload]
+		};
+	}
+	finalizeTransactionSigning({ transaction, rsvSignatures }) {
+		transaction.signatures = rsvSignatures.map((sig) => this.transformRSVSignature(sig));
+		const txBytes = cosmjs_types_cosmos_tx_v1beta1_tx_js.TxRaw.encode(transaction).finish();
+		return Buffer.from(txBytes).toString("hex");
+	}
+	async broadcastTx(txSerialized) {
+		try {
+			const { rpcUrl } = await this.getChainInfo();
+			const client = await __cosmjs_stargate.StargateClient.connect(rpcUrl);
+			const txBytes = (0, __cosmjs_encoding.fromHex)(txSerialized);
+			const broadcastResponse = await client.broadcastTx(txBytes);
+			if (broadcastResponse.code !== 0) throw new Error(`Broadcast error: ${broadcastResponse.rawLog}`);
+			return broadcastResponse.transactionHash;
+		} catch (error) {
+			console.error("Transaction broadcast failed:", error);
+			throw new Error("Failed to broadcast transaction.");
+		}
+	}
+};
+
+//#endregion
+//#region src/chain-adapters/Cosmos/index.ts
+var Cosmos_exports = /* @__PURE__ */ __export({ Cosmos: () => Cosmos });
+
+//#endregion
+//#region src/chain-adapters/index.ts
+var chain_adapters_exports = /* @__PURE__ */ __export({
+	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 = class extends BaseChainSignatureContract {};
+
+//#endregion
+//#region src/contracts/evm/ChainSignaturesContractABI.ts
+var ChainSignaturesContractABI_exports = /* @__PURE__ */ __export({ 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__ */ __export({
+	ChainSignatureError: () => ChainSignatureError,
+	SignatureContractError: () => SignatureContractError$1,
+	SignatureNotFoundError: () => SignatureNotFoundError$1,
+	SigningError: () => SigningError$1
+});
+var ChainSignatureError = class extends Error {
+	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$1 = class extends ChainSignatureError {
+	constructor(errorCode, requestId, receipt) {
+		super(`Signature error: ${errorCode}`, requestId, receipt);
+		this.name = "SignatureContractError";
+		this.errorCode = errorCode;
+	}
+};
+var SigningError$1 = class extends ChainSignatureError {
+	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$1]) => address$1.toLowerCase() === contractAddress.toLowerCase())?.[0];
+	if (environment) return ROOT_PUBLIC_KEYS[environment];
+};
+
+//#endregion
+//#region src/contracts/evm/utils.ts
+const getRequestId = (request) => {
+	return (0, viem.keccak256)((0, viem.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$2 = class extends ChainSignatureContract {
+	/**
+	* 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 = rootPublicKey;
+	}
+	async getCurrentSignatureDeposit() {
+		return new bn_js.default((await this.publicClient.readContract({
+			address: this.contractAddress,
+			abi,
+			functionName: "getSignatureDeposit"
+		})).toString());
+	}
+	async getDerivedPublicKey(args) {
+		return deriveChildPublicKey(await this.getPublicKey(), args.predecessor.toLowerCase(), args.path, KDF_CHAIN_IDS.ETHEREUM, args.keyVersion);
+	}
+	async getPublicKey() {
+		return najToUncompressedPubKeySEC1(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$1(pollResult.error, requestId, receipt);
+			return pollResult;
+		} catch (error) {
+			if (error instanceof SignatureNotFoundError$1 || error instanceof SignatureContractError$1) 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 (0, viem.withRetry)(async () => {
+			const result$1 = await this.getSignatureFromEvents(requestId, fromBlock);
+			if (result$1) {
+				if (!await verifyRecoveredAddress(result$1, payload, this.walletClient.account?.address, path, this, keyVersion)) throw new Error("Signature not found yet");
+				return result$1;
+			} 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: `0x${Buffer.from(args.payload).toString("hex")}`,
+			path: args.path,
+			keyVersion: args.key_version,
+			algo: options.algo ?? "",
+			dest: options.dest ?? "",
+			params: options.params ?? ""
+		};
+		return {
+			target: this.contractAddress,
+			data: (0, viem.encodeFunctionData)({
+				abi,
+				functionName: "sign",
+				args: [request]
+			}),
+			value: BigInt((await this.getCurrentSignatureDeposit()).toString())
+		};
+	}
+	/**
+	* 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: payload: `0x${Buffer.from(args.payload).toString('hex')}`,,
+	*   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 getRequestId({
+			payload: `0x${Buffer.from(args.payload).toString("hex")}`,
+			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__ */ __export({
+	ChainSignatureContract: () => ChainSignatureContract$2,
+	utils: () => utils$1
+});
+const utils$1 = {
+	ChainSignaturesContractABI: ChainSignaturesContractABI_exports,
+	errors: errors_exports$1
+};
+
+//#endregion
+//#region src/contracts/solana/errors.ts
+var errors_exports = /* @__PURE__ */ __export({
+	ResponseError: () => ResponseError,
+	SignatureContractError: () => SignatureContractError,
+	SignatureNotFoundError: () => SignatureNotFoundError,
+	SigningError: () => SigningError
+});
+var SignatureNotFoundError = class extends Error {
+	constructor(requestId, metadata$1) {
+		const message = requestId ? `Signature not found for request ID: ${requestId}` : "Signature not found";
+		super(message);
+		this.name = "SignatureNotFoundError";
+		this.requestId = requestId;
+		this.hash = metadata$1?.hash;
+	}
+};
+var SignatureContractError = class extends Error {
+	constructor(message, requestId, metadata$1) {
+		super(message);
+		this.name = "SignatureContractError";
+		this.requestId = requestId;
+		this.hash = metadata$1?.hash;
+	}
+};
+var SigningError = class extends Error {
+	constructor(requestId, metadata$1, originalError) {
+		super(`Signing error for request ID: ${requestId}`);
+		this.name = "SigningError";
+		this.requestId = requestId;
+		this.hash = metadata$1?.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__ */ __export({
+	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$1 = [];
+		if (!tx?.meta?.innerInstructions) return events$1;
+		for (const innerIxSet of tx.meta.innerInstructions) for (const instruction of innerIxSet.instructions) {
+			if (!("programId" in instruction) || !("data" in instruction)) continue;
+			if (instruction.programId.toString() !== targetProgramId) continue;
+			const parsedEvent = this.parseInstruction(instruction.data, program);
+			if (parsedEvent) events$1.push(parsedEvent);
+		}
+		return events$1;
+	}
+	/**
+	* Fetch a transaction by signature and parse its CPI events.
+	* Used by the subscription path where only the signature is available.
+	*/
+	static async fetchAndParseCpiEvents(connection, signature, targetProgramId, program) {
+		try {
+			const tx = await connection.getParsedTransaction(signature, {
+				commitment: "confirmed",
+				maxSupportedTransactionVersion: 0
+			});
+			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 = __coral_xyz_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(__coral_xyz_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$1 = await this.fetchAndParseCpiEvents(connection, logs.signature, program.programId.toString(), program);
+				for (const event of events$1) {
+					const handler = eventHandlers.get(event.name);
+					if (handler) try {
+						await handler(event.data, context.slot);
+					} catch {}
+				}
+			})();
+		}, "confirmed");
+	}
+};
+
+//#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");
+	return (0, viem.keccak256)((0, viem.encodeAbiParameters)((0, viem.parseAbiParameters)("string, bytes, string, uint32, string, string, string, string"), [
+		address$1,
+		payloadHex,
+		path,
+		keyVersion,
+		chainId,
+		algo,
+		dest,
+		params
+	]));
+}
+
+//#endregion
+//#region src/contracts/solana/ChainSignaturesContract.ts
+var ChainSignatureContract$1 = class extends ChainSignatureContract {
+	/**
+	* 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
+	*/
+	constructor(args) {
+		super();
+		this.provider = args.provider;
+		this.requesterAddress = args.config?.requesterAddress ?? this.provider.wallet.publicKey.toString();
+		this.programId = typeof args.programId === "string" ? new __solana_web3_js.PublicKey(args.programId) : args.programId;
+		this.program = new __coral_xyz_anchor.Program({
+			...args.config?.idl || chain_signatures_project_default,
+			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 = rootPublicKey;
+	}
+	/**
+	* Gets the connection from the provider
+	*/
+	get connection() {
+		return this.provider.connection;
+	}
+	async getCurrentSignatureDeposit() {
+		try {
+			const programStatePDA = await this.getProgramStatePDA();
+			return new bn_js.default((await this.program.account.programState.fetch(programStatePDA)).signatureDeposit.toString());
+		} catch (error) {
+			throw new Error(`Failed to get signature deposit: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Get the Program State PDA
+	*/
+	async getProgramStatePDA() {
+		const [pda] = __solana_web3_js.PublicKey.findProgramAddressSync([Buffer.from("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 najToUncompressedPubKeySEC1(this.rootPublicKey);
+	}
+	async getSignRequestInstruction(args, options) {
+		const fixedRemainingAccounts = [{
+			pubkey: __solana_web3_js.PublicKey.findProgramAddressSync([Buffer.from("__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 __solana_web3_js.Transaction().add(instruction);
+		transaction.feePayer = this.provider.wallet.publicKey;
+		const hash = await this.sendAndConfirmWithoutWebSocket(transaction, options?.remainingSigners);
+		const controller = new AbortController();
+		const successPromise = this.waitForEvent({
+			eventName: "signatureRespondedEvent",
+			requestId,
+			signer: this.programId,
+			afterSignature: hash,
+			timeoutMs,
+			backfillIntervalMs: delay,
+			signal: controller.signal
+		});
+		const errorPromise = this.waitForEvent({
+			eventName: "signatureErrorEvent",
+			requestId,
+			signer: this.programId,
+			afterSignature: hash,
+			timeoutMs,
+			backfillIntervalMs: delay,
+			signal: controller.signal
+		}).then((err) => {
+			throw new SignatureContractError(err.error, requestId, { hash });
+		});
+		successPromise.catch(() => {});
+		errorPromise.catch(() => {});
+		try {
+			const result = await Promise.race([successPromise, errorPromise]);
+			if (!await verifyRecoveredAddress(result, args.payload, this.requesterAddress, args.path, this, args.key_version)) throw new SigningError(requestId, { hash }, /* @__PURE__ */ new Error("Signature verification failed: recovered address does not match expected address"));
+			return result;
+		} catch (error) {
+			if (error instanceof SignatureNotFoundError || error instanceof SignatureContractError) throw error;
+			else throw new SigningError(requestId, { hash }, error instanceof Error ? error : void 0);
+		} finally {
+			controller.abort();
+		}
+	}
+	async sendAndConfirmWithoutWebSocket(transaction, signers) {
+		const { blockhash } = await this.provider.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.provider.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.provider.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 __solana_web3_js.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 = 5e3, backfillLimit = 50, signal } = options;
+		return await new Promise((resolve, reject) => {
+			let settled = false;
+			const seenSignatures = /* @__PURE__ */ new Set();
+			let lastCheckedSignature = afterSignature;
+			const cleanupFns = [];
+			const cleanup = () => {
+				for (const fn of cleanupFns) try {
+					fn();
+				} catch {}
+			};
+			const settle = (action) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				action();
+			};
+			const processEvent = (name, data, txSignature) => {
+				if (settled) return false;
+				if (txSignature && seenSignatures.has(txSignature)) return false;
+				if (txSignature) seenSignatures.add(txSignature);
+				if (name !== eventName) return false;
+				const result = this.mapEventForName(eventName, data, requestId);
+				if (result !== void 0) {
+					settle(() => {
+						resolve(result);
+					});
+					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 parser = new __coral_xyz_anchor.EventParser(this.program.programId, this.program.coder);
+			const subId = this.connection.onLogs(signer, (logs, _context) => {
+				if (settled) return;
+				if (logs.err) return;
+				for (const evt of parser.parseLogs(logs.logs)) {
+					if (!evt) continue;
+					if (processEvent(evt.name, evt.data, logs.signature)) return;
+				}
+				CpiEventParser.fetchAndParseCpiEvents(this.connection, logs.signature, this.programId.toString(), this.program).then((cpiEvents) => {
+					for (const event of cpiEvents) if (processEvent(event.name, event.data, logs.signature)) return;
+				});
+			}, "confirmed");
+			cleanupFns.push(() => {
+				this.connection.removeOnLogsListener(subId);
+			});
+			const runBackfill = async () => {
+				if (settled) return;
+				try {
+					const signatures = await this.connection.getSignaturesForAddress(signer, {
+						until: lastCheckedSignature,
+						limit: backfillLimit
+					}, "confirmed");
+					if (signatures.length > 0) lastCheckedSignature = signatures[0].signature;
+					for (const sig of signatures) {
+						if (settled) return;
+						if (seenSignatures.has(sig.signature)) continue;
+						const tx = await this.connection.getParsedTransaction(sig.signature, {
+							commitment: "confirmed",
+							maxSupportedTransactionVersion: 0
+						});
+						if (!tx) continue;
+						const cpiEvents = CpiEventParser.parseCpiEventsFromTransaction(tx, this.programId.toString(), this.program);
+						for (const event of cpiEvents) if (processEvent(event.name, event.data, sig.signature)) return;
+						const logs = tx.meta?.logMessages;
+						if (logs) for (const evt of parser.parseLogs(logs)) {
+							if (!evt) continue;
+							if (processEvent(evt.name, evt.data, sig.signature)) return;
+						}
+					}
+				} catch {}
+			};
+			runBackfill();
+			const intervalId = setInterval(() => {
+				runBackfill();
+			}, backfillIntervalMs);
+			cleanupFns.push(() => {
+				clearInterval(intervalId);
+			});
+		});
+	}
+	mapRespondToResult(data, requestId) {
+		if ("0x" + Buffer.from(data.requestId).toString("hex") !== requestId) return void 0;
+		return {
+			r: Buffer.from(data.signature.bigR.x).toString("hex"),
+			s: Buffer.from(data.signature.s).toString("hex"),
+			v: data.signature.recoveryId + 27
+		};
+	}
+	mapRespondErrorToResult(data, requestId) {
+		const eventRequestIdHex = "0x" + Buffer.from(data.requestId).toString("hex");
+		if (eventRequestIdHex !== requestId) return void 0;
+		return {
+			requestId: eventRequestIdHex,
+			error: data.error
+		};
+	}
+	mapRespondBidirectionalToResult(data, requestId) {
+		if ("0x" + Buffer.from(data.requestId).toString("hex") !== requestId) return void 0;
+		return {
+			serializedOutput: data.serializedOutput,
+			signature: data.signature
+		};
+	}
+	mapEventForName(eventName, data, requestId) {
+		switch (eventName) {
+			case "signatureRespondedEvent": return this.mapRespondToResult(data, requestId);
+			case "signatureErrorEvent": return this.mapRespondErrorToResult(data, requestId);
+			case "respondBidirectionalEvent": return this.mapRespondBidirectionalToResult(data, requestId);
+			default: return;
+		}
+	}
+	/**
+	* Generates the request ID for a signature request allowing to track the response.
+	*/
+	getRequestId(args, options = {
+		algo: "",
+		dest: "",
+		params: ""
+	}) {
+		return generateRequestIdSolana({
+			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__ */ __export({
+	ChainSignatureContract: () => ChainSignatureContract$1,
+	utils: () => utils
+});
+const utils = {
+	ChainSignaturesContractIdl: chain_signatures_project_exports,
+	errors: errors_exports
+};
+
+//#endregion
+//#region src/contracts/index.ts
+var contracts_exports = /* @__PURE__ */ __export({
+	ChainSignatureContract: () => ChainSignatureContract,
+	evm: () => evm_exports,
+	solana: () => solana_exports
+});
+
+//#endregion
+Object.defineProperty(exports, 'chainAdapters', {
+  enumerable: true,
+  get: function () {
+    return chain_adapters_exports;
+  }
+});
+Object.defineProperty(exports, 'constants', {
+  enumerable: true,
+  get: function () {
+    return constants_exports;
+  }
+});
+Object.defineProperty(exports, 'contracts', {
+  enumerable: true,
+  get: function () {
+    return contracts_exports;
+  }
+});
+Object.defineProperty(exports, 'utils', {
+  enumerable: true,
+  get: function () {
+    return utils_exports;
+  }
+});