@sig-net/signet.js 0.5.0-rc1

package/dist/index.d.cts

@@ -0,0 +1,2098 @@
+import { Address, Hash, Hex, PublicClient, SignableMessage, TransactionReceipt, TransactionRequest, TypedDataDefinition, WalletClient } from "viem";
+import * as bitcoin from "bitcoinjs-lib";
+import { EncodeObject } from "@cosmjs/proto-signing";
+import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { AnchorProvider, Idl } from "@coral-xyz/anchor";
+import { AccountMeta, Connection, PublicKey, Signer, TransactionInstruction } from "@solana/web3.js";
+
+//#region \0rolldown/runtime.js
+//#endregion
+//#region src/contracts/ChainSignatureContract.d.ts
+interface SignArgs {
+  /** The payload to sign as an array of 32 bytes */
+  payload: number[];
+  /** The derivation path for key generation */
+  path: string;
+  /** Key version for derivation (must be >= 1; v0 legacy format is not supported) */
+  key_version: number;
+}
+/**
+ * Base contract interface required for compatibility with ChainAdapter instances like EVM and Bitcoin.
+ *
+ * See {@link EVM} and {@link Bitcoin} for example implementations.
+ */
+declare abstract class BaseChainSignatureContract {
+  /**
+   * Gets the current signature deposit required by the contract.
+   * This deposit amount helps manage network congestion.
+   *
+   * @returns Promise resolving to the required deposit amount as a BigNumber
+   */
+  abstract getCurrentSignatureDeposit(): Promise<bigint>;
+  /**
+   * Derives a child public key using a\ derivation path and predecessor.
+   *
+   * @param args - Arguments for key derivation
+   * @param args.path - The string path to use derive the key
+   * @param args.predecessor - The id/address of the account requesting signature
+   * @param args.keyVersion - Key version for derivation (must be >= 1; v0 legacy format is not supported)
+   * @returns Promise resolving to the derived SEC1 uncompressed public key
+   */
+  abstract getDerivedPublicKey(args: {
+    path: string;
+    predecessor: string;
+    keyVersion: number;
+  } & Record<string, unknown>): Promise<UncompressedPubKeySEC1>;
+}
+/**
+ * Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
+ */
+declare abstract class ChainSignatureContract$2 extends BaseChainSignatureContract {
+  /**
+   * Signs a payload using Sig Network MPC.
+   *
+   * @param args - Arguments for the signing operation
+   * @param args.payload - The data to sign as an array of 32 bytes
+   * @param args.path - The string path to use derive the key
+   * @param args.key_version - Version of the key to use
+   * @returns Promise resolving to the RSV signature
+   */
+  abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>;
+  /**
+   * Gets the public key associated with this contract instance.
+   *
+   * @returns Promise resolving to the SEC1 uncompressed public key
+   */
+  abstract getPublicKey(): Promise<UncompressedPubKeySEC1>;
+}
+//#endregion
+//#region src/types.d.ts
+type HashToSign = SignArgs['payload'];
+type Base58String = string;
+type NajPublicKey = `secp256k1:${Base58String}`;
+type UncompressedPubKeySEC1 = `04${string}`;
+type CompressedPubKeySEC1 = `02${string}` | `03${string}`;
+type KeyDerivationPath = string;
+interface RSVSignature {
+  r: string;
+  s: string;
+  v: number;
+}
+interface SigNetEvmMpcSignature {
+  bigR: {
+    x: bigint;
+    y: bigint;
+  };
+  s: bigint;
+  recoveryId: number;
+}
+type MPCSignature = SigNetEvmMpcSignature;
+type RootPublicKey = NajPublicKey | UncompressedPubKeySEC1 | CompressedPubKeySEC1;
+declare namespace constants_d_exports {
+  export { CHAINS, CONTRACT_ADDRESSES, ENVS, KDF_CHAIN_IDS, ROOT_PUBLIC_KEYS };
+}
+declare const ENVS: {
+  readonly TESTNET_DEV: "TESTNET_DEV";
+  readonly TESTNET: "TESTNET";
+  readonly MAINNET: "MAINNET";
+};
+declare const CHAINS: {
+  readonly ETHEREUM: "ETHEREUM";
+  readonly SOLANA: "SOLANA";
+  readonly CANTON: "CANTON";
+};
+/**
+ * Root public keys for the Sig Network Smart Contracts across different environments.
+ *
+ * These keys should never change.
+ */
+declare const ROOT_PUBLIC_KEYS: Record<keyof typeof ENVS, NajPublicKey>;
+/**
+ * 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
+ */
+declare const KDF_CHAIN_IDS: {
+  readonly ETHEREUM: "eip155:1";
+  readonly SOLANA: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+  readonly 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
+ */
+declare const CONTRACT_ADDRESSES: Record<keyof typeof CHAINS, Record<keyof typeof ENVS, string>>;
+declare namespace cryptography_d_exports {
+  export { compressPubKey, deriveChildPublicKey, normalizeToUncompressedPubKey, toRSV, verifyRecoveredAddress };
+}
+declare const toRSV: (signature: MPCSignature) => RSVSignature;
+/**
+ * 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
+ */
+declare const compressPubKey: (uncompressedPubKeySEC1: UncompressedPubKeySEC1) => string;
+/**
+ * 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)
+ */
+declare const normalizeToUncompressedPubKey: (key: RootPublicKey) => UncompressedPubKeySEC1;
+/**
+ * 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)
+ */
+declare function deriveChildPublicKey(rootUncompressedPubKeySEC1: UncompressedPubKeySEC1, predecessorId: string, path: string | undefined, chainId: string, keyVersion: number): UncompressedPubKeySEC1;
+/**
+ * Verifies that a secp256k1 signature was created by the expected derived address
+ * by recovering the signing address and comparing it with the address derived from the contract.
+ *
+ * @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
+ */
+declare function verifyRecoveredAddress(signature: RSVSignature, payload: number[] | Uint8Array, requesterAddress: string, path: string, contract: BaseChainSignatureContract, keyVersion: number): Promise<boolean>;
+declare namespace index_d_exports$2 {
+  export { cryptography_d_exports as cryptography };
+}
+//#endregion
+//#region src/chain-adapters/ChainAdapter.d.ts
+declare abstract class ChainAdapter<TransactionRequest, UnsignedTransaction> {
+  /**
+   * Gets the native token balance and decimals for a given address
+   *
+   * @param address - The address to check
+   * @returns Promise resolving to an object containing:
+   *          - balance: The balance as a bigint, in the chain's base units
+   *          - decimals: The number of decimals used to format the balance
+   */
+  abstract getBalance(address: string): Promise<{
+    balance: bigint;
+    decimals: number;
+  }>;
+  /**
+   * Uses Sig Network Key Derivation Function to derive the address and public key. from a signer ID and string path.
+   *
+   * @param predecessor - The id/address of the account requesting signature
+   * @param path - The string path used to derive the key
+   * @returns Promise resolving to the derived address and public key
+   */
+  abstract deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath, keyVersion: number): Promise<{
+    address: string;
+    publicKey: string;
+  }>;
+  /**
+   * Serializes an unsigned transaction to a string format.
+   * This is useful for storing or transmitting the transaction.
+   *
+   * @param transaction - The unsigned transaction to serialize
+   * @returns The serialized transaction string
+   */
+  abstract serializeTransaction(transaction: UnsignedTransaction): string;
+  /**
+   * Deserializes a transaction string back into an unsigned transaction object.
+   * This reverses the serialization done by serializeTransaction().
+   *
+   * @param serialized - The serialized transaction string
+   * @returns The deserialized unsigned transaction
+   */
+  abstract deserializeTransaction(serialized: string): UnsignedTransaction;
+  /**
+   * Prepares a transaction for Sig Network MPC signing by creating the necessary payloads.
+   * This method handles chain-specific transaction preparation including:
+   * - Fee calculation
+   * - Nonce/sequence management
+   * - UTXO selection (for UTXO-based chains)
+   * - Transaction encoding
+   *
+   * @param transactionRequest - The transaction request containing parameters like recipient, amount, etc.
+   * @returns Promise resolving to an object containing:
+   *          - transaction: The unsigned transaction
+   *          - hashesToSign: Array of payloads to be signed by MPC. The order of these payloads must match
+   *                         the order of signatures provided to finalizeTransactionSigning()
+   */
+  abstract prepareTransactionForSigning(transactionRequest: TransactionRequest): Promise<{
+    transaction: UnsignedTransaction;
+    hashesToSign: HashToSign[];
+  }>;
+  /**
+   * Adds Sig Network MPC-generated signatures to an unsigned transaction.
+   *
+   * @param params - Parameters for adding signatures
+   * @param params.transaction - The unsigned transaction to add signatures to
+   * @param params.rsvSignatures - Array of RSV signatures generated through MPC. Must be in the same order
+   *                              as the payloads returned by prepareTransactionForSigning()
+   * @returns The serialized signed transaction ready for broadcast
+   */
+  abstract finalizeTransactionSigning(params: {
+    transaction: UnsignedTransaction;
+    rsvSignatures: RSVSignature[];
+  }): string;
+  /**
+   * Broadcasts a signed transaction to the network.
+   *
+   * @param txSerialized - The serialized signed transaction
+   * @returns Promise resolving to the transaction hash/ID
+   */
+  abstract broadcastTx(txSerialized: string): Promise<string>;
+}
+//#endregion
+//#region src/chain-adapters/EVM/types.d.ts
+type EVMUnsignedTransaction = TransactionRequest & {
+  type: 'eip1559';
+  chainId: number;
+};
+interface EVMTransactionRequest extends Omit<EVMUnsignedTransaction, 'chainId' | 'type'> {
+  from: Address;
+}
+type EVMMessage = SignableMessage;
+type EVMTypedData = TypedDataDefinition;
+//#endregion
+//#region src/chain-adapters/EVM/EVM.d.ts
+/**
+ * Implementation of the ChainAdapter interface for EVM-compatible networks.
+ * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
+ */
+declare class EVM extends ChainAdapter<EVMTransactionRequest, EVMUnsignedTransaction> {
+  private readonly client;
+  private readonly 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
+  }: {
+    publicClient: PublicClient;
+    contract: BaseChainSignatureContract;
+  });
+  private attachGasAndNonce;
+  private transformRSVSignature;
+  private assembleSignature;
+  deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath, keyVersion: number): Promise<{
+    address: string;
+    publicKey: string;
+  }>;
+  getBalance(address: string): Promise<{
+    balance: bigint;
+    decimals: number;
+  }>;
+  serializeTransaction(transaction: EVMUnsignedTransaction): `0x${string}`;
+  deserializeTransaction(serialized: `0x${string}`): EVMUnsignedTransaction;
+  prepareTransactionForSigning(transactionRequest: EVMTransactionRequest): Promise<{
+    transaction: EVMUnsignedTransaction;
+    hashesToSign: HashToSign[];
+  }>;
+  prepareMessageForSigning(message: EVMMessage): Promise<{
+    hashToSign: HashToSign;
+  }>;
+  prepareTypedDataForSigning(typedDataRequest: EVMTypedData): Promise<{
+    hashToSign: HashToSign;
+  }>;
+  finalizeTransactionSigning({
+    transaction,
+    rsvSignatures
+  }: {
+    transaction: EVMUnsignedTransaction;
+    rsvSignatures: RSVSignature[];
+  }): `0x02${string}`;
+  finalizeMessageSigning({
+    rsvSignature
+  }: {
+    rsvSignature: RSVSignature;
+  }): Hex;
+  finalizeTypedDataSigning({
+    rsvSignature
+  }: {
+    rsvSignature: RSVSignature;
+  }): Hex;
+  broadcastTx(txSerialized: `0x${string}`): Promise<Hash>;
+}
+//#endregion
+//#region src/chain-adapters/EVM/utils.d.ts
+interface EVMFeeProperties {
+  gas: bigint;
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+}
+declare function fetchEVMFeeProperties(client: PublicClient, transaction: TransactionRequest): Promise<EVMFeeProperties>;
+declare namespace index_d_exports$7 {
+  export { EVM, EVMMessage, EVMTransactionRequest, EVMTypedData, EVMUnsignedTransaction, fetchEVMFeeProperties };
+}
+//#endregion
+//#region src/chain-adapters/Bitcoin/types.d.ts
+interface BTCTransaction {
+  vout: Array<{
+    scriptpubkey: string;
+    value: number;
+  }>;
+}
+interface BTCInput {
+  txid: string;
+  vout: number;
+  value: number;
+  scriptPubKey: Uint8Array;
+}
+type BTCOutput = {
+  value: number;
+} | {
+  address: string;
+  value: number;
+} | {
+  script: Uint8Array;
+  value: number;
+};
+type BTCTransactionRequest = {
+  publicKey: string;
+} & ({
+  inputs: BTCInput[];
+  outputs: BTCOutput[];
+  from?: never;
+  to?: never;
+  value?: never;
+} | {
+  inputs?: never;
+  outputs?: never;
+  from: string;
+  to: string;
+  value: string;
+});
+interface BTCUnsignedTransaction {
+  psbt: bitcoin.Psbt;
+  publicKey: string;
+}
+type BTCNetworkIds = 'mainnet' | 'testnet' | 'regtest';
+//#endregion
+//#region src/chain-adapters/Bitcoin/BTCRpcAdapter/BTCRpcAdapter.d.ts
+declare abstract class BTCRpcAdapter {
+  abstract selectUTXOs(from: string, targets: BTCOutput[]): Promise<{
+    inputs: BTCInput[];
+    outputs: BTCOutput[];
+  }>;
+  abstract broadcastTransaction(transactionHex: string): Promise<string>;
+  abstract getBalance(address: string): Promise<number>;
+  abstract getTransaction(txid: string): Promise<BTCTransaction>;
+}
+//#endregion
+//#region src/chain-adapters/Bitcoin/BTCRpcAdapter/Mempool/Mempool.d.ts
+declare class Mempool extends BTCRpcAdapter {
+  private readonly providerUrl;
+  constructor(providerUrl: string);
+  private fetchFeeRate;
+  private fetchUTXOs;
+  selectUTXOs(from: string, targets: BTCOutput[], confirmationTarget?: number): Promise<{
+    inputs: BTCInput[];
+    outputs: BTCOutput[];
+  }>;
+  broadcastTransaction(transactionHex: string): Promise<string>;
+  getBalance(address: string): Promise<number>;
+  getTransaction(txid: string): Promise<BTCTransaction>;
+}
+//#endregion
+//#region src/chain-adapters/Bitcoin/BTCRpcAdapter/index.d.ts
+declare const BTCRpcAdapters: {
+  Mempool: typeof Mempool;
+};
+//#endregion
+//#region src/chain-adapters/Bitcoin/Bitcoin.d.ts
+/**
+ * Implementation of the ChainAdapter interface for Bitcoin network.
+ * Handles interactions with both Bitcoin mainnet and testnet, supporting P2WPKH transactions.
+ */
+declare class Bitcoin extends ChainAdapter<BTCTransactionRequest, BTCUnsignedTransaction> {
+  private static readonly SATOSHIS_PER_BTC;
+  private readonly network;
+  private readonly btcRpcAdapter;
+  private readonly 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
+  }: {
+    network: BTCNetworkIds;
+    contract: BaseChainSignatureContract;
+    btcRpcAdapter: BTCRpcAdapter;
+  });
+  /**
+   * Converts satoshis to BTC
+   * @param satoshis - Amount in satoshis
+   * @returns Amount in BTC
+   */
+  static toBTC(satoshis: number): number;
+  /**
+   * Converts BTC to satoshis
+   * @param btc - Amount in BTC
+   * @returns Amount in satoshis (rounded)
+   */
+  static toSatoshi(btc: number): number;
+  private fetchTransaction;
+  private static transformRSVSignature;
+  /**
+   * 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
+   */
+  createPSBT({
+    transactionRequest
+  }: {
+    transactionRequest: BTCTransactionRequest;
+  }): Promise<bitcoin.Psbt>;
+  getBalance(address: string): Promise<{
+    balance: bigint;
+    decimals: number;
+  }>;
+  deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath, keyVersion: number): Promise<{
+    address: string;
+    publicKey: string;
+  }>;
+  serializeTransaction(transaction: BTCUnsignedTransaction): string;
+  deserializeTransaction(serialized: string): BTCUnsignedTransaction;
+  prepareTransactionForSigning(transactionRequest: BTCTransactionRequest): Promise<{
+    transaction: BTCUnsignedTransaction;
+    hashesToSign: HashToSign[];
+  }>;
+  finalizeTransactionSigning({
+    transaction: {
+      psbt,
+      publicKey
+    },
+    rsvSignatures
+  }: {
+    transaction: BTCUnsignedTransaction;
+    rsvSignatures: RSVSignature[];
+  }): string;
+  broadcastTx(txSerialized: string): Promise<string>;
+}
+declare namespace index_d_exports$6 {
+  export { BTCInput, BTCNetworkIds, BTCOutput, BTCRpcAdapter, BTCRpcAdapters, BTCTransaction, BTCTransactionRequest, BTCUnsignedTransaction, Bitcoin };
+}
+//#endregion
+//#region src/chain-adapters/Cosmos/types.d.ts
+type CosmosNetworkIds = string;
+type CosmosUnsignedTransaction = TxRaw;
+interface CosmosTransactionRequest {
+  address: string;
+  publicKey: string;
+  messages: EncodeObject[];
+  memo?: string;
+  gas?: number;
+}
+//#endregion
+//#region src/chain-adapters/Cosmos/Cosmos.d.ts
+/**
+ * Implementation of the ChainAdapter interface for Cosmos-based networks.
+ * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
+ */
+declare class Cosmos extends ChainAdapter<CosmosTransactionRequest, CosmosUnsignedTransaction> {
+  private readonly registry;
+  private readonly chainId;
+  private readonly contract;
+  private readonly 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
+  }: {
+    contract: BaseChainSignatureContract;
+    chainId: CosmosNetworkIds;
+    endpoints?: {
+      rpcUrl?: string;
+      restUrl?: string;
+    };
+  });
+  private transformRSVSignature;
+  private getChainInfo;
+  getBalance(address: string): Promise<{
+    balance: bigint;
+    decimals: number;
+  }>;
+  deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath, keyVersion: number): Promise<{
+    address: string;
+    publicKey: string;
+  }>;
+  serializeTransaction(transaction: CosmosUnsignedTransaction): string;
+  deserializeTransaction(serialized: string): CosmosUnsignedTransaction;
+  prepareTransactionForSigning(transactionRequest: CosmosTransactionRequest): Promise<{
+    transaction: CosmosUnsignedTransaction;
+    hashesToSign: HashToSign[];
+  }>;
+  finalizeTransactionSigning({
+    transaction,
+    rsvSignatures
+  }: {
+    transaction: CosmosUnsignedTransaction;
+    rsvSignatures: RSVSignature[];
+  }): string;
+  broadcastTx(txSerialized: string): Promise<string>;
+}
+declare namespace index_d_exports$5 {
+  export { Cosmos, CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction };
+}
+declare namespace index_d_exports {
+  export { ChainAdapter, index_d_exports$6 as btc, index_d_exports$5 as cosmos, index_d_exports$7 as evm };
+}
+declare namespace ChainSignaturesContractABI_d_exports {
+  export { abi };
+}
+declare const abi: ({
+  inputs: {
+    internalType: string;
+    name: string;
+    type: string;
+  }[];
+  stateMutability: string;
+  type: string;
+  name?: undefined;
+  anonymous?: undefined;
+  outputs?: undefined;
+} | {
+  inputs: {
+    internalType: string;
+    name: string;
+    type: string;
+  }[];
+  name: string;
+  type: string;
+  stateMutability?: undefined;
+  anonymous?: undefined;
+  outputs?: undefined;
+} | {
+  anonymous: boolean;
+  inputs: ({
+    indexed: boolean;
+    internalType: string;
+    name: string;
+    type: string;
+    components?: undefined;
+  } | {
+    components: ({
+      components: {
+        internalType: string;
+        name: string;
+        type: string;
+      }[];
+      internalType: string;
+      name: string;
+      type: string;
+    } | {
+      internalType: string;
+      name: string;
+      type: string;
+      components?: undefined;
+    })[];
+    indexed: boolean;
+    internalType: string;
+    name: string;
+    type: string;
+  })[];
+  name: string;
+  type: string;
+  stateMutability?: undefined;
+  outputs?: undefined;
+} | {
+  inputs: {
+    internalType: string;
+    name: string;
+    type: string;
+  }[];
+  name: string;
+  outputs: {
+    internalType: string;
+    name: string;
+    type: string;
+  }[];
+  stateMutability: string;
+  type: string;
+  anonymous?: undefined;
+} | {
+  inputs: {
+    components: ({
+      internalType: string;
+      name: string;
+      type: string;
+      components?: undefined;
+    } | {
+      components: ({
+        components: {
+          internalType: string;
+          name: string;
+          type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+      } | {
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+      })[];
+      internalType: string;
+      name: string;
+      type: string;
+    })[];
+    internalType: string;
+    name: string;
+    type: string;
+  }[];
+  name: string;
+  outputs: never[];
+  stateMutability: string;
+  type: string;
+  anonymous?: undefined;
+})[];
+declare namespace errors_d_exports$1 {
+  export { ChainSignatureError, SignatureContractError, SignatureNotFoundError$1 as SignatureNotFoundError, SigningError$1 as SigningError };
+}
+declare class ChainSignatureError extends Error {
+  requestId: `0x${string}`;
+  receipt: TransactionReceipt;
+  constructor(message: string, requestId: `0x${string}`, receipt: TransactionReceipt);
+}
+declare class SignatureNotFoundError$1 extends ChainSignatureError {
+  constructor(requestId: `0x${string}`, receipt: TransactionReceipt);
+}
+declare class SignatureContractError extends ChainSignatureError {
+  errorCode: string;
+  constructor(errorCode: string, requestId: `0x${string}`, receipt: TransactionReceipt);
+}
+declare class SigningError$1 extends ChainSignatureError {
+  originalError?: Error;
+  constructor(requestId: `0x${string}`, receipt: TransactionReceipt, originalError?: Error);
+}
+//#endregion
+//#region src/contracts/evm/types.d.ts
+interface RetryOptions {
+  delay?: number;
+  retryCount?: number;
+}
+interface SignOptions {
+  sign: {
+    algo?: string;
+    dest?: string;
+    params?: string;
+  };
+  retry: RetryOptions;
+  transaction?: {
+    gas?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+  };
+}
+interface SignatureErrorData {
+  requestId: string;
+  error: string;
+}
+interface RequestIdArgs {
+  address: Address;
+  payload: Hex;
+  path: string;
+  keyVersion: number;
+  chainId: bigint;
+  algo: string;
+  dest: string;
+  params: string;
+}
+//#endregion
+//#region src/contracts/evm/ChainSignaturesContract.d.ts
+/**
+ * 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.
+ */
+declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
+  private readonly publicClient;
+  private readonly walletClient;
+  private readonly contractAddress;
+  private readonly 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: {
+    publicClient: PublicClient;
+    walletClient: WalletClient;
+    contractAddress: Hex;
+    rootPublicKey?: RootPublicKey;
+  });
+  getCurrentSignatureDeposit(): Promise<bigint>;
+  getDerivedPublicKey(args: {
+    path: string;
+    predecessor: string;
+    keyVersion: number;
+  }): Promise<UncompressedPubKeySEC1>;
+  getPublicKey(): Promise<UncompressedPubKeySEC1>;
+  getLatestKeyVersion(): Promise<number>;
+  /**
+   * Sends a sign request transaction and return the transaction hash.
+   *
+   * @param args - The signature arguments
+   * @param options - The signing options
+   * @returns The transaction hash
+   */
+  createSignatureRequest(args: SignArgs, options?: Pick<SignOptions, 'sign' | 'transaction'>): Promise<{
+    txHash: Hex;
+    requestId: Hex;
+  }>;
+  /**
+   * 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.
+   */
+  sign(args: SignArgs, options?: SignOptions): Promise<RSVSignature>;
+  pollForRequestId({
+    requestId,
+    payload,
+    path,
+    keyVersion,
+    fromBlock,
+    options
+  }: {
+    requestId: Hex;
+    payload: number[];
+    path: string;
+    keyVersion: number;
+    fromBlock: bigint;
+    options?: RetryOptions;
+  }): Promise<RSVSignature | SignatureErrorData | undefined>;
+  getSignRequestParams(args: SignArgs, options?: SignOptions['sign']): Promise<{
+    target: Hex;
+    data: Hex;
+    value: bigint;
+  }>;
+  /**
+   * 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: SignArgs, options?: SignOptions['sign']): Hex;
+  getErrorFromEvents(requestId: Hex, fromBlock: bigint): Promise<SignatureErrorData | undefined>;
+  /**
+   * 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
+   */
+  getSignatureFromEvents(requestId: Hex, fromBlock: bigint): Promise<RSVSignature | undefined>;
+}
+//#endregion
+//#region src/contracts/evm/utils.d.ts
+/**
+ * Generates a unique request ID for EVM signature requests using keccak256 hashing.
+ *
+ * The request ID is computed by ABI-encoding the request parameters and hashing
+ * the result. This ID is used to track signature requests and match them with
+ * responses from the MPC network.
+ *
+ * @param request - The signature request parameters
+ * @param request.address - The address of the requester (EVM address format)
+ * @param request.payload - The data payload to be signed as a hex string
+ * @param request.path - The derivation path for the signing key
+ * @param request.keyVersion - The version of the signing key
+ * @param request.chainId - The chain ID where the request originated
+ * @param request.algo - The signing algorithm identifier
+ * @param request.dest - The destination identifier for the signature
+ * @param request.params - Additional parameters for the signing process
+ * @returns The keccak256 hash of the encoded request as a hex string
+ *
+ * @example
+ * ```typescript
+ * const requestId = getRequestIdRespond({
+ *   address: '0x1234...abcd',
+ *   payload: '0xdeadbeef',
+ *   path: 'ethereum,1',
+ *   keyVersion: 0,
+ *   chainId: 1n,
+ *   algo: '',
+ *   dest: '',
+ *   params: '',
+ * })
+ * ```
+ */
+declare const getRequestIdRespond$1: (request: RequestIdArgs) => `0x${string}`;
+declare namespace index_d_exports$4 {
+  export { ChainSignatureContract$1 as ChainSignatureContract, RequestIdArgs, getRequestIdRespond$1 as getRequestIdRespond, utils$1 as utils };
+}
+declare const utils$1: {
+  ChainSignaturesContractABI: typeof ChainSignaturesContractABI_d_exports;
+  errors: typeof errors_d_exports$1;
+};
+declare namespace errors_d_exports {
+  export { ResponseError, SignatureNotFoundError, SigningError };
+}
+declare class SignatureNotFoundError extends Error {
+  readonly requestId?: string;
+  readonly hash?: string;
+  constructor(requestId?: string, metadata?: {
+    hash?: string;
+  });
+}
+declare class SigningError extends Error {
+  readonly requestId: string;
+  readonly hash?: string;
+  readonly originalError?: Error;
+  constructor(requestId: string, metadata?: {
+    hash?: string;
+  }, originalError?: Error);
+}
+declare class ResponseError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/contracts/solana/types/chain_signatures_project.d.ts
+/**
+ * Program IDL in camelCase format in order to be used in JS/TS.
+ *
+ * Note that this is only a type helper and is not the actual IDL. The original
+ * IDL can be found at `target/idl/chain_signatures_project.json`.
+ */
+interface ChainSignaturesProject {
+  address: 'H5tHfpYoEnarrrzcV7sWBcZhiKMvL2aRpUYvb1ydWkwS';
+  metadata: {
+    name: 'chainSignatures';
+    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';
+  };
+  instructions: [{
+    name: 'getSignatureDeposit';
+    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: 'programState';
+      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: 'programState';
+      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: 'systemProgram';
+      address: '11111111111111111111111111111111';
+    }];
+    args: [{
+      name: 'signatureDeposit';
+      type: 'u64';
+    }, {
+      name: 'chainId';
+      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: 'eventAuthority';
+      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: 'requestIds';
+      type: {
+        vec: {
+          array: ['u8', 32];
+        };
+      };
+    }, {
+      name: 'signatures';
+      type: {
+        vec: {
+          defined: {
+            name: 'signature';
+          };
+        };
+      };
+    }];
+  }, {
+    name: 'respondBidirectional';
+    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: 'requestId';
+      type: {
+        array: ['u8', 32];
+      };
+    }, {
+      name: 'serializedOutput';
+      type: 'bytes';
+    }, {
+      name: 'signature';
+      type: {
+        defined: {
+          name: 'signature';
+        };
+      };
+    }];
+  }, {
+    name: 'respondError';
+    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: 'programState';
+      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: 'feePayer';
+      writable: true;
+      signer: true;
+      optional: true;
+    }, {
+      name: 'systemProgram';
+      address: '11111111111111111111111111111111';
+    }, {
+      name: 'eventAuthority';
+      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: 'keyVersion';
+      type: 'u32';
+    }, {
+      name: 'path';
+      type: 'string';
+    }, {
+      name: 'algo';
+      type: 'string';
+    }, {
+      name: 'dest';
+      type: 'string';
+    }, {
+      name: 'params';
+      type: 'string';
+    }];
+  }, {
+    name: 'signBidirectional';
+    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: 'programState';
+      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: 'feePayer';
+      writable: true;
+      signer: true;
+      optional: true;
+    }, {
+      name: 'systemProgram';
+      address: '11111111111111111111111111111111';
+    }, {
+      name: 'instructions';
+      optional: true;
+    }, {
+      name: 'eventAuthority';
+      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: 'serializedTransaction';
+      type: 'bytes';
+    }, {
+      name: 'caip2Id';
+      type: 'string';
+    }, {
+      name: 'keyVersion';
+      type: 'u32';
+    }, {
+      name: 'path';
+      type: 'string';
+    }, {
+      name: 'algo';
+      type: 'string';
+    }, {
+      name: 'dest';
+      type: 'string';
+    }, {
+      name: 'params';
+      type: 'string';
+    }, {
+      name: 'programId';
+      type: 'pubkey';
+    }, {
+      name: 'outputDeserializationSchema';
+      type: 'bytes';
+    }, {
+      name: 'respondSerializationSchema';
+      type: 'bytes';
+    }];
+  }, {
+    name: 'updateDeposit';
+    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: 'programState';
+      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: ['programState'];
+    }, {
+      name: 'systemProgram';
+      address: '11111111111111111111111111111111';
+    }];
+    args: [{
+      name: 'newDeposit';
+      type: 'u64';
+    }];
+  }, {
+    name: 'withdrawFunds';
+    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: 'programState';
+      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: ['programState'];
+    }, {
+      name: 'recipient';
+      docs: ['function by checking it is not the zero address.'];
+      writable: true;
+    }, {
+      name: 'systemProgram';
+      address: '11111111111111111111111111111111';
+    }];
+    args: [{
+      name: 'amount';
+      type: 'u64';
+    }];
+  }];
+  accounts: [{
+    name: 'programState';
+    discriminator: [77, 209, 137, 229, 149, 67, 167, 230];
+  }];
+  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];
+  }];
+  errors: [{
+    code: 6000;
+    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';
+  }];
+  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: 'oldDeposit';
+        type: 'u64';
+      }, {
+        name: 'newDeposit';
+        type: 'u64';
+      }];
+    };
+  }, {
+    name: 'errorResponse';
+    type: {
+      kind: 'struct';
+      fields: [{
+        name: 'requestId';
+        type: {
+          array: ['u8', 32];
+        };
+      }, {
+        name: 'errorMessage';
+        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: 'signatureDeposit';
+        type: 'u64';
+      }, {
+        name: 'chainId';
+        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: 'requestId';
+        type: {
+          array: ['u8', 32];
+        };
+      }, {
+        name: 'responder';
+        type: 'pubkey';
+      }, {
+        name: 'serializedOutput';
+        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: 'serializedTransaction';
+        type: 'bytes';
+      }, {
+        name: 'caip2Id';
+        type: 'string';
+      }, {
+        name: 'keyVersion';
+        type: 'u32';
+      }, {
+        name: 'deposit';
+        type: 'u64';
+      }, {
+        name: 'path';
+        type: 'string';
+      }, {
+        name: 'algo';
+        type: 'string';
+      }, {
+        name: 'dest';
+        type: 'string';
+      }, {
+        name: 'params';
+        type: 'string';
+      }, {
+        name: 'programId';
+        type: 'pubkey';
+      }, {
+        name: 'outputDeserializationSchema';
+        type: 'bytes';
+      }, {
+        name: 'respondSerializationSchema';
+        type: 'bytes';
+      }];
+    };
+  }, {
+    name: 'signature';
+    type: {
+      kind: 'struct';
+      fields: [{
+        name: 'bigR';
+        type: {
+          defined: {
+            name: 'affinePoint';
+          };
+        };
+      }, {
+        name: 's';
+        type: {
+          array: ['u8', 32];
+        };
+      }, {
+        name: 'recoveryId';
+        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: 'requestId';
+        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: 'keyVersion';
+        type: 'u32';
+      }, {
+        name: 'deposit';
+        type: 'u64';
+      }, {
+        name: 'chainId';
+        type: 'string';
+      }, {
+        name: 'path';
+        type: 'string';
+      }, {
+        name: 'algo';
+        type: 'string';
+      }, {
+        name: 'dest';
+        type: 'string';
+      }, {
+        name: 'params';
+        type: 'string';
+      }, {
+        name: 'feePayer';
+        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: 'requestId';
+        type: {
+          array: ['u8', 32];
+        };
+      }, {
+        name: 'responder';
+        type: 'pubkey';
+      }, {
+        name: 'signature';
+        type: {
+          defined: {
+            name: 'signature';
+          };
+        };
+      }];
+    };
+  }];
+}
+//#endregion
+//#region src/contracts/solana/types/events.d.ts
+interface AffinePoint {
+  x: number[];
+  y: number[];
+}
+interface Signature {
+  bigR: AffinePoint;
+  s: number[];
+  recoveryId: number;
+}
+interface RespondBidirectionalData {
+  serializedOutput: Buffer;
+  signature: Signature;
+}
+type ChainSignaturesEventName = 'signatureRespondedEvent' | 'signatureErrorEvent' | 'respondBidirectionalEvent';
+interface EventResultMap {
+  signatureRespondedEvent: RSVSignature;
+  signatureErrorEvent: SignatureErrorData;
+  respondBidirectionalEvent: RespondBidirectionalData;
+}
+type EventResult<E extends ChainSignaturesEventName> = EventResultMap[E];
+//#endregion
+//#region src/contracts/solana/ChainSignaturesContract.d.ts
+declare class ChainSignatureContract extends ChainSignatureContract$2 {
+  private readonly provider;
+  private readonly program;
+  private readonly programId;
+  private readonly rootPublicKey;
+  private readonly requesterAddress;
+  private readonly _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: {
+    provider: AnchorProvider;
+    programId: string | PublicKey;
+    config?: {
+      rootPublicKey?: RootPublicKey;
+      requesterAddress?: string;
+      idl?: ChainSignaturesProject & Idl;
+      disableRetryOnRateLimit?: boolean;
+    };
+  });
+  /**
+   * Gets the connection, using the override if `disableRetryOnRateLimit` was configured.
+   */
+  get connection(): Connection;
+  getCurrentSignatureDeposit(): Promise<bigint>;
+  /**
+   * Get the Program State PDA
+   */
+  getProgramStatePDA(): Promise<PublicKey>;
+  getDerivedPublicKey(args: {
+    path: string;
+    predecessor: string;
+    keyVersion: number;
+  }): Promise<UncompressedPubKeySEC1>;
+  getPublicKey(): Promise<UncompressedPubKeySEC1>;
+  getSignRequestInstruction(args: SignArgs, options?: Pick<SignOptions, 'sign'> & {
+    remainingAccounts?: AccountMeta[];
+  }): Promise<TransactionInstruction>;
+  /**
+   * 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.
+   */
+  sign(args: SignArgs, options?: Partial<SignOptions> & {
+    remainingAccounts?: AccountMeta[];
+    remainingSigners?: Signer[];
+  }): Promise<RSVSignature>;
+  private sendAndConfirmWithoutWebSocket;
+  /**
+   * Waits for a specific event matching the given requestId by combining
+   * a WebSocket listener (real-time) with polling backfill (resilience).
+   */
+  waitForEvent<E extends ChainSignaturesEventName>(options: {
+    eventName: E;
+    requestId: string;
+    signer: PublicKey;
+    afterSignature?: string;
+    timeoutMs?: number;
+    backfillIntervalMs?: number;
+    backfillLimit?: number;
+    healthCheckIntervalMs?: number;
+    signal?: AbortSignal;
+  }): Promise<EventResult<E>>;
+  private mapRespondToResult;
+  private mapRespondErrorToResult;
+  private mapRespondBidirectionalToResult;
+  private mapEventForName;
+  /**
+   * Generates the request ID for a signature request allowing to track the response.
+   */
+  getRequestId(args: SignArgs, options?: SignOptions['sign']): string;
+}
+//#endregion
+//#region src/contracts/solana/utils.d.ts
+interface SolanaRequestIdArgs {
+  address: string;
+  payload: Uint8Array | number[];
+  path: string;
+  keyVersion: number;
+  chainId: string;
+  algo: string;
+  dest: string;
+  params: string;
+}
+interface SolanaBidirectionalRequestIdArgs {
+  sender: string;
+  payload: Uint8Array | number[];
+  caip2Id: string;
+  keyVersion: number;
+  path: string;
+  algo: string;
+  dest: string;
+  params: string;
+}
+/**
+ * Generates a unique request ID for Solana signature requests using keccak256 hashing.
+ *
+ * The request ID is computed by ABI-encoding the request parameters and hashing
+ * the result. This ID is used to track signature requests and match them with
+ * responses from the MPC network.
+ *
+ * @param request - The signature request parameters
+ * @param request.address - The sender's address (Solana public key as string)
+ * @param request.payload - The data payload to be signed
+ * @param request.path - The derivation path for the signing key
+ * @param request.keyVersion - The version of the signing key
+ * @param request.chainId - The CAIP-2 chain identifier (e.g., 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
+ * @param request.algo - The signing algorithm identifier
+ * @param request.dest - The destination identifier for the signature
+ * @param request.params - Additional parameters for the signing process
+ * @returns The keccak256 hash of the encoded request as a hex string
+ *
+ * @example
+ * ```typescript
+ * const requestId = getRequestIdRespond({
+ *   address: 'So11111111111111111111111111111111111111112',
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   path: 'solana,1',
+ *   keyVersion: 0,
+ *   chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+ *   algo: '',
+ *   dest: '',
+ *   params: '',
+ * })
+ * ```
+ */
+declare function getRequestIdRespond(request: SolanaRequestIdArgs): string;
+/**
+ * Generates a unique request ID for bidirectional sign operations using keccak256 hashing.
+ *
+ * Unlike `getRequestIdRespond`, this function uses packed encoding (solidityPacked)
+ * instead of standard ABI encoding. This is used for cross-chain bidirectional
+ * signing flows where the request originates from a different chain.
+ *
+ * @param request - The bidirectional signature request parameters
+ * @param request.sender - The sender's address (Solana public key as string)
+ * @param request.payload - The data payload to be signed
+ * @param request.caip2Id - The CAIP-2 chain identifier (e.g., 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
+ * @param request.keyVersion - The version of the signing key
+ * @param request.path - The derivation path for the signing key
+ * @param request.algo - The signing algorithm identifier
+ * @param request.dest - The destination identifier for the signature
+ * @param request.params - Additional parameters for the signing process
+ * @returns The keccak256 hash of the packed encoded request as a hex string
+ *
+ * @example
+ * ```typescript
+ * const requestId = getRequestIdBidirectional({
+ *   sender: 'So11111111111111111111111111111111111111112',
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   caip2Id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+ *   keyVersion: 0,
+ *   path: 'ethereum,1',
+ *   algo: '',
+ *   dest: '',
+ *   params: '',
+ * })
+ * ```
+ */
+declare function getRequestIdBidirectional(request: SolanaBidirectionalRequestIdArgs): string;
+declare namespace index_d_exports$3 {
+  export { ChainSignatureContract, ChainSignaturesProject, SolanaBidirectionalRequestIdArgs, SolanaRequestIdArgs, getRequestIdBidirectional, getRequestIdRespond, utils };
+}
+declare const utils: {
+  ChainSignaturesContractIdl: {
+    address: string;
+    metadata: {
+      name: string;
+      version: string;
+      spec: string;
+      description: string;
+      repository: string;
+    };
+    instructions: ({
+      name: string;
+      docs: string[];
+      discriminator: number[];
+      accounts: {
+        name: string;
+        pda: {
+          seeds: {
+            kind: string;
+            value: number[];
+          }[];
+        };
+      }[];
+      args: never[];
+      returns: string;
+    } | {
+      name: string;
+      docs: string[];
+      discriminator: number[];
+      accounts: ({
+        name: string;
+        signer: boolean;
+        pda?: undefined;
+      } | {
+        name: string;
+        pda: {
+          seeds: {
+            kind: string;
+            value: number[];
+          }[];
+        };
+        signer?: undefined;
+      } | {
+        name: string;
+        signer?: undefined;
+        pda?: undefined;
+      })[];
+      args: ({
+        name: string;
+        type: {
+          vec: {
+            array: (string | number)[];
+            defined?: undefined;
+          };
+        };
+      } | {
+        name: string;
+        type: {
+          vec: {
+            defined: {
+              name: string;
+            };
+            array?: undefined;
+          };
+        };
+      })[];
+      returns?: undefined;
+    } | {
+      name: string;
+      docs: string[];
+      discriminator: number[];
+      accounts: {
+        name: string;
+        signer: boolean;
+      }[];
+      args: ({
+        name: string;
+        type: {
+          array: (string | number)[];
+          defined?: undefined;
+        };
+      } | {
+        name: string;
+        type: string;
+      } | {
+        name: string;
+        type: {
+          defined: {
+            name: string;
+          };
+          array?: undefined;
+        };
+      })[];
+      returns?: undefined;
+    } | {
+      name: string;
+      docs: string[];
+      discriminator: number[];
+      accounts: ({
+        name: string;
+        writable: boolean;
+        pda: {
+          seeds: {
+            kind: string;
+            value: number[];
+          }[];
+        };
+        signer?: undefined;
+        optional?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        writable: boolean;
+        signer: boolean;
+        pda?: undefined;
+        optional?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        writable: boolean;
+        signer: boolean;
+        optional: boolean;
+        pda?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        address: string;
+        writable?: undefined;
+        pda?: undefined;
+        signer?: undefined;
+        optional?: undefined;
+      } | {
+        name: string;
+        pda: {
+          seeds: {
+            kind: string;
+            value: number[];
+          }[];
+        };
+        writable?: undefined;
+        signer?: undefined;
+        optional?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        writable?: undefined;
+        pda?: undefined;
+        signer?: undefined;
+        optional?: undefined;
+        address?: undefined;
+      })[];
+      args: ({
+        name: string;
+        type: {
+          array: (string | number)[];
+        };
+      } | {
+        name: string;
+        type: string;
+      })[];
+      returns?: undefined;
+    } | {
+      name: string;
+      docs: string[];
+      discriminator: number[];
+      accounts: ({
+        name: string;
+        writable: boolean;
+        pda: {
+          seeds: {
+            kind: string;
+            value: number[];
+          }[];
+        };
+        signer?: undefined;
+        optional?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        writable: boolean;
+        signer: boolean;
+        pda?: undefined;
+        optional?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        writable: boolean;
+        signer: boolean;
+        optional: boolean;
+        pda?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        address: string;
+        writable?: undefined;
+        pda?: undefined;
+        signer?: undefined;
+        optional?: undefined;
+      } | {
+        name: string;
+        optional: boolean;
+        writable?: undefined;
+        pda?: undefined;
+        signer?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        pda: {
+          seeds: {
+            kind: string;
+            value: number[];
+          }[];
+        };
+        writable?: undefined;
+        signer?: undefined;
+        optional?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        writable?: undefined;
+        pda?: undefined;
+        signer?: undefined;
+        optional?: undefined;
+        address?: undefined;
+      })[];
+      args: {
+        name: string;
+        type: string;
+      }[];
+      returns?: undefined;
+    } | {
+      name: string;
+      docs: string[];
+      discriminator: number[];
+      accounts: ({
+        name: string;
+        writable: boolean;
+        pda: {
+          seeds: {
+            kind: string;
+            value: number[];
+          }[];
+        };
+        signer?: undefined;
+        relations?: undefined;
+        docs?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        writable: boolean;
+        signer: boolean;
+        relations: string[];
+        pda?: undefined;
+        docs?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        docs: string[];
+        writable: boolean;
+        pda?: undefined;
+        signer?: undefined;
+        relations?: undefined;
+        address?: undefined;
+      } | {
+        name: string;
+        address: string;
+        writable?: undefined;
+        pda?: undefined;
+        signer?: undefined;
+        relations?: undefined;
+        docs?: undefined;
+      })[];
+      args: {
+        name: string;
+        type: string;
+      }[];
+      returns?: undefined;
+    })[];
+    accounts: {
+      name: string;
+      discriminator: number[];
+    }[];
+    events: {
+      name: string;
+      discriminator: number[];
+    }[];
+    errors: {
+      code: number;
+      name: string;
+      msg: string;
+    }[];
+    types: ({
+      name: string;
+      docs: string[];
+      type: {
+        kind: string;
+        fields: ({
+          name: string;
+          type: {
+            array: (string | number)[];
+            defined?: undefined;
+          };
+        } | {
+          name: string;
+          type: string;
+        } | {
+          name: string;
+          type: {
+            defined: {
+              name: string;
+            };
+            array?: undefined;
+          };
+        })[];
+      };
+    } | {
+      name: string;
+      type: {
+        kind: string;
+        fields: ({
+          name: string;
+          type: {
+            defined: {
+              name: string;
+            };
+            array?: undefined;
+          };
+        } | {
+          name: string;
+          type: {
+            array: (string | number)[];
+            defined?: undefined;
+          };
+        } | {
+          name: string;
+          type: string;
+        })[];
+      };
+      docs?: undefined;
+    } | {
+      name: string;
+      docs: string[];
+      type: {
+        kind: string;
+        fields: ({
+          name: string;
+          type: string;
+        } | {
+          name: string;
+          type: {
+            array: (string | number)[];
+            option?: undefined;
+          };
+        } | {
+          name: string;
+          type: {
+            option: string;
+            array?: undefined;
+          };
+        })[];
+      };
+    })[];
+  };
+  errors: typeof errors_d_exports;
+};
+declare namespace index_d_exports$1 {
+  export { ChainSignatureContract$2 as ChainSignatureContract, SignArgs, index_d_exports$4 as evm, index_d_exports$3 as solana };
+}
+//#endregion
+export { CompressedPubKeySEC1, HashToSign, KeyDerivationPath, MPCSignature, NajPublicKey, RSVSignature, RootPublicKey, SigNetEvmMpcSignature, UncompressedPubKeySEC1, index_d_exports as chainAdapters, constants_d_exports as constants, index_d_exports$1 as contracts, index_d_exports$2 as utils };