signet.js 0.0.12-beta.10 → 0.0.12-beta.12

package/types/index.d.cts

@@ -2,15 +2,9 @@ import BN from 'bn.js';
 import { TransactionRequest, Address, SignableMessage, TypedDataDefinition, Hex, PublicClient, Hash, TransactionReceipt, WalletClient } from 'viem';
 import * as bitcoin from 'bitcoinjs-lib';
 import { EncodeObject } from '@cosmjs/proto-signing';
-import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx.js';
-import { KeyPair } from '@near-js/crypto';
-import { Action as Action$1 } from '@near-js/transactions';
-import { TxExecutionStatus } from '@near-js/types';
-import { NetworkId, Action, FinalExecutionOutcome } from '@near-wallet-selector/core';
-import { KeyPair as KeyPair$1 } from 'near-api-js';
-import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, AccountMeta, TransactionInstruction, Signer } from '@solana/web3.js';
-import { AnchorProvider } from '@coral-xyz/anchor';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { AnchorProvider, Idl } from '@coral-xyz/anchor';
+import { PublicKey, Connection, AccountMeta, TransactionInstruction, Signer } from '@solana/web3.js';
 
 interface SignArgs {
     /** The payload to sign as an array of 32 bytes */
@@ -49,7 +43,7 @@ declare abstract class BaseChainSignatureContract {
 /**
  * Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
  */
-declare abstract class ChainSignatureContract$3 extends BaseChainSignatureContract {
+declare abstract class ChainSignatureContract$2 extends BaseChainSignatureContract {
     /**
      * Signs a payload using Sig Network MPC.
      *
@@ -79,20 +73,6 @@ interface RSVSignature {
     s: string;
     v: number;
 }
-interface NearNearMpcSignature {
-    big_r: {
-        affine_point: string;
-    };
-    s: {
-        scalar: string;
-    };
-    recovery_id: number;
-}
-interface SigNetNearMpcSignature {
-    big_r: string;
-    s: string;
-    recovery_id: number;
-}
 interface SigNetEvmMpcSignature {
     bigR: {
         x: bigint;
@@ -101,7 +81,7 @@ interface SigNetEvmMpcSignature {
     s: bigint;
     recoveryId: number;
 }
-type MPCSignature = NearNearMpcSignature | SigNetNearMpcSignature | SigNetEvmMpcSignature;
+type MPCSignature = SigNetEvmMpcSignature;
 
 declare const ENVS: {
     readonly TESTNET_DEV: "TESTNET_DEV";
@@ -110,7 +90,6 @@ declare const ENVS: {
 };
 declare const CHAINS: {
     readonly ETHEREUM: "ETHEREUM";
-    readonly NEAR: "NEAR";
     readonly SOLANA: "SOLANA";
 };
 /**
@@ -127,7 +106,6 @@ declare const ROOT_PUBLIC_KEYS: Record<keyof typeof ENVS, NajPublicKey>;
  */
 declare const KDF_CHAIN_IDS: {
     readonly ETHEREUM: "0x1";
-    readonly NEAR: "0x18d";
     readonly SOLANA: "0x800001f5";
 };
 /**
@@ -178,18 +156,31 @@ declare const najToUncompressedPubKeySEC1: (najPublicKey: NajPublicKey) => Uncom
  * @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): 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): Promise<boolean>;
 
 declare const cryptography_compressPubKey: typeof compressPubKey;
 declare const cryptography_deriveChildPublicKey: typeof deriveChildPublicKey;
 declare const cryptography_najToUncompressedPubKeySEC1: typeof najToUncompressedPubKeySEC1;
 declare const cryptography_toRSV: typeof toRSV;
+declare const cryptography_verifyRecoveredAddress: typeof verifyRecoveredAddress;
 declare namespace cryptography {
-  export { cryptography_compressPubKey as compressPubKey, cryptography_deriveChildPublicKey as deriveChildPublicKey, cryptography_najToUncompressedPubKeySEC1 as najToUncompressedPubKeySEC1, cryptography_toRSV as toRSV };
+  export { cryptography_compressPubKey as compressPubKey, cryptography_deriveChildPublicKey as deriveChildPublicKey, cryptography_najToUncompressedPubKeySEC1 as najToUncompressedPubKeySEC1, cryptography_toRSV as toRSV, cryptography_verifyRecoveredAddress as verifyRecoveredAddress };
 }
 
-declare const index$8_cryptography: typeof cryptography;
-declare namespace index$8 {
-  export { index$8_cryptography as cryptography };
+declare const index$7_cryptography: typeof cryptography;
+declare namespace index$7 {
+  export { index$7_cryptography as cryptography };
 }
 
 declare abstract class ChainAdapter<TransactionRequest, UnsignedTransaction> {
@@ -387,18 +378,18 @@ interface EVMFeeProperties {
 }
 declare function fetchEVMFeeProperties(client: PublicClient, transaction: TransactionRequest): Promise<EVMFeeProperties>;
 
-type index$7_EVM = EVM;
-declare const index$7_EVM: typeof EVM;
-type index$7_EVMMessage = EVMMessage;
-type index$7_EVMTransactionRequest = EVMTransactionRequest;
-type index$7_EVMTypedData = EVMTypedData;
-type index$7_EVMUnsignedTransaction = EVMUnsignedTransaction;
-declare const index$7_fetchEVMFeeProperties: typeof fetchEVMFeeProperties;
-declare namespace index$7 {
-  export { index$7_EVM as EVM, type index$7_EVMMessage as EVMMessage, type index$7_EVMTransactionRequest as EVMTransactionRequest, type index$7_EVMTypedData as EVMTypedData, type index$7_EVMUnsignedTransaction as EVMUnsignedTransaction, index$7_fetchEVMFeeProperties as fetchEVMFeeProperties };
+type index$6_EVM = EVM;
+declare const index$6_EVM: typeof EVM;
+type index$6_EVMMessage = EVMMessage;
+type index$6_EVMTransactionRequest = EVMTransactionRequest;
+type index$6_EVMTypedData = EVMTypedData;
+type index$6_EVMUnsignedTransaction = EVMUnsignedTransaction;
+declare const index$6_fetchEVMFeeProperties: typeof fetchEVMFeeProperties;
+declare namespace index$6 {
+  export { index$6_EVM as EVM, type index$6_EVMMessage as EVMMessage, type index$6_EVMTransactionRequest as EVMTransactionRequest, type index$6_EVMTypedData as EVMTypedData, type index$6_EVMUnsignedTransaction as EVMUnsignedTransaction, index$6_fetchEVMFeeProperties as fetchEVMFeeProperties };
 }
 
-interface BTCTransaction$1 {
+interface BTCTransaction {
     vout: Array<{
         scriptpubkey: string;
         value: number;
@@ -447,7 +438,7 @@ declare abstract class BTCRpcAdapter {
     }>;
     abstract broadcastTransaction(transactionHex: string): Promise<string>;
     abstract getBalance(address: string): Promise<number>;
-    abstract getTransaction(txid: string): Promise<BTCTransaction$1>;
+    abstract getTransaction(txid: string): Promise<BTCTransaction>;
 }
 
 declare class Mempool extends BTCRpcAdapter {
@@ -461,7 +452,7 @@ declare class Mempool extends BTCRpcAdapter {
     }>;
     broadcastTransaction(transactionHex: string): Promise<string>;
     getBalance(address: string): Promise<number>;
-    getTransaction(txid: string): Promise<BTCTransaction$1>;
+    getTransaction(txid: string): Promise<BTCTransaction>;
 }
 
 declare const BTCRpcAdapters: {
@@ -533,18 +524,19 @@ declare class Bitcoin extends ChainAdapter<BTCTransactionRequest, BTCUnsignedTra
     broadcastTx(txSerialized: string): Promise<string>;
 }
 
-type index$6_BTCInput = BTCInput;
-type index$6_BTCNetworkIds = BTCNetworkIds;
-type index$6_BTCOutput = BTCOutput;
-type index$6_BTCRpcAdapter = BTCRpcAdapter;
-declare const index$6_BTCRpcAdapter: typeof BTCRpcAdapter;
-declare const index$6_BTCRpcAdapters: typeof BTCRpcAdapters;
-type index$6_BTCTransactionRequest = BTCTransactionRequest;
-type index$6_BTCUnsignedTransaction = BTCUnsignedTransaction;
-type index$6_Bitcoin = Bitcoin;
-declare const index$6_Bitcoin: typeof Bitcoin;
-declare namespace index$6 {
-  export { type index$6_BTCInput as BTCInput, type index$6_BTCNetworkIds as BTCNetworkIds, type index$6_BTCOutput as BTCOutput, index$6_BTCRpcAdapter as BTCRpcAdapter, index$6_BTCRpcAdapters as BTCRpcAdapters, type BTCTransaction$1 as BTCTransaction, type index$6_BTCTransactionRequest as BTCTransactionRequest, type index$6_BTCUnsignedTransaction as BTCUnsignedTransaction, index$6_Bitcoin as Bitcoin };
+type index$5_BTCInput = BTCInput;
+type index$5_BTCNetworkIds = BTCNetworkIds;
+type index$5_BTCOutput = BTCOutput;
+type index$5_BTCRpcAdapter = BTCRpcAdapter;
+declare const index$5_BTCRpcAdapter: typeof BTCRpcAdapter;
+declare const index$5_BTCRpcAdapters: typeof BTCRpcAdapters;
+type index$5_BTCTransaction = BTCTransaction;
+type index$5_BTCTransactionRequest = BTCTransactionRequest;
+type index$5_BTCUnsignedTransaction = BTCUnsignedTransaction;
+type index$5_Bitcoin = Bitcoin;
+declare const index$5_Bitcoin: typeof Bitcoin;
+declare namespace index$5 {
+  export { type index$5_BTCInput as BTCInput, type index$5_BTCNetworkIds as BTCNetworkIds, type index$5_BTCOutput as BTCOutput, index$5_BTCRpcAdapter as BTCRpcAdapter, index$5_BTCRpcAdapters as BTCRpcAdapters, type index$5_BTCTransaction as BTCTransaction, type index$5_BTCTransactionRequest as BTCTransactionRequest, type index$5_BTCUnsignedTransaction as BTCUnsignedTransaction, index$5_Bitcoin as Bitcoin };
 }
 
 type CosmosNetworkIds = string;
@@ -606,178 +598,19 @@ declare class Cosmos extends ChainAdapter<CosmosTransactionRequest, CosmosUnsign
     broadcastTx(txSerialized: string): Promise<string>;
 }
 
-type index$5_Cosmos = Cosmos;
-declare const index$5_Cosmos: typeof Cosmos;
-type index$5_CosmosNetworkIds = CosmosNetworkIds;
-type index$5_CosmosTransactionRequest = CosmosTransactionRequest;
-type index$5_CosmosUnsignedTransaction = CosmosUnsignedTransaction;
-declare namespace index$5 {
-  export { index$5_Cosmos as Cosmos, type index$5_CosmosNetworkIds as CosmosNetworkIds, type index$5_CosmosTransactionRequest as CosmosTransactionRequest, type index$5_CosmosUnsignedTransaction as CosmosUnsignedTransaction };
-}
-
-type index$4_ChainAdapter<TransactionRequest, UnsignedTransaction> = ChainAdapter<TransactionRequest, UnsignedTransaction>;
-declare const index$4_ChainAdapter: typeof ChainAdapter;
+type index$4_Cosmos = Cosmos;
+declare const index$4_Cosmos: typeof Cosmos;
+type index$4_CosmosNetworkIds = CosmosNetworkIds;
+type index$4_CosmosTransactionRequest = CosmosTransactionRequest;
+type index$4_CosmosUnsignedTransaction = CosmosUnsignedTransaction;
 declare namespace index$4 {
-  export { index$4_ChainAdapter as ChainAdapter, index$6 as btc, index$5 as cosmos, index$7 as evm };
-}
-
-type ChainSignatureContractIds = string;
-type NearNetworkIds = 'mainnet' | 'testnet';
-interface ChainProvider {
-    providerUrl: string;
-    contract: ChainSignatureContractIds;
-}
-interface NearAuthentication {
-    networkId: NearNetworkIds;
-    accountId: string;
-}
-interface SuccessResponse {
-    transactionHash: string;
-    success: true;
-}
-interface FailureResponse {
-    success: false;
-    errorMessage: string;
-}
-type Response = SuccessResponse | FailureResponse;
-type EVMChainConfigWithProviders = ChainProvider;
-interface EVMRequest {
-    transaction: EVMTransactionRequest;
-    chainConfig: EVMChainConfigWithProviders;
-    nearAuthentication: NearAuthentication;
-    fastAuthRelayerUrl?: string;
-    derivationPath: KeyDerivationPath;
-}
-type BTCChainConfigWithProviders = ChainProvider & {
-    network: BTCNetworkIds;
-};
-interface BitcoinRequest {
-    transaction: BTCTransactionRequest;
-    chainConfig: BTCChainConfigWithProviders;
-    nearAuthentication: NearAuthentication;
-    fastAuthRelayerUrl?: string;
-    derivationPath: KeyDerivationPath;
-}
-interface CosmosChainConfig {
-    contract: ChainSignatureContractIds;
-    chainId: CosmosNetworkIds;
-}
-interface CosmosRequest {
-    chainConfig: CosmosChainConfig;
-    transaction: CosmosTransactionRequest;
-    nearAuthentication: NearAuthentication;
-    derivationPath: KeyDerivationPath;
-    fastAuthRelayerUrl?: string;
-}
-
-declare const EVMTransaction: (req: EVMRequest, keyPair: KeyPair) => Promise<Response>;
-declare const BTCTransaction: (req: BitcoinRequest, keyPair: KeyPair) => Promise<Response>;
-declare const CosmosTransaction: (req: CosmosRequest, keyPair: KeyPair) => Promise<Response>;
-
-declare const keypair_BTCTransaction: typeof BTCTransaction;
-declare const keypair_CosmosTransaction: typeof CosmosTransaction;
-declare const keypair_EVMTransaction: typeof EVMTransaction;
-declare namespace keypair {
-  export { keypair_BTCTransaction as BTCTransaction, keypair_CosmosTransaction as CosmosTransaction, keypair_EVMTransaction as EVMTransaction };
+  export { index$4_Cosmos as Cosmos, type index$4_CosmosNetworkIds as CosmosNetworkIds, type index$4_CosmosTransactionRequest as CosmosTransactionRequest, type index$4_CosmosUnsignedTransaction as CosmosUnsignedTransaction };
 }
 
-declare const signAndSend_keypair: typeof keypair;
-declare namespace signAndSend {
-  export { signAndSend_keypair as keypair };
-}
-
-declare const mpcPayloadsToChainSigTransaction: ({ networkId, contractId, hashesToSign, path, }: {
-    networkId: NetworkId;
-    contractId: ChainSignatureContractIds;
-    hashesToSign: HashToSign[];
-    path: KeyDerivationPath;
-}) => Promise<{
-    receiverId: string;
-    actions: Action[];
-}>;
-declare const responseToMpcSignature: ({ response, }: {
-    response: FinalExecutionOutcome;
-}) => RSVSignature | undefined;
-interface SendTransactionOptions {
-    until: TxExecutionStatus;
-    retryCount: number;
-    delay: number;
-    nodeUrl: string;
-}
-declare const sendTransactionUntil: ({ accountId, keypair, networkId, receiverId, actions, nonce, options, }: {
-    accountId: string;
-    keypair: KeyPair$1;
-    networkId: NetworkId;
-    receiverId: string;
-    actions: Action$1[];
-    nonce?: number;
-    options?: SendTransactionOptions;
-}) => Promise<FinalExecutionOutcome>;
-
-type transaction_SendTransactionOptions = SendTransactionOptions;
-declare const transaction_mpcPayloadsToChainSigTransaction: typeof mpcPayloadsToChainSigTransaction;
-declare const transaction_responseToMpcSignature: typeof responseToMpcSignature;
-declare const transaction_sendTransactionUntil: typeof sendTransactionUntil;
-declare namespace transaction {
-  export { type transaction_SendTransactionOptions as SendTransactionOptions, transaction_mpcPayloadsToChainSigTransaction as mpcPayloadsToChainSigTransaction, transaction_responseToMpcSignature as responseToMpcSignature, transaction_sendTransactionUntil as sendTransactionUntil };
-}
-
-interface ChainSignatureContractArgs {
-    networkId: NearNetworkIds;
-    contractId: ChainSignatureContractIds;
-    accountId?: string;
-    keypair?: KeyPair;
-    rootPublicKey?: NajPublicKey;
-    sendTransactionOptions?: SendTransactionOptions;
-}
-/**
- * Implementation of the ChainSignatureContract for NEAR chains.
- *
- * This class provides an interface to interact with the ChainSignatures contract
- * deployed on NEAR. It supports both view methods (which don't require authentication)
- * and change methods (which require a valid NEAR account and keypair).
- *
- * @extends AbstractChainSignatureContract
- */
-declare class ChainSignatureContract$2 extends ChainSignatureContract$3 {
-    private readonly networkId;
-    private readonly contractId;
-    private readonly accountId;
-    private readonly keypair;
-    private readonly rootPublicKey?;
-    private readonly sendTransactionOptions?;
-    /**
-     * Creates a new instance of the ChainSignatureContract for NEAR chains.
-     *
-     * @param args - Configuration options for the contract
-     * @param args.networkId - The NEAR network ID (e.g. 'testnet', 'mainnet')
-     * @param args.contractId - The contract ID of the deployed ChainSignatures contract
-     * @param args.accountId - Optional NEAR account ID for signing transactions. Required for change methods.
-     * @param args.keypair - Optional NEAR KeyPair for signing transactions. Required for change methods.
-     * @param args.rootPublicKey - Optional root public key for the contract. If not provided, it will be derived from the contract ID.
-     * @param args.sendTransactionOptions - Optional configuration for transaction sending behavior.
-     */
-    constructor({ networkId, contractId, accountId, keypair, rootPublicKey, sendTransactionOptions, }: ChainSignatureContractArgs);
-    private getContract;
-    getCurrentSignatureDeposit(): Promise<BN>;
-    getDerivedPublicKey(args: {
-        path: string;
-        predecessor: string;
-    }): Promise<UncompressedPubKeySEC1>;
-    getPublicKey(): Promise<UncompressedPubKeySEC1>;
-    sign(args: SignArgs, options?: {
-        nonce?: number;
-    }): Promise<RSVSignature>;
-    private requireAccount;
-}
-
-declare const utils$2: {
-    transaction: typeof transaction;
-    signAndSend: typeof signAndSend;
-};
-
+type index$3_ChainAdapter<TransactionRequest, UnsignedTransaction> = ChainAdapter<TransactionRequest, UnsignedTransaction>;
+declare const index$3_ChainAdapter: typeof ChainAdapter;
 declare namespace index$3 {
-  export { ChainSignatureContract$2 as ChainSignatureContract, utils$2 as utils };
+  export { index$3_ChainAdapter as ChainAdapter, index$5 as btc, index$4 as cosmos, index$6 as evm };
 }
 
 declare const abi: ({
@@ -947,7 +780,7 @@ interface SignatureErrorData {
  * 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$3 {
+declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
     private readonly publicClient;
     private readonly walletClient;
     private readonly contractAddress;
@@ -1090,7 +923,575 @@ declare namespace errors {
   export { errors_ResponseError as ResponseError, errors_SignatureContractError as SignatureContractError, errors_SignatureNotFoundError as SignatureNotFoundError, errors_SigningError as SigningError };
 }
 
-declare class ChainSignatureContract extends ChainSignatureContract$3 {
+/**
+ * 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: '4uvZW8K4g4jBg7dzPNbb9XDxJLFBK7V6iC76uofmYvEU';
+    metadata: {
+        name: 'chainSignaturesProject';
+        version: '0.1.0';
+        spec: '0.1.0';
+        description: 'Created with Anchor';
+    };
+    instructions: [
+        {
+            name: 'initialize';
+            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: 'respond';
+            discriminator: [72, 65, 227, 97, 42, 255, 147, 12];
+            accounts: [
+                {
+                    name: 'responder';
+                    signer: true;
+                }
+            ];
+            args: [
+                {
+                    name: 'requestIds';
+                    type: {
+                        vec: {
+                            array: ['u8', 32];
+                        };
+                    };
+                },
+                {
+                    name: 'signatures';
+                    type: {
+                        vec: {
+                            defined: {
+                                name: 'signature';
+                            };
+                        };
+                    };
+                }
+            ];
+        },
+        {
+            name: 'respondError';
+            discriminator: [3, 170, 41, 132, 72, 184, 252, 69];
+            accounts: [
+                {
+                    name: 'responder';
+                    signer: true;
+                }
+            ];
+            args: [
+                {
+                    name: 'requestIds';
+                    type: {
+                        vec: {
+                            array: ['u8', 32];
+                        };
+                    };
+                },
+                {
+                    name: 'errors';
+                    type: {
+                        vec: 'string';
+                    };
+                }
+            ];
+        },
+        {
+            name: 'sign';
+            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';
+                }
+            ];
+            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: 'updateDeposit';
+            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';
+            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: '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';
+        }
+    ];
+    types: [
+        {
+            name: 'affinePoint';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'x';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'y';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'depositUpdatedEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'oldDeposit';
+                        type: 'u64';
+                    },
+                    {
+                        name: 'newDeposit';
+                        type: 'u64';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'fundsWithdrawnEvent';
+            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: 'signature';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'bigR';
+                        type: {
+                            defined: {
+                                name: 'affinePoint';
+                            };
+                        };
+                    },
+                    {
+                        name: 's';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'recoveryId';
+                        type: 'u8';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'signatureErrorEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'requestId';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'responder';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'error';
+                        type: 'string';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'signatureRequestedEvent';
+            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: 'u64';
+                    },
+                    {
+                        name: 'path';
+                        type: 'string';
+                    },
+                    {
+                        name: 'algo';
+                        type: 'string';
+                    },
+                    {
+                        name: 'dest';
+                        type: 'string';
+                    },
+                    {
+                        name: 'params';
+                        type: 'string';
+                    },
+                    {
+                        name: 'feePayer';
+                        type: {
+                            option: 'pubkey';
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'signatureRespondedEvent';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'requestId';
+                        type: {
+                            array: ['u8', 32];
+                        };
+                    },
+                    {
+                        name: 'responder';
+                        type: 'pubkey';
+                    },
+                    {
+                        name: 'signature';
+                        type: {
+                            defined: {
+                                name: 'signature';
+                            };
+                        };
+                    }
+                ];
+            };
+        }
+    ];
+}
+
+interface AffinePoint {
+    x: number[];
+    y: number[];
+}
+interface Signature {
+    bigR: AffinePoint;
+    s: number[];
+    recoveryId: number;
+}
+interface SignatureRespondedEvent {
+    requestId: number[];
+    responder: PublicKey;
+    signature: Signature;
+}
+interface SignatureErrorEvent {
+    requestId: number[];
+    responder: PublicKey;
+    error: string;
+}
+
+declare class ChainSignatureContract extends ChainSignatureContract$2 {
     private readonly provider;
     private readonly program;
     private readonly programId;
@@ -1102,19 +1503,24 @@ declare class ChainSignatureContract extends ChainSignatureContract$3 {
      * @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.rootPublicKey - Optional root public key. If not provided, it will be derived from the program ID
-     * @param args.requesterAddress - Provider wallet address is always the fee payer but requester can be overridden
+     * @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: {
         provider: AnchorProvider;
         programId: string | PublicKey;
-        rootPublicKey?: NajPublicKey;
-        requesterAddress?: string;
+        config?: {
+            rootPublicKey?: NajPublicKey;
+            requesterAddress?: string;
+            idl?: ChainSignaturesProject & Idl;
+        };
     });
     /**
      * Gets the connection from the provider
      */
-    get connection(): _solana_web3_js.Connection;
+    get connection(): Connection;
     getCurrentSignatureDeposit(): Promise<BN>;
     /**
      * Get the Program State PDA
@@ -1142,7 +1548,7 @@ declare class ChainSignatureContract extends ChainSignatureContract$3 {
      * Polls for signature or error events matching the given requestId starting from the solana transaction with signature afterSignature.
      * Returns a signature, error data, or undefined if nothing is found.
      */
-    pollForRequestId({ requestId, payload, path, afterSignature, options, }: {
+    pollForRequestId({ requestId, payload: _payload, path: _path, afterSignature, options, }: {
         requestId: string;
         payload: number[];
         path: string;
@@ -1153,10 +1559,19 @@ declare class ChainSignatureContract extends ChainSignatureContract$3 {
      * Parses transaction logs for signature or error events.
      */
     private parseLogsForEvents;
+    private mapEventToResult;
     /**
      * Generates the request ID for a signature request allowing to track the response.
      */
     getRequestId(args: SignArgs, options?: SignOptions['sign']): string;
+    /**
+     * Subscribes to program events using Anchor's EventParser for regular events,
+     * and CPI parsing for emit_cpi!-emitted events. Returns an unsubscribe fn.
+     */
+    subscribeToEvents(handlers: {
+        onSignatureResponded?: (event: SignatureRespondedEvent, slot: number) => Promise<void> | void;
+        onSignatureError?: (event: SignatureErrorEvent, slot: number) => Promise<void> | void;
+    }): Promise<() => Promise<void>>;
 }
 
 declare const utils: {
@@ -1370,14 +1785,15 @@ declare const utils: {
 
 type index$1_ChainSignatureContract = ChainSignatureContract;
 declare const index$1_ChainSignatureContract: typeof ChainSignatureContract;
+type index$1_ChainSignaturesProject = ChainSignaturesProject;
 declare const index$1_utils: typeof utils;
 declare namespace index$1 {
-  export { index$1_ChainSignatureContract as ChainSignatureContract, index$1_utils as utils };
+  export { index$1_ChainSignatureContract as ChainSignatureContract, type index$1_ChainSignaturesProject as ChainSignaturesProject, index$1_utils as utils };
 }
 
 type index_SignArgs = SignArgs;
 declare namespace index {
-  export { ChainSignatureContract$3 as ChainSignatureContract, type index_SignArgs as SignArgs, index$2 as evm, index$3 as near, index$1 as solana };
+  export { ChainSignatureContract$2 as ChainSignatureContract, type index_SignArgs as SignArgs, index$2 as evm, index$1 as solana };
 }
 
-export { type CompressedPubKeySEC1, type HashToSign, type KeyDerivationPath, type MPCSignature, type NajPublicKey, type NearNearMpcSignature, type RSVSignature, type SigNetEvmMpcSignature, type SigNetNearMpcSignature, type UncompressedPubKeySEC1, index$4 as chainAdapters, constants, index as contracts, index$8 as utils };
+export { type CompressedPubKeySEC1, type HashToSign, type KeyDerivationPath, type MPCSignature, type NajPublicKey, type RSVSignature, type SigNetEvmMpcSignature, type UncompressedPubKeySEC1, index$3 as chainAdapters, constants, index as contracts, index$7 as utils };