signet.js 0.0.2-beta.6 → 0.0.3

package/types/index.d.ts

@@ -1,919 +0,0 @@
-import { NetworkId, Action, FinalExecutionOutcome } from '@near-wallet-selector/core';
-import BN from 'bn.js';
-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';
-
-interface SignArgs {
-    /** The payload to sign as an array of 32 bytes */
-    payload: number[];
-    /** The derivation path for key generation */
-    path: string;
-    /** Version of the key to use */
-    key_version: number;
-}
-/**
- * Base contract interface required for compatibility with Chain instances like EVM and Bitcoin.
- *
- * See {@link EVM} and {@link Bitcoin} for example implementations.
- */
-declare abstract class BaseChainSignatureContract {
-    /**
-     * Gets the current signature deposit required by the contract.
-     * This deposit amount helps manage network congestion.
-     *
-     * @returns Promise resolving to the required deposit amount as a BigNumber
-     */
-    abstract getCurrentSignatureDeposit(): Promise<BN>;
-    /**
-     * Derives a child public key using a\ derivation path and predecessor.
-     *
-     * @param args - Arguments for key derivation
-     * @param args.path - The string path to use derive the key
-     * @param args.predecessor - The id/address of the account requesting signature
-     * @returns Promise resolving to the derived SEC1 uncompressed public key
-     */
-    abstract getDerivedPublicKey(args: {
-        path: string;
-        predecessor: string;
-    } & Record<string, unknown>): Promise<UncompressedPubKeySEC1>;
-}
-/**
- * Full contract interface that extends BaseChainSignatureContract to provide all Sig Network Smart Contract capabilities.
- */
-declare abstract class ChainSignatureContract$2 extends BaseChainSignatureContract {
-    /**
-     * Signs a payload using Sig Network MPC.
-     *
-     * @param args - Arguments for the signing operation
-     * @param args.payload - The data to sign as an array of 32 bytes
-     * @param args.path - The string path to use derive the key
-     * @param args.key_version - Version of the key to use
-     * @returns Promise resolving to the RSV signature
-     */
-    abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>;
-    /**
-     * Gets the public key associated with this contract instance.
-     *
-     * @returns Promise resolving to the SEC1 uncompressed public key
-     */
-    abstract getPublicKey(): Promise<UncompressedPubKeySEC1>;
-}
-
-type HashToSign = SignArgs['payload'];
-type Base58String = string;
-type NajPublicKey = `secp256k1:${Base58String}`;
-type UncompressedPubKeySEC1 = `04${string}`;
-type CompressedPubKeySEC1 = `02${string}` | `03${string}`;
-type KeyDerivationPath = string;
-interface RSVSignature {
-    r: string;
-    s: string;
-    v: number;
-}
-interface 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;
-        y: bigint;
-    };
-    s: bigint;
-    recoveryId: number;
-}
-type MPCSignature = NearNearMpcSignature | SigNetNearMpcSignature | SigNetEvmMpcSignature;
-
-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';
-
-type CosmosNetworkIds = string;
-type CosmosUnsignedTransaction = TxRaw;
-interface CosmosTransactionRequest {
-    address: string;
-    publicKey: string;
-    messages: EncodeObject[];
-    memo?: string;
-    gas?: number;
-}
-
-type EVMUnsignedTransaction = TransactionRequest & {
-    type: 'eip1559';
-    chainId: number;
-};
-interface EVMTransactionRequest extends Omit<EVMUnsignedTransaction, 'chainId' | 'type'> {
-    from: Address;
-}
-type EVMMessage = SignableMessage;
-type EVMTypedData = TypedDataDefinition;
-interface UserOperationV7 {
-    sender: Hex;
-    nonce: Hex;
-    factory: Hex;
-    factoryData: Hex;
-    callData: Hex;
-    callGasLimit: Hex;
-    verificationGasLimit: Hex;
-    preVerificationGas: Hex;
-    maxFeePerGas: Hex;
-    maxPriorityFeePerGas: Hex;
-    paymaster: Hex;
-    paymasterVerificationGasLimit: Hex;
-    paymasterPostOpGasLimit: Hex;
-    paymasterData: Hex;
-    signature: Hex;
-}
-interface UserOperationV6 {
-    sender: Hex;
-    nonce: Hex;
-    initCode: Hex;
-    callData: Hex;
-    callGasLimit: Hex;
-    verificationGasLimit: Hex;
-    preVerificationGas: Hex;
-    maxFeePerGas: Hex;
-    maxPriorityFeePerGas: Hex;
-    paymasterAndData: Hex;
-    signature: Hex;
-}
-
-/**
-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;
-
-declare const transactionBuilder_mpcPayloadsToChainSigTransaction: typeof mpcPayloadsToChainSigTransaction;
-declare const transactionBuilder_responseToMpcSignature: typeof responseToMpcSignature;
-declare namespace transactionBuilder {
-  export { transactionBuilder_mpcPayloadsToChainSigTransaction as mpcPayloadsToChainSigTransaction, transactionBuilder_responseToMpcSignature as responseToMpcSignature };
-}
-
-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 };
-}
-
-declare const index$4_keypair: typeof keypair;
-declare namespace index$4 {
-  export { index$4_keypair as keypair };
-}
-
-interface ChainSignatureContractArgs {
-    networkId: NearNetworkIds;
-    contractId: ChainSignatureContractIds;
-    accountId?: string;
-    keypair?: KeyPair;
-}
-/**
- * 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$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;
-    /**
-     * Creates a new instance of the ChainSignatureContract for EVM chains.
-     *
-     * @param args - Configuration options for the contract
-     * @param args.publicClient - A Viem PublicClient instance for reading from the blockchain
-     * @param args.walletClient - A Viem WalletClient instance for sending transactions
-     * @param args.contractAddress - The address of the deployed ChainSignatures contract (e.g. `0x857ED3A242B59cC24144814a0DF41C397a3811E6`)
-     * @param args.rootPublicKey - Optional root public key. If not provided, it will be derived from the contract address
-     */
-    constructor(args: {
-        publicClient: PublicClient;
-        walletClient: WalletClient;
-        contractAddress: Hex;
-        rootPublicKey?: NajPublicKey;
-    });
-    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>;
-}
-
-declare const abi: ({
-    inputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    stateMutability: string;
-    type: string;
-    name?: undefined;
-    anonymous?: undefined;
-    outputs?: undefined;
-} | {
-    inputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    name: string;
-    type: string;
-    stateMutability?: undefined;
-    anonymous?: undefined;
-    outputs?: undefined;
-} | {
-    anonymous: boolean;
-    inputs: ({
-        indexed: boolean;
-        internalType: string;
-        name: string;
-        type: string;
-        components?: undefined;
-    } | {
-        components: ({
-            components: {
-                internalType: string;
-                name: string;
-                type: string;
-            }[];
-            internalType: string;
-            name: string;
-            type: string;
-        } | {
-            internalType: string;
-            name: string;
-            type: string;
-            components?: undefined;
-        })[];
-        indexed: boolean;
-        internalType: string;
-        name: string;
-        type: string;
-    })[];
-    name: string;
-    type: string;
-    stateMutability?: undefined;
-    outputs?: undefined;
-} | {
-    inputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    name: string;
-    outputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    stateMutability: string;
-    type: string;
-    anonymous?: undefined;
-} | {
-    inputs: {
-        components: ({
-            internalType: string;
-            name: string;
-            type: string;
-            components?: undefined;
-        } | {
-            components: ({
-                components: {
-                    internalType: string;
-                    name: string;
-                    type: string;
-                }[];
-                internalType: string;
-                name: string;
-                type: string;
-            } | {
-                internalType: string;
-                name: string;
-                type: string;
-                components?: undefined;
-            })[];
-            internalType: string;
-            name: string;
-            type: string;
-        })[];
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    name: string;
-    outputs: never[];
-    stateMutability: string;
-    type: string;
-    anonymous?: undefined;
-})[];
-
-declare 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>;
-}
-
-interface EVMFeeProperties {
-    gas: bigint;
-    maxFeePerGas: bigint;
-    maxPriorityFeePerGas: bigint;
-}
-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 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 Chain interface for Bitcoin network.
- * Handles interactions with both Bitcoin mainnet and testnet, supporting P2WPKH transactions.
- */
-declare class Bitcoin extends Chain<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[];
-    }>;
-    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?;
-    /**
-     * 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[];
-    }>;
-    attachTransactionSignature({ transaction, rsvSignatures, }: {
-        transaction: CosmosUnsignedTransaction;
-        rsvSignatures: RSVSignature[];
-    }): string;
-    broadcastTx(txSerialized: string): Promise<string>;
-}
-
-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 };
-}
-
-declare const index_constants: typeof constants;
-declare const index_cryptography: typeof cryptography;
-declare namespace index {
-  export { index$1 as chains, index_constants as constants, index_cryptography as cryptography };
-}
-
-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 };