signet.js 0.0.2-beta.4 → 0.0.2-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signet.js",
-  "version": "0.0.2-beta.4",
+  "version": "0.0.2-beta.5",
   "description": "",
   "type": "module",
   "exports": {
@@ -26,7 +26,7 @@
     "build": "rm -rf dist && npm run build:browser && npm run build:node && npm run build:post && cp package.json README.md LICENSE dist/",
     "build:browser": "tsup --env.TARGET=browser",
     "build:node": "tsup --env.TARGET=node",
-    "build:post": "mkdir -p dist/types && cp dist/node/index.d.ts dist/node/index.d.cts dist/types/",
+    "build:post": "mkdir -p dist/types && cp dist/node/index.d.ts dist/node/index.d.cts dist/types/ && rm dist/node/index.d.ts dist/node/index.d.cts",
     "pre:deploy": "npm run build && npm run docs:build",
     "publish-npm": "npm run pre:deploy && npm publish",
     "publish-npm:beta": "npm run pre:deploy && cd dist && npm publish --tag beta",

package/node/index.d.cts

@@ -1,693 +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 MPCPayloads = Array<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 OldMpcSignature {
-    big_r: {
-        affine_point: string;
-    };
-    s: {
-        scalar: string;
-    };
-    recovery_id: number;
-}
-interface NewMpcSignature {
-    big_r: string;
-    s: string;
-    recovery_id: number;
-}
-type MPCSignature = OldMpcSignature | NewMpcSignature;
-
-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, mpcPayloads, path, }: {
-    networkId: NetworkId;
-    contractId: ChainSignatureContractIds;
-    mpcPayloads: MPCPayloads;
-    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$1 {
-    networkId: NearNetworkIds;
-    contractId: ChainSignatureContractIds;
-    accountId?: string;
-    keypair?: KeyPair;
-}
-/**
- * This contract will default to view methods only.
- * If you want to use the change methods, you need to provide an account and keypair.
- */
-declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
-    private readonly networkId;
-    private readonly contractId;
-    private readonly accountId;
-    private readonly keypair;
-    constructor({ networkId, contractId, accountId, keypair, }: ChainSignatureContractArgs$1);
-    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 ChainSignatureContractArgs {
-    publicClient: PublicClient;
-    walletClient: WalletClient;
-    contractAddress: Hex;
-    rootPublicKey?: NajPublicKey;
-}
-interface SignOptions {
-    sign: {
-        algo?: string;
-        dest?: string;
-        params?: string;
-    };
-    retry: {
-        delay?: number;
-        retryCount?: number;
-    };
-}
-interface SignatureErrorData {
-    requestId: string;
-    responder: string;
-    error: string;
-}
-
-declare class ChainSignatureContract extends ChainSignatureContract$2 {
-    private readonly publicClient;
-    private readonly walletClient;
-    private readonly contractAddress;
-    private readonly rootPublicKey;
-    constructor(args: ChainSignatureContractArgs);
-    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>;
-}
-
-type index$2_ChainSignatureContract = ChainSignatureContract;
-declare const index$2_ChainSignatureContract: typeof ChainSignatureContract;
-declare namespace index$2 {
-  export { index$2_ChainSignatureContract as ChainSignatureContract };
-}
-
-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;
-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 as ROOT_PUBLIC_KEY_V1_SIG_NET_TESTNET and ROOT_PUBLIC_KEY_DEV_V1_SIG_NET_TESTNET.
- *
- * @param najPublicKey - The parent public key in NAJ format (e.g. secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5)
- * @param predecessorId - The predecessor ID calling the signer contract
- * @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 const index_cryptography: typeof cryptography;
-declare namespace index {
-  export { index$1 as chains, index_cryptography as cryptography };
-}
-
-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
-     *          - mpcPayloads: 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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    /**
-     * 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.mpcSignatures - 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;
-        mpcSignatures: 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 parseSignature;
-    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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    prepareMessageForSigning(message: EVMMessage): Promise<{
-        message: EVMMessage;
-        mpcPayloads: MPCPayloads;
-    }>;
-    prepareTypedDataForSigning(typedDataRequest: EVMTypedData): Promise<{
-        typedData: EVMTypedData;
-        mpcPayloads: MPCPayloads;
-    }>;
-    /**
-     * 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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    attachTransactionSignature({ transaction, mpcSignatures, }: {
-        transaction: EVMUnsignedTransaction;
-        mpcSignatures: RSVSignature[];
-    }): `0x02${string}`;
-    attachMessageSignature({ mpcSignatures, }: {
-        message: string;
-        mpcSignatures: RSVSignature[];
-    }): Hex;
-    attachTypedDataSignature({ mpcSignatures, }: {
-        typedData: EVMTypedData;
-        mpcSignatures: RSVSignature[];
-    }): Hex;
-    attachUserOpSignature({ userOp, mpcSignatures, }: {
-        userOp: UserOperationV7 | UserOperationV6;
-        mpcSignatures: 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 parseRSVSignature;
-    /**
-     * 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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    attachTransactionSignature({ transaction: { psbt, publicKey }, mpcSignatures, }: {
-        transaction: BTCUnsignedTransaction;
-        mpcSignatures: 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 parseRSVSignature;
-    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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    attachTransactionSignature({ transaction, mpcSignatures, }: {
-        transaction: CosmosUnsignedTransaction;
-        mpcSignatures: RSVSignature[];
-    }): string;
-    broadcastTx(txSerialized: string): Promise<string>;
-}
-
-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 EVMTransactionRequest, type EVMUnsignedTransaction, type KeyDerivationPath, type MPCPayloads, type MPCSignature, type NajPublicKey, type RSVSignature, type SignArgs, type UncompressedPubKeySEC1, fetchEVMFeeProperties, index as utils };

package/node/index.d.ts

@@ -1,693 +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 MPCPayloads = Array<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 OldMpcSignature {
-    big_r: {
-        affine_point: string;
-    };
-    s: {
-        scalar: string;
-    };
-    recovery_id: number;
-}
-interface NewMpcSignature {
-    big_r: string;
-    s: string;
-    recovery_id: number;
-}
-type MPCSignature = OldMpcSignature | NewMpcSignature;
-
-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, mpcPayloads, path, }: {
-    networkId: NetworkId;
-    contractId: ChainSignatureContractIds;
-    mpcPayloads: MPCPayloads;
-    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$1 {
-    networkId: NearNetworkIds;
-    contractId: ChainSignatureContractIds;
-    accountId?: string;
-    keypair?: KeyPair;
-}
-/**
- * This contract will default to view methods only.
- * If you want to use the change methods, you need to provide an account and keypair.
- */
-declare class ChainSignatureContract$1 extends ChainSignatureContract$2 {
-    private readonly networkId;
-    private readonly contractId;
-    private readonly accountId;
-    private readonly keypair;
-    constructor({ networkId, contractId, accountId, keypair, }: ChainSignatureContractArgs$1);
-    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 ChainSignatureContractArgs {
-    publicClient: PublicClient;
-    walletClient: WalletClient;
-    contractAddress: Hex;
-    rootPublicKey?: NajPublicKey;
-}
-interface SignOptions {
-    sign: {
-        algo?: string;
-        dest?: string;
-        params?: string;
-    };
-    retry: {
-        delay?: number;
-        retryCount?: number;
-    };
-}
-interface SignatureErrorData {
-    requestId: string;
-    responder: string;
-    error: string;
-}
-
-declare class ChainSignatureContract extends ChainSignatureContract$2 {
-    private readonly publicClient;
-    private readonly walletClient;
-    private readonly contractAddress;
-    private readonly rootPublicKey;
-    constructor(args: ChainSignatureContractArgs);
-    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>;
-}
-
-type index$2_ChainSignatureContract = ChainSignatureContract;
-declare const index$2_ChainSignatureContract: typeof ChainSignatureContract;
-declare namespace index$2 {
-  export { index$2_ChainSignatureContract as ChainSignatureContract };
-}
-
-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;
-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 as ROOT_PUBLIC_KEY_V1_SIG_NET_TESTNET and ROOT_PUBLIC_KEY_DEV_V1_SIG_NET_TESTNET.
- *
- * @param najPublicKey - The parent public key in NAJ format (e.g. secp256k1:3Ww8iFjqTHufye5aRGUvrQqETegR4gVUcW8FX5xzscaN9ENhpkffojsxJwi6N1RbbHMTxYa9UyKeqK3fsMuwxjR5)
- * @param predecessorId - The predecessor ID calling the signer contract
- * @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 const index_cryptography: typeof cryptography;
-declare namespace index {
-  export { index$1 as chains, index_cryptography as cryptography };
-}
-
-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
-     *          - mpcPayloads: 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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    /**
-     * 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.mpcSignatures - 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;
-        mpcSignatures: 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 parseSignature;
-    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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    prepareMessageForSigning(message: EVMMessage): Promise<{
-        message: EVMMessage;
-        mpcPayloads: MPCPayloads;
-    }>;
-    prepareTypedDataForSigning(typedDataRequest: EVMTypedData): Promise<{
-        typedData: EVMTypedData;
-        mpcPayloads: MPCPayloads;
-    }>;
-    /**
-     * 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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    attachTransactionSignature({ transaction, mpcSignatures, }: {
-        transaction: EVMUnsignedTransaction;
-        mpcSignatures: RSVSignature[];
-    }): `0x02${string}`;
-    attachMessageSignature({ mpcSignatures, }: {
-        message: string;
-        mpcSignatures: RSVSignature[];
-    }): Hex;
-    attachTypedDataSignature({ mpcSignatures, }: {
-        typedData: EVMTypedData;
-        mpcSignatures: RSVSignature[];
-    }): Hex;
-    attachUserOpSignature({ userOp, mpcSignatures, }: {
-        userOp: UserOperationV7 | UserOperationV6;
-        mpcSignatures: 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 parseRSVSignature;
-    /**
-     * 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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    attachTransactionSignature({ transaction: { psbt, publicKey }, mpcSignatures, }: {
-        transaction: BTCUnsignedTransaction;
-        mpcSignatures: 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 parseRSVSignature;
-    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;
-        mpcPayloads: MPCPayloads;
-    }>;
-    attachTransactionSignature({ transaction, mpcSignatures, }: {
-        transaction: CosmosUnsignedTransaction;
-        mpcSignatures: RSVSignature[];
-    }): string;
-    broadcastTx(txSerialized: string): Promise<string>;
-}
-
-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 EVMTransactionRequest, type EVMUnsignedTransaction, type KeyDerivationPath, type MPCPayloads, type MPCSignature, type NajPublicKey, type RSVSignature, type SignArgs, type UncompressedPubKeySEC1, fetchEVMFeeProperties, index as utils };