signet.js 0.0.4 → 0.0.5-beta.1

package/types/index.d.ts

@@ -1,10 +1,13 @@
-import { NetworkId, Action, FinalExecutionOutcome } from '@near-wallet-selector/core';
 import BN from 'bn.js';
+import { TransactionRequest, Address, SignableMessage, TypedDataDefinition, Hex, Hash, PublicClient, 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';
-import { TransactionRequest, Address, SignableMessage, TypedDataDefinition, Hex, PublicClient, WalletClient, TransactionReceipt, Hash } from 'viem';
 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';
 
 interface SignArgs {
     /** The payload to sign as an array of 32 bytes */
@@ -15,7 +18,7 @@ interface SignArgs {
     key_version: number;
 }
 /**
- * Base contract interface required for compatibility with Chain instances like EVM and Bitcoin.
+ * Base contract interface required for compatibility with ChainAdapter instances like EVM and Bitcoin.
  *
  * See {@link EVM} and {@link Bitcoin} for example implementations.
  */
@@ -97,56 +100,171 @@ interface SigNetEvmMpcSignature {
 }
 type MPCSignature = NearNearMpcSignature | SigNetNearMpcSignature | SigNetEvmMpcSignature;
 
-interface BTCTransaction$1 {
-    vout: Array<{
-        scriptpubkey: string;
-        value: number;
-    }>;
+declare const ENVS: {
+    readonly TESTNET_DEV: "TESTNET_DEV";
+    readonly TESTNET: "TESTNET";
+    readonly MAINNET: "MAINNET";
+};
+declare const CHAINS: {
+    readonly ETHEREUM: "ETHEREUM";
+    readonly NEAR: "NEAR";
+};
+/**
+ * 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: "0x1";
+    readonly NEAR: "0x18d";
+};
+/**
+ * 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 const constants_CHAINS: typeof CHAINS;
+declare const constants_CONTRACT_ADDRESSES: typeof CONTRACT_ADDRESSES;
+declare const constants_ENVS: typeof ENVS;
+declare const constants_KDF_CHAIN_IDS: typeof KDF_CHAIN_IDS;
+declare const constants_ROOT_PUBLIC_KEYS: typeof ROOT_PUBLIC_KEYS;
+declare namespace constants {
+  export { constants_CHAINS as CHAINS, constants_CONTRACT_ADDRESSES as CONTRACT_ADDRESSES, constants_ENVS as ENVS, constants_KDF_CHAIN_IDS as KDF_CHAIN_IDS, constants_ROOT_PUBLIC_KEYS as ROOT_PUBLIC_KEYS };
 }
-interface BTCInput {
-    txid: string;
-    vout: number;
-    value: number;
-    scriptPubKey: Buffer;
+
+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;
+/**
+ * Converts a NAJ public key to an uncompressed SEC1 public key.
+ *
+ * @param najPublicKey - The NAJ public key to convert (e.g. secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5)
+ * @returns The uncompressed SEC1 public key (e.g. 04 || x || y)
+ */
+declare const najToUncompressedPubKeySEC1: (najPublicKey: NajPublicKey) => UncompressedPubKeySEC1;
+/**
+ * Derives a child public key from a parent public key using the sig.network v1.0.0 epsilon derivation scheme.
+ * The parent public keys are defined in @constants.ts
+ *
+ * @param najPublicKey - 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)
+ * @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;
+
+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 namespace cryptography {
+  export { cryptography_compressPubKey as compressPubKey, cryptography_deriveChildPublicKey as deriveChildPublicKey, cryptography_najToUncompressedPubKeySEC1 as najToUncompressedPubKeySEC1, cryptography_toRSV as toRSV };
 }
-type BTCOutput = {
-    value: number;
-} | {
-    address: string;
-    value: number;
-} | {
-    script: Buffer;
-    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;
+
+declare const index$7_cryptography: typeof cryptography;
+declare namespace index$7 {
+  export { index$7_cryptography as cryptography };
 }
-type BTCNetworkIds = 'mainnet' | 'testnet' | 'regtest';
 
-type CosmosNetworkIds = string;
-type CosmosUnsignedTransaction = TxRaw;
-interface CosmosTransactionRequest {
-    address: string;
-    publicKey: string;
-    messages: EncodeObject[];
-    memo?: string;
-    gas?: number;
+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): 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>;
 }
 
 type EVMUnsignedTransaction = TransactionRequest & {
@@ -190,77 +308,361 @@ interface UserOperationV6 {
 }
 
 /**
-Available ChainSignature contracts:
-  - Mainnet: v1.signer
-  - Testnet: v1.signer-prod.testnet
-  - Development (unstable): v1.signer-dev.testnet
-*/
-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 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;
+ * 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.rpcUrl - URL of the EVM JSON-RPC provider (e.g., Infura endpoint)
+     * @param params.contract - Instance of the chain signature contract for MPC operations
+     */
+    constructor({ rpcUrl, contract, }: {
+        rpcUrl: string;
+        contract: BaseChainSignatureContract;
+    });
+    private attachGasAndNonce;
+    private transformRSVSignature;
+    private assembleSignature;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): 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;
+    }>;
+    /**
+     * This implementation is a common step for Biconomy and Alchemy.
+     * Key differences between implementations:
+     * - Signature format: Biconomy omits 0x00 prefix when concatenating, Alchemy includes it
+     * - Version support: Biconomy only supports v6, Alchemy supports both v6 and v7
+     * - Validation: Biconomy uses modules for signature validation, Alchemy uses built-in validation
+     */
+    prepareUserOpForSigning(userOp: UserOperationV7 | UserOperationV6, entryPointAddress?: Address, chainIdArgs?: number): Promise<{
+        userOp: UserOperationV7 | UserOperationV6;
+        hashToSign: HashToSign;
+    }>;
+    finalizeTransactionSigning({ transaction, rsvSignatures, }: {
+        transaction: EVMUnsignedTransaction;
+        rsvSignatures: RSVSignature[];
+    }): `0x02${string}`;
+    finalizeMessageSigning({ rsvSignature, }: {
+        rsvSignature: RSVSignature;
+    }): Hex;
+    finalizeTypedDataSigning({ rsvSignature, }: {
+        rsvSignature: RSVSignature;
+    }): Hex;
+    finalizeUserOpSigning({ userOp, rsvSignature, }: {
+        userOp: UserOperationV7 | UserOperationV6;
+        rsvSignature: RSVSignature;
+    }): UserOperationV7 | UserOperationV6;
+    broadcastTx(txSerialized: `0x${string}`): Promise<Hash>;
+}
+
+interface EVMFeeProperties {
+    gas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}
+declare function fetchEVMFeeProperties(client: PublicClient, transaction: TransactionRequest): Promise<EVMFeeProperties>;
+
+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 {
+    vout: Array<{
+        scriptpubkey: string;
+        value: number;
+    }>;
+}
+interface BTCInput {
+    txid: string;
+    vout: number;
+    value: number;
+    scriptPubKey: Buffer;
+}
+type BTCOutput = {
+    value: number;
+} | {
+    address: string;
+    value: number;
+} | {
+    script: Buffer;
+    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';
+
+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$1>;
+}
+
+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$1>;
+}
+
+declare const BTCRpcAdapters: {
+    Mempool: typeof Mempool;
+};
+
+/**
+ * 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): 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>;
+}
+
+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_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 BTCTransaction$1 as BTCTransaction, type index$5_BTCTransactionRequest as BTCTransactionRequest, type index$5_BTCUnsignedTransaction as BTCUnsignedTransaction, index$5_Bitcoin as Bitcoin };
+}
+
+type CosmosNetworkIds = string;
+type CosmosUnsignedTransaction = TxRaw;
+interface CosmosTransactionRequest {
+    address: string;
+    publicKey: string;
+    messages: EncodeObject[];
+    memo?: string;
+    gas?: number;
+}
+
+/**
+ * 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): 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>;
+}
+
+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_Cosmos as Cosmos, type index$4_CosmosNetworkIds as CosmosNetworkIds, type index$4_CosmosTransactionRequest as CosmosTransactionRequest, type index$4_CosmosUnsignedTransaction as CosmosUnsignedTransaction };
+}
 
-declare const transactionBuilder_mpcPayloadsToChainSigTransaction: typeof mpcPayloadsToChainSigTransaction;
-declare const transactionBuilder_responseToMpcSignature: typeof responseToMpcSignature;
-declare namespace transactionBuilder {
-  export { transactionBuilder_mpcPayloadsToChainSigTransaction as mpcPayloadsToChainSigTransaction, transactionBuilder_responseToMpcSignature as responseToMpcSignature };
+type index$3_ChainAdapter<TransactionRequest, UnsignedTransaction> = ChainAdapter<TransactionRequest, UnsignedTransaction>;
+declare const index$3_ChainAdapter: typeof ChainAdapter;
+declare namespace index$3 {
+  export { index$3_ChainAdapter as ChainAdapter, index$5 as btc, index$4 as cosmos, index$6 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>;
@@ -274,9 +676,45 @@ declare namespace keypair {
   export { keypair_BTCTransaction as BTCTransaction, keypair_CosmosTransaction as CosmosTransaction, keypair_EVMTransaction as EVMTransaction };
 }
 
-declare const index$4_keypair: typeof keypair;
-declare namespace index$4 {
-  export { index$4_keypair as keypair };
+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 {
@@ -284,6 +722,8 @@ interface ChainSignatureContractArgs {
     contractId: ChainSignatureContractIds;
     accountId?: string;
     keypair?: KeyPair;
+    rootPublicKey?: NajPublicKey;
+    sendTransactionOptions?: SendTransactionOptions;
 }
 /**
  * Implementation of the ChainSignatureContract for NEAR chains.
@@ -292,94 +732,47 @@ interface ChainSignatureContractArgs {
  * 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$1 extends ChainSignatureContract$2 {
-    private readonly networkId;
-    private readonly contractId;
-    private readonly accountId;
-    private readonly keypair;
-    /**
-     * 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.
-     */
-    constructor({ networkId, contractId, accountId, keypair, }: ChainSignatureContractArgs);
-    private getContract;
-    getCurrentSignatureDeposit(): Promise<BN>;
-    getDerivedPublicKey(args: {
-        path: string;
-        predecessor: string;
-    }): Promise<UncompressedPubKeySEC1>;
-    getPublicKey(): Promise<UncompressedPubKeySEC1>;
-    sign(args: SignArgs): Promise<RSVSignature>;
-}
-
-declare const index$3_transactionBuilder: typeof transactionBuilder;
-declare namespace index$3 {
-  export { ChainSignatureContract$1 as ChainSignatureContract, index$4 as signAndSend, index$3_transactionBuilder as transactionBuilder };
-}
-
-interface SignOptions {
-    sign: {
-        algo?: string;
-        dest?: string;
-        params?: string;
-    };
-    retry: {
-        delay?: number;
-        retryCount?: number;
-    };
-}
-interface SignatureErrorData {
-    requestId: string;
-    responder: string;
-    error: string;
-}
-
-/**
- * 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 extends ChainSignatureContract$2 {
-    private readonly publicClient;
-    private readonly walletClient;
-    private readonly contractAddress;
-    private readonly rootPublicKey;
+ * @extends AbstractChainSignatureContract
+ */
+declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
+    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 EVM chains.
+     * Creates a new instance of the ChainSignatureContract for NEAR 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
+     * @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(args: {
-        publicClient: PublicClient;
-        walletClient: WalletClient;
-        contractAddress: Hex;
-        rootPublicKey?: NajPublicKey;
-    });
+    constructor({ networkId, contractId, accountId, keypair, rootPublicKey, sendTransactionOptions, }: ChainSignatureContractArgs);
+    private getContract;
     getCurrentSignatureDeposit(): Promise<BN>;
     getDerivedPublicKey(args: {
         path: string;
         predecessor: string;
     }): Promise<UncompressedPubKeySEC1>;
     getPublicKey(): Promise<UncompressedPubKeySEC1>;
-    getLatestKeyVersion(): Promise<number>;
-    sign(args: SignArgs, options?: SignOptions): Promise<RSVSignature>;
-    private getRequestId;
-    getErrorFromEvents(requestId: `0x${string}`, receipt: TransactionReceipt): Promise<SignatureErrorData | undefined>;
-    getSignatureFromEvents(requestId: `0x${string}`, receipt: TransactionReceipt): Promise<RSVSignature | undefined>;
+    sign(args: SignArgs, options?: {
+        nonce?: number;
+    }): Promise<RSVSignature>;
+    private requireAccount;
+}
+
+declare const utils$1: {
+    transaction: typeof transaction;
+    signAndSend: typeof signAndSend;
+};
+
+declare namespace index$2 {
+  export { ChainSignatureContract$1 as ChainSignatureContract, utils$1 as utils };
 }
 
 declare const abi: ({
@@ -475,445 +868,181 @@ declare const abi: ({
                 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 class ChainSignatureError extends Error {
-    requestId: `0x${string}`;
-    receipt: TransactionReceipt;
-    constructor(message: string, requestId: `0x${string}`, receipt: TransactionReceipt);
-}
-declare class SignatureNotFoundError 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 extends ChainSignatureError {
-    originalError?: Error;
-    constructor(requestId: `0x${string}`, receipt: TransactionReceipt, originalError?: Error);
-}
-
-type errors_ChainSignatureError = ChainSignatureError;
-declare const errors_ChainSignatureError: typeof ChainSignatureError;
-type errors_SignatureContractError = SignatureContractError;
-declare const errors_SignatureContractError: typeof SignatureContractError;
-type errors_SignatureNotFoundError = SignatureNotFoundError;
-declare const errors_SignatureNotFoundError: typeof SignatureNotFoundError;
-type errors_SigningError = SigningError;
-declare const errors_SigningError: typeof SigningError;
-declare namespace errors {
-  export { errors_ChainSignatureError as ChainSignatureError, errors_SignatureContractError as SignatureContractError, errors_SignatureNotFoundError as SignatureNotFoundError, errors_SigningError as SigningError };
-}
-
-type index$2_ChainSignatureContract = ChainSignatureContract;
-declare const index$2_ChainSignatureContract: typeof ChainSignatureContract;
-declare const index$2_abi: typeof abi;
-declare const index$2_errors: typeof errors;
-declare namespace index$2 {
-  export { index$2_ChainSignatureContract as ChainSignatureContract, index$2_abi as abi, index$2_errors as errors };
-}
-
-declare namespace index$1 {
-  export { index$2 as evm, index$3 as near };
-}
-
-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;
-/**
- * Converts a NAJ public key to an uncompressed SEC1 public key.
- *
- * @param najPublicKey - The NAJ public key to convert (e.g. secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5)
- * @returns The uncompressed SEC1 public key (e.g. 04 || x || y)
- */
-declare const najToUncompressedPubKeySEC1: (najPublicKey: NajPublicKey) => UncompressedPubKeySEC1;
-/**
- * Derives a child public key from a parent public key using the sig.network v1.0.0 epsilon derivation scheme.
- * The parent public keys are defined in @constants.ts
- *
- * @param najPublicKey - 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)
- * @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;
-
-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 namespace cryptography {
-  export { cryptography_compressPubKey as compressPubKey, cryptography_deriveChildPublicKey as deriveChildPublicKey, cryptography_najToUncompressedPubKeySEC1 as najToUncompressedPubKeySEC1, cryptography_toRSV as toRSV };
-}
-
-declare abstract class Chain<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): 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 attachTransactionSignature()
-     */
-    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 attachTransactionSignature(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>;
-}
-
-/**
- * Implementation of the Chain interface for EVM-compatible networks.
- * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
- */
-declare class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
-    private readonly client;
-    private readonly contract;
-    /**
-     * Creates a new EVM chain instance
-     * @param params - Configuration parameters
-     * @param params.rpcUrl - URL of the EVM JSON-RPC provider (e.g., Infura endpoint)
-     * @param params.contract - Instance of the chain signature contract for MPC operations
-     */
-    constructor({ rpcUrl, contract, }: {
-        rpcUrl: string;
-        contract: BaseChainSignatureContract;
-    });
-    private attachGasAndNonce;
-    private transformRSVSignature;
-    private assembleSignature;
-    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): 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<{
-        hashesToSign: HashToSign[];
-    }>;
-    prepareTypedDataForSigning(typedDataRequest: EVMTypedData): Promise<{
-        hashesToSign: HashToSign[];
-    }>;
-    /**
-     * This implementation is a common step for Biconomy and Alchemy.
-     * Key differences between implementations:
-     * - Signature format: Biconomy omits 0x00 prefix when concatenating, Alchemy includes it
-     * - Version support: Biconomy only supports v6, Alchemy supports both v6 and v7
-     * - Validation: Biconomy uses modules for signature validation, Alchemy uses built-in validation
-     */
-    prepareUserOpForSigning(userOp: UserOperationV7 | UserOperationV6, entryPointAddress?: Address, chainIdArgs?: number): Promise<{
-        userOp: UserOperationV7 | UserOperationV6;
-        hashesToSign: HashToSign[];
-    }>;
-    attachTransactionSignature({ transaction, rsvSignatures, }: {
-        transaction: EVMUnsignedTransaction;
-        rsvSignatures: RSVSignature[];
-    }): `0x02${string}`;
-    assembleMessageSignature({ rsvSignatures, }: {
-        rsvSignatures: RSVSignature[];
-    }): Hex;
-    assembleTypedDataSignature({ rsvSignatures, }: {
-        rsvSignatures: RSVSignature[];
-    }): Hex;
-    attachUserOpSignature({ userOp, rsvSignatures, }: {
-        userOp: UserOperationV7 | UserOperationV6;
-        rsvSignatures: RSVSignature[];
-    }): UserOperationV7 | UserOperationV6;
-    broadcastTx(txSerialized: `0x${string}`): Promise<Hash>;
-}
+            internalType: string;
+            name: string;
+            type: string;
+        })[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
 
-interface EVMFeeProperties {
-    gas: bigint;
-    maxFeePerGas: bigint;
-    maxPriorityFeePerGas: bigint;
+declare const ChainSignaturesContractABI_abi: typeof abi;
+declare namespace ChainSignaturesContractABI {
+  export { ChainSignaturesContractABI_abi as abi };
 }
-declare function fetchEVMFeeProperties(client: PublicClient, transaction: TransactionRequest): Promise<EVMFeeProperties>;
 
-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$1>;
+declare class ChainSignatureError extends Error {
+    requestId: `0x${string}`;
+    receipt: TransactionReceipt;
+    constructor(message: string, requestId: `0x${string}`, receipt: TransactionReceipt);
+}
+declare class SignatureNotFoundError 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 extends ChainSignatureError {
+    originalError?: Error;
+    constructor(requestId: `0x${string}`, receipt: TransactionReceipt, originalError?: Error);
 }
 
-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$1>;
+type errors_ChainSignatureError = ChainSignatureError;
+declare const errors_ChainSignatureError: typeof ChainSignatureError;
+type errors_SignatureContractError = SignatureContractError;
+declare const errors_SignatureContractError: typeof SignatureContractError;
+type errors_SignatureNotFoundError = SignatureNotFoundError;
+declare const errors_SignatureNotFoundError: typeof SignatureNotFoundError;
+type errors_SigningError = SigningError;
+declare const errors_SigningError: typeof SigningError;
+declare namespace errors {
+  export { errors_ChainSignatureError as ChainSignatureError, errors_SignatureContractError as SignatureContractError, errors_SignatureNotFoundError as SignatureNotFoundError, errors_SigningError as SigningError };
 }
 
-declare const BTCRpcAdapters: {
-    Mempool: typeof Mempool;
-};
+interface SignOptions {
+    sign: {
+        algo?: string;
+        dest?: string;
+        params?: string;
+    };
+    retry: {
+        delay?: number;
+        retryCount?: number;
+    };
+}
+interface SignatureErrorData {
+    requestId: string;
+    responder: string;
+    error: string;
+}
+interface RequestIdArgs {
+    address: Address;
+    payload: Hex;
+    path: string;
+    keyVersion: number;
+    chainId: bigint;
+    algo: string;
+    dest: string;
+    params: string;
+}
 
 /**
- * Implementation of the Chain interface for Bitcoin network.
- * Handles interactions with both Bitcoin mainnet and testnet, supporting P2WPKH transactions.
+ * 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 Bitcoin extends Chain<BTCTransactionRequest, BTCUnsignedTransaction> {
-    private static readonly SATOSHIS_PER_BTC;
-    private readonly network;
-    private readonly btcRpcAdapter;
-    private readonly contract;
+declare class ChainSignatureContract extends ChainSignatureContract$2 {
+    private readonly publicClient;
+    private readonly walletClient;
+    private readonly contractAddress;
+    private readonly rootPublicKey;
     /**
-     * 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
+     * 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({ network, contract, btcRpcAdapter, }: {
-        network: BTCNetworkIds;
-        contract: BaseChainSignatureContract;
-        btcRpcAdapter: BTCRpcAdapter;
+    constructor(args: {
+        publicClient: PublicClient;
+        walletClient: WalletClient;
+        contractAddress: Hex;
+        rootPublicKey?: NajPublicKey;
     });
+    getCurrentSignatureDeposit(): Promise<BN>;
+    getDerivedPublicKey(args: {
+        path: string;
+        predecessor: string;
+    }): Promise<UncompressedPubKeySEC1>;
+    getPublicKey(): Promise<UncompressedPubKeySEC1>;
+    getLatestKeyVersion(): Promise<number>;
     /**
-     * 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)
+     * 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.
      */
-    static toSatoshi(btc: number): number;
-    private fetchTransaction;
-    private static transformRSVSignature;
+    sign(args: SignArgs, options?: SignOptions): Promise<RSVSignature>;
     /**
-     * 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
+     * Generates the request ID for a signature request allowing to track the response.
+     *
+     * @param request - The signature request object containing:
+     *   @param request.address - The contract/wallet address calling the signing contract
+     *   @param request.payload - The data payload to be signed as a hex string
+     *   @param request.path - The derivation path for the key
+     *   @param request.keyVersion - The version of the key to use
+     *   @param request.chainId - The chain ID as a bigint
+     *   @param request.algo - The signing algorithm to use
+     *   @param request.dest - The destination for the signature
+     *   @param request.params - Additional parameters for the signing process
+     * @returns A hex string representing the unique request ID
+     *
+     * @example
+     * ```typescript
+     * const requestId = ChainSignatureContract.getRequestId({
+     *   address: walletClient.account.address,
+     *   payload: payload: `0x${Buffer.from(args.payload).toString('hex')}`,,
+     *   path: '',
+     *   keyVersion: 0,
+     *   chainId: 1n,
+     *   algo: '',
+     *   dest: '',
+     *   params: ''
+     * });
+     * console.log(requestId); // 0x...
+     * ```
      */
-    createPSBT({ transactionRequest, }: {
-        transactionRequest: BTCTransactionRequest;
-    }): Promise<bitcoin.Psbt>;
-    getBalance(address: string): Promise<{
-        balance: bigint;
-        decimals: number;
-    }>;
-    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
-        address: string;
-        publicKey: string;
-    }>;
-    serializeTransaction(transaction: BTCUnsignedTransaction): string;
-    deserializeTransaction(serialized: string): BTCUnsignedTransaction;
-    prepareTransactionForSigning(transactionRequest: BTCTransactionRequest): Promise<{
-        transaction: BTCUnsignedTransaction;
-        hashesToSign: HashToSign[];
-    }>;
-    attachTransactionSignature({ transaction: { psbt, publicKey }, rsvSignatures, }: {
-        transaction: BTCUnsignedTransaction;
-        rsvSignatures: RSVSignature[];
-    }): string;
-    broadcastTx(txSerialized: string): Promise<string>;
-}
-
-/**
- * Implementation of the Chain interface for Cosmos-based networks.
- * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
- */
-declare class Cosmos extends Chain<CosmosTransactionRequest, CosmosUnsignedTransaction> {
-    private readonly registry;
-    private readonly chainId;
-    private readonly contract;
-    private readonly endpoints?;
+    getRequestId(request: RequestIdArgs): Hex;
+    getErrorFromEvents(requestId: Hex, fromBlock: bigint): Promise<SignatureErrorData | undefined>;
     /**
-     * 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
+     * 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
      */
-    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): Promise<{
-        address: string;
-        publicKey: string;
-    }>;
-    serializeTransaction(transaction: CosmosUnsignedTransaction): string;
-    deserializeTransaction(serialized: string): CosmosUnsignedTransaction;
-    prepareTransactionForSigning(transactionRequest: CosmosTransactionRequest): Promise<{
-        transaction: CosmosUnsignedTransaction;
-        hashesToSign: HashToSign[];
-    }>;
-    attachTransactionSignature({ transaction, rsvSignatures, }: {
-        transaction: CosmosUnsignedTransaction;
-        rsvSignatures: RSVSignature[];
-    }): string;
-    broadcastTx(txSerialized: string): Promise<string>;
+    getSignatureFromEvents(requestId: Hex, fromBlock: bigint): Promise<RSVSignature | undefined>;
 }
 
-declare const ENVS: {
-    readonly TESTNET_DEV: "TESTNET_DEV";
-    readonly TESTNET: "TESTNET";
-    readonly MAINNET: "MAINNET";
-};
-declare const CHAINS: {
-    readonly ETHEREUM: "ETHEREUM";
-    readonly NEAR: "NEAR";
-};
-/**
- * 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: "0x1";
-    readonly NEAR: "0x18d";
+declare const utils: {
+    ChainSignaturesContractABI: typeof ChainSignaturesContractABI;
+    errors: typeof errors;
 };
-/**
- * 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 const constants_CHAINS: typeof CHAINS;
-declare const constants_CONTRACT_ADDRESSES: typeof CONTRACT_ADDRESSES;
-declare const constants_ENVS: typeof ENVS;
-declare const constants_KDF_CHAIN_IDS: typeof KDF_CHAIN_IDS;
-declare const constants_ROOT_PUBLIC_KEYS: typeof ROOT_PUBLIC_KEYS;
-declare namespace constants {
-  export { constants_CHAINS as CHAINS, constants_CONTRACT_ADDRESSES as CONTRACT_ADDRESSES, constants_ENVS as ENVS, constants_KDF_CHAIN_IDS as KDF_CHAIN_IDS, constants_ROOT_PUBLIC_KEYS as ROOT_PUBLIC_KEYS };
+type index$1_ChainSignatureContract = ChainSignatureContract;
+declare const index$1_ChainSignatureContract: typeof ChainSignatureContract;
+declare const index$1_utils: typeof utils;
+declare namespace index$1 {
+  export { index$1_ChainSignatureContract as ChainSignatureContract, index$1_utils as utils };
 }
 
-declare const index_constants: typeof constants;
-declare const index_cryptography: typeof cryptography;
+type index_SignArgs = SignArgs;
 declare namespace index {
-  export { index$1 as chains, index_constants as constants, index_cryptography as cryptography };
+  export { ChainSignatureContract$2 as ChainSignatureContract, type index_SignArgs as SignArgs, index$1 as evm, index$2 as near };
 }
 
-export { type BTCInput, type BTCNetworkIds, type BTCOutput, BTCRpcAdapter, BTCRpcAdapters, type BTCTransaction$1 as BTCTransaction, type BTCTransactionRequest, type BTCUnsignedTransaction, Bitcoin, Chain, ChainSignatureContract$2 as ChainSignatureContract, type CompressedPubKeySEC1, Cosmos, type CosmosNetworkIds, type CosmosTransactionRequest, type CosmosUnsignedTransaction, EVM, type EVMMessage, type EVMTransactionRequest, type EVMTypedData, type EVMUnsignedTransaction, type HashToSign, type KeyDerivationPath, type MPCSignature, type NajPublicKey, type NearNearMpcSignature, type RSVSignature, type SigNetEvmMpcSignature, type SigNetNearMpcSignature, type SignArgs, type UncompressedPubKeySEC1, fetchEVMFeeProperties, index as utils };
+export { type CompressedPubKeySEC1, type HashToSign, type KeyDerivationPath, type MPCSignature, type NajPublicKey, type NearNearMpcSignature, type RSVSignature, type SigNetEvmMpcSignature, type SigNetNearMpcSignature, type UncompressedPubKeySEC1, index$3 as chainAdapters, constants, index as contracts, index$7 as utils };