signet.js 0.0.1-beta.0

package/src/chains/Chain.d.ts

@@ -0,0 +1,89 @@
+import type { KeyDerivationPath, MPCPayloads, RSVSignature } from '@chains';
+/**
+ * Core interface for blockchain implementations.
+ * Provides a standardized way to interact with different blockchain networks through a common set of methods.
+ *
+ * @typeParam TransactionRequest - The type of transaction request specific to the blockchain
+ * @typeParam UnsignedTransaction - The type of unsigned transaction specific to the blockchain
+ */
+export declare abstract class Chain<TransactionRequest, UnsignedTransaction> {
+    /**
+     * Gets the native token balance for a given address
+     *
+     * @param address - The blockchain address to check
+     * @returns Promise resolving to the balance as a string, formatted according to the chain's decimal places (e.g. ETH, BTC, etc.)
+     * @throws Error if the balance fetch fails or the address is invalid
+     */
+    abstract getBalance(address: string): Promise<string>;
+    /**
+     * Derives an address and public key from a signer ID and derivation path.
+     * Uses MPC (Multi-Party Computation) to derive the key pair securely.
+     *
+     * @param predecessor - The signer ID used to call the sign function on ChainSignatureContract
+     * @param path - The derivation path that uniquely identifies this key pair
+     * @returns Promise resolving to the derived address and its corresponding public key
+     * @throws Error if key derivation fails or the signer ID is invalid
+     */
+    abstract deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    /**
+     * Stores an unsigned transaction in local storage for later use.
+     * This method persists transaction data between page reloads and browser sessions.
+     * Particularly useful for browser-based wallets that need to maintain transaction state.
+     *
+     * @param transaction - The unsigned transaction to store
+     * @param storageKey - Unique key to identify the stored transaction
+     */
+    abstract setTransaction(transaction: UnsignedTransaction, storageKey: string): void;
+    /**
+     * Retrieves a previously stored transaction from local storage.
+     *
+     * @param storageKey - The key used to store the transaction
+     * @param options - Additional options
+     * @param options.remove - If true, removes the transaction from storage after retrieval
+     * @returns The stored transaction or undefined if not found
+     */
+    abstract getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): UnsignedTransaction | undefined;
+    /**
+     * Prepares a transaction for 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 the unsigned transaction and MPC payloads for signing
+     * @throws Error if transaction preparation fails
+     */
+    abstract getMPCPayloadAndTransaction(transactionRequest: TransactionRequest): Promise<{
+        transaction: UnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    /**
+     * Adds MPC-generated signatures to an unsigned transaction.
+     * The signatures are applied according to the chain's specific signing scheme.
+     *
+     * @param params - Parameters for adding signatures
+     * @param params.transaction - The unsigned transaction to sign
+     * @param params.mpcSignatures - Array of RSV signatures generated through MPC
+     * @returns The serialized signed transaction ready for broadcast
+     * @throws Error if signature application fails
+     */
+    abstract addSignature(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
+     * @throws Error if broadcast fails or transaction is rejected
+     */
+    abstract broadcastTx(txSerialized: string): Promise<string>;
+}

package/src/chains/Chain.js

@@ -0,0 +1,9 @@
+/**
+ * Core interface for blockchain implementations.
+ * Provides a standardized way to interact with different blockchain networks through a common set of methods.
+ *
+ * @typeParam TransactionRequest - The type of transaction request specific to the blockchain
+ * @typeParam UnsignedTransaction - The type of unsigned transaction specific to the blockchain
+ */
+export class Chain {
+}

package/src/chains/ChainSignatureContract.d.ts

@@ -0,0 +1,62 @@
+import type BN from 'bn.js';
+import type { RSVSignature, UncompressedPubKeySEC1 } from '@chains';
+/**
+ * Arguments for the sign method
+ */
+export 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;
+}
+/**
+ * Abstract class defining the interface for chain signature contracts.
+ * This contract handles MPC (Multi-Party Computation) operations for secure key derivation and signing.
+ * It serves as a bridge between the blockchain implementations and the MPC infrastructure.
+ */
+export declare abstract class ChainSignatureContract {
+    /**
+     * 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
+     * @throws Error if the deposit check fails
+     */
+    abstract getCurrentSignatureDeposit(): Promise<BN>;
+    /**
+     * Gets the public key associated with this contract.
+     * This is the root public key from which child keys can be derived.
+     *
+     * @returns Promise resolving to the uncompressed public key
+     * @throws Error if public key retrieval fails
+     */
+    abstract getPublicKey(): Promise<UncompressedPubKeySEC1>;
+    /**
+     * Signs a payload using MPC.
+     * This is the core signing operation that coordinates with the MPC infrastructure.
+     *
+     * @param args - Arguments for the signing operation
+     * @param args.payload - The data to sign
+     * @param args.path - Derivation path for the signing key
+     * @param args.key_version - Version of the key to use
+     * @returns Promise resolving to the RSV signature
+     * @throws Error if signing fails or is rejected
+     */
+    abstract sign(args: SignArgs & Record<string, unknown>): Promise<RSVSignature>;
+    /**
+     * Derives a child public key using a derivation path and predecessor.
+     * This method implements hierarchical deterministic key derivation.
+     *
+     * @param args - Arguments for key derivation
+     * @param args.path - The derivation path to use
+     * @param args.predecessor - The predecessor key (usually a NEAR account) that controls this derived key
+     * @returns Promise resolving to the derived uncompressed public key
+     * @throws Error if key derivation fails
+     */
+    abstract getDerivedPublicKey(args: {
+        path: string;
+        predecessor: string;
+    } & Record<string, unknown>): Promise<UncompressedPubKeySEC1>;
+}

package/src/chains/ChainSignatureContract.js

@@ -0,0 +1,7 @@
+/**
+ * Abstract class defining the interface for chain signature contracts.
+ * This contract handles MPC (Multi-Party Computation) operations for secure key derivation and signing.
+ * It serves as a bridge between the blockchain implementations and the MPC infrastructure.
+ */
+export class ChainSignatureContract {
+}

package/src/chains/Cosmos/Cosmos.d.ts

@@ -0,0 +1,49 @@
+import type { MPCPayloads, RSVSignature, KeyDerivationPath, CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction, ChainSignatureContract } from '@chains';
+import { Chain } from '@chains';
+/**
+ * Implementation of the Chain interface for Cosmos-based networks.
+ * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
+ */
+export 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: ChainSignatureContract;
+        chainId: CosmosNetworkIds;
+        endpoints?: {
+            rpcUrl?: string;
+            restUrl?: string;
+        };
+    });
+    private parseRSVSignature;
+    private getChainInfo;
+    getBalance(address: string): Promise<string>;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    setTransaction(transaction: CosmosUnsignedTransaction, storageKey: string): void;
+    getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): CosmosUnsignedTransaction | undefined;
+    getMPCPayloadAndTransaction(transactionRequest: CosmosTransactionRequest): Promise<{
+        transaction: CosmosUnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    addSignature({ transaction, mpcSignatures, }: {
+        transaction: CosmosUnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    broadcastTx(txSerialized: string): Promise<string>;
+}

package/src/chains/Cosmos/Cosmos.js

@@ -0,0 +1,156 @@
+import { encodeSecp256k1Pubkey } from '@cosmjs/amino';
+import { ripemd160, sha256 } from '@cosmjs/crypto';
+import { toBase64, fromBase64, fromHex } from '@cosmjs/encoding';
+import { Registry, makeSignBytes, encodePubkey, makeAuthInfoBytes, makeSignDoc, } from '@cosmjs/proto-signing';
+import { GasPrice, StargateClient, calculateFee } from '@cosmjs/stargate';
+import { bech32 } from 'bech32';
+import { SignMode } from 'cosmjs-types/cosmos/tx/signing/v1beta1/signing';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { Chain, utils } from '@chains';
+import { fetchChainInfo } from '@chains/Cosmos/utils';
+/**
+ * Implementation of the Chain interface for Cosmos-based networks.
+ * Handles interactions with Cosmos SDK chains like Cosmos Hub, Osmosis, etc.
+ */
+export class Cosmos extends Chain {
+    /**
+     * 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, }) {
+        super();
+        this.contract = contract;
+        this.registry = new Registry();
+        this.chainId = chainId;
+        this.endpoints = endpoints;
+    }
+    parseRSVSignature(rsvSignature) {
+        return new Uint8Array([
+            ...fromHex(rsvSignature.r),
+            ...fromHex(rsvSignature.s),
+        ]);
+    }
+    async getChainInfo() {
+        return {
+            ...(await fetchChainInfo(this.chainId)),
+            ...this.endpoints,
+        };
+    }
+    async getBalance(address) {
+        try {
+            const { restUrl, denom, decimals } = await this.getChainInfo();
+            const response = await fetch(`${restUrl}/cosmos/bank/v1beta1/balances/${address}`);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = (await response.json());
+            const balance = data.balances.find((b) => b.denom === denom);
+            const amount = balance?.amount ?? '0';
+            const formattedBalance = (parseInt(amount) / Math.pow(10, decimals)).toString();
+            return formattedBalance;
+        }
+        catch (error) {
+            console.error('Failed to fetch Cosmos balance:', error);
+            throw new Error('Failed to fetch Cosmos balance');
+        }
+    }
+    async deriveAddressAndPublicKey(predecessor, path) {
+        const { prefix } = await this.getChainInfo();
+        const uncompressedPubKey = await this.contract.getDerivedPublicKey({
+            path,
+            predecessor,
+        });
+        if (!uncompressedPubKey) {
+            throw new Error('Failed to get derived public key');
+        }
+        const derivedKey = utils.compressPubKey(uncompressedPubKey);
+        const pubKeySha256 = sha256(fromHex(derivedKey));
+        const ripemd160Hash = ripemd160(pubKeySha256);
+        const address = bech32.encode(prefix, bech32.toWords(ripemd160Hash));
+        return { address, publicKey: derivedKey };
+    }
+    setTransaction(transaction, storageKey) {
+        const serialized = TxRaw.encode(transaction).finish();
+        window.localStorage.setItem(storageKey, toBase64(serialized));
+    }
+    getTransaction(storageKey, options) {
+        const serialized = window.localStorage.getItem(storageKey);
+        if (!serialized)
+            return undefined;
+        if (options?.remove) {
+            window.localStorage.removeItem(storageKey);
+        }
+        return TxRaw.decode(fromBase64(serialized));
+    }
+    async getMPCPayloadAndTransaction(transactionRequest) {
+        const { denom, rpcUrl, gasPrice } = await this.getChainInfo();
+        const publicKeyBytes = fromHex(transactionRequest.publicKey);
+        const gasLimit = transactionRequest.gas || 200000;
+        const fee = calculateFee(gasLimit, GasPrice.fromString(`${gasPrice}${denom}`));
+        const client = await StargateClient.connect(rpcUrl);
+        const accountOnChain = await client.getAccount(transactionRequest.address);
+        if (!accountOnChain) {
+            throw new Error(`Account ${transactionRequest.address} does not exist on chain`);
+        }
+        const { accountNumber, sequence } = accountOnChain;
+        const txBodyEncodeObject = {
+            typeUrl: '/cosmos.tx.v1beta1.TxBody',
+            value: {
+                messages: transactionRequest.messages,
+                memo: transactionRequest.memo || '',
+            },
+        };
+        const txBodyBytes = this.registry.encode(txBodyEncodeObject);
+        const pubkey = encodePubkey(encodeSecp256k1Pubkey(publicKeyBytes));
+        // TODO: Allow caller to provide: multiple signers, fee payer, fee granter
+        const authInfoBytes = makeAuthInfoBytes([
+            {
+                pubkey,
+                sequence,
+            },
+        ], fee.amount, Number(fee.gas), undefined, undefined, SignMode.SIGN_MODE_DIRECT);
+        const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, this.chainId, accountNumber);
+        const signBytes = makeSignBytes(signDoc);
+        const payload = Array.from(sha256(signBytes));
+        return {
+            transaction: TxRaw.fromPartial({
+                bodyBytes: txBodyBytes,
+                authInfoBytes,
+                signatures: [],
+            }),
+            mpcPayloads: [
+                {
+                    index: 0,
+                    payload,
+                },
+            ],
+        };
+    }
+    addSignature({ transaction, mpcSignatures, }) {
+        // Allow support for multi-sig but the package only supports single-sig
+        transaction.signatures = mpcSignatures.map((sig) => this.parseRSVSignature(sig));
+        const txBytes = TxRaw.encode(transaction).finish();
+        return Buffer.from(txBytes).toString('hex');
+    }
+    async broadcastTx(txSerialized) {
+        try {
+            const { rpcUrl } = await this.getChainInfo();
+            const client = await StargateClient.connect(rpcUrl);
+            const txBytes = fromHex(txSerialized);
+            const broadcastResponse = await client.broadcastTx(txBytes);
+            if (broadcastResponse.code !== 0) {
+                throw new Error(`Broadcast error: ${broadcastResponse.rawLog}`);
+            }
+            return broadcastResponse.transactionHash;
+        }
+        catch (error) {
+            console.error('Transaction broadcast failed:', error);
+            throw new Error('Failed to broadcast transaction.');
+        }
+    }
+}

package/src/chains/Cosmos/types.d.ts

@@ -0,0 +1,30 @@
+import { type EncodeObject } from '@cosmjs/proto-signing';
+import { type TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+export type CosmosNetworkIds = string;
+export type CosmosUnsignedTransaction = TxRaw;
+export interface CosmosTransactionRequest {
+    address: string;
+    publicKey: string;
+    messages: EncodeObject[];
+    memo?: string;
+    gas?: number;
+}
+export interface BalanceResponse {
+    balances: Array<{
+        denom: string;
+        amount: string;
+    }>;
+    pagination: {
+        next_key: string | null;
+        total: string;
+    };
+}
+export interface ChainInfo {
+    prefix: string;
+    denom: string;
+    rpcUrl: string;
+    restUrl: string;
+    expectedChainId: string;
+    gasPrice: number;
+    decimals: number;
+}

package/src/chains/Cosmos/types.js

@@ -0,0 +1 @@
+export {};

package/src/chains/Cosmos/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ChainInfo } from '@chains/Cosmos/types';
+export declare const fetchChainInfo: (chainId: string) => Promise<ChainInfo>;

package/src/chains/Cosmos/utils.js

@@ -0,0 +1,27 @@
+import { chains, assets } from 'chain-registry';
+export const fetchChainInfo = async (chainId) => {
+    const chainInfo = chains.find((chain) => chain.chain_id === chainId);
+    if (!chainInfo) {
+        throw new Error(`Chain info not found for chainId: ${chainId}`);
+    }
+    const { bech32_prefix: prefix, chain_id: expectedChainId } = chainInfo;
+    const denom = chainInfo.staking?.staking_tokens?.[0]?.denom;
+    const rpcUrl = chainInfo.apis?.rpc?.[0]?.address;
+    const restUrl = chainInfo.apis?.rest?.[0]?.address;
+    const gasPrice = chainInfo.fees?.fee_tokens?.[0]?.average_gas_price;
+    if (!prefix ||
+        !denom ||
+        !rpcUrl ||
+        !restUrl ||
+        !expectedChainId ||
+        gasPrice === undefined) {
+        throw new Error(`Missing required chain information for ${chainInfo.chain_name}`);
+    }
+    const assetList = assets.find((asset) => asset.chain_name === chainInfo.chain_name);
+    const asset = assetList?.assets.find((asset) => asset.base === denom);
+    const decimals = asset?.denom_units.find((unit) => unit.denom === asset.display)?.exponent;
+    if (decimals === undefined) {
+        throw new Error(`Could not find decimals for ${denom} on chain ${chainInfo.chain_name}`);
+    }
+    return { prefix, denom, rpcUrl, restUrl, expectedChainId, gasPrice, decimals };
+};

package/src/chains/EVM/EVM.d.ts

@@ -0,0 +1,40 @@
+import { type MPCPayloads, type RSVSignature, type KeyDerivationPath, type EVMTransactionRequest, type EVMUnsignedTransaction, type ChainSignatureContract } from '@chains';
+import { Chain } from '@chains';
+/**
+ * Implementation of the Chain interface for EVM-compatible networks.
+ * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
+ */
+export declare class EVM extends Chain<EVMTransactionRequest, EVMUnsignedTransaction> {
+    private readonly provider;
+    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: ChainSignatureContract;
+    });
+    private attachGasAndNonce;
+    private parseSignature;
+    deriveAddressAndPublicKey(predecessor: string, path: KeyDerivationPath): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    getBalance(address: string): Promise<string>;
+    setTransaction(transaction: EVMUnsignedTransaction, storageKey: string): void;
+    getTransaction(storageKey: string, options?: {
+        remove?: boolean;
+    }): EVMUnsignedTransaction | undefined;
+    getMPCPayloadAndTransaction(transactionRequest: EVMTransactionRequest): Promise<{
+        transaction: EVMUnsignedTransaction;
+        mpcPayloads: MPCPayloads;
+    }>;
+    addSignature({ transaction, mpcSignatures, }: {
+        transaction: EVMUnsignedTransaction;
+        mpcSignatures: RSVSignature[];
+    }): string;
+    broadcastTx(txSerialized: string): Promise<string>;
+}

package/src/chains/EVM/EVM.js

@@ -0,0 +1,108 @@
+import { fromHex } from '@cosmjs/encoding';
+import { ethers, keccak256 } from 'ethers';
+import { Chain, fetchEVMFeeProperties } from '@chains';
+/**
+ * Implementation of the Chain interface for EVM-compatible networks.
+ * Handles interactions with Ethereum Virtual Machine based blockchains like Ethereum, BSC, Polygon, etc.
+ */
+export class EVM extends Chain {
+    /**
+     * 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, }) {
+        super();
+        this.contract = contract;
+        this.provider = new ethers.JsonRpcProvider(rpcUrl);
+    }
+    async attachGasAndNonce(transaction) {
+        const fees = await fetchEVMFeeProperties(this.provider._getConnection().url, transaction);
+        const nonce = await this.provider.getTransactionCount(transaction.from, 'latest');
+        const { from, ...rest } = transaction;
+        return {
+            ...fees,
+            chainId: this.provider._network.chainId,
+            nonce,
+            type: 2,
+            ...rest,
+        };
+    }
+    parseSignature(signature) {
+        return ethers.Signature.from({
+            r: `0x${signature.r}`,
+            s: `0x${signature.s}`,
+            v: signature.v,
+        });
+    }
+    async deriveAddressAndPublicKey(predecessor, path) {
+        const uncompressedPubKey = await this.contract.getDerivedPublicKey({
+            path,
+            predecessor,
+        });
+        if (!uncompressedPubKey) {
+            throw new Error('Failed to get derived public key');
+        }
+        const publicKeyNoPrefix = uncompressedPubKey.startsWith('04')
+            ? uncompressedPubKey.substring(2)
+            : uncompressedPubKey;
+        const hash = ethers.keccak256(fromHex(publicKeyNoPrefix));
+        return {
+            address: `0x${hash.substring(hash.length - 40)}`,
+            publicKey: uncompressedPubKey,
+        };
+    }
+    async getBalance(address) {
+        try {
+            const balance = await this.provider.getBalance(address);
+            return ethers.formatEther(balance);
+        }
+        catch (error) {
+            console.error(`Failed to fetch balance for address ${address}:`, error);
+            throw new Error('Failed to fetch balance.');
+        }
+    }
+    setTransaction(transaction, storageKey) {
+        const serializedTransaction = JSON.stringify(transaction, (_, value) => typeof value === 'bigint' ? value.toString() : value);
+        window.localStorage.setItem(storageKey, serializedTransaction);
+    }
+    getTransaction(storageKey, options) {
+        const txSerialized = window.localStorage.getItem(storageKey);
+        if (options?.remove) {
+            window.localStorage.removeItem(storageKey);
+        }
+        return txSerialized ? JSON.parse(txSerialized) : undefined;
+    }
+    async getMPCPayloadAndTransaction(transactionRequest) {
+        const transaction = await this.attachGasAndNonce(transactionRequest);
+        const txSerialized = ethers.Transaction.from(transaction).unsignedSerialized;
+        const transactionHash = keccak256(txSerialized);
+        const txHash = Array.from(ethers.getBytes(transactionHash));
+        return {
+            transaction,
+            mpcPayloads: [
+                {
+                    index: 0,
+                    payload: txHash,
+                },
+            ],
+        };
+    }
+    addSignature({ transaction, mpcSignatures, }) {
+        return ethers.Transaction.from({
+            ...transaction,
+            signature: this.parseSignature(mpcSignatures[0]),
+        }).serialized;
+    }
+    async broadcastTx(txSerialized) {
+        try {
+            const txResponse = await this.provider.broadcastTransaction(txSerialized);
+            return txResponse.hash;
+        }
+        catch (error) {
+            console.error('Transaction broadcast failed:', error);
+            throw new Error('Failed to broadcast transaction.');
+        }
+    }
+}

package/src/chains/EVM/types.d.ts

@@ -0,0 +1,5 @@
+import type * as ethers from 'ethers';
+export type EVMUnsignedTransaction = ethers.TransactionLike;
+export type EVMTransactionRequest = Omit<ethers.TransactionLike, 'from'> & {
+    from: string;
+};

package/src/chains/EVM/types.js

@@ -0,0 +1 @@
+export {};

package/src/chains/EVM/utils.d.ts

@@ -0,0 +1,7 @@
+import { ethers } from 'ethers';
+export declare function fetchEVMFeeProperties(providerUrl: string, transaction: ethers.TransactionLike): Promise<{
+    gasLimit: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    maxFee: bigint;
+}>;

package/src/chains/EVM/utils.js

@@ -0,0 +1,14 @@
+import { ethers } from 'ethers';
+export async function fetchEVMFeeProperties(providerUrl, transaction) {
+    const provider = new ethers.JsonRpcProvider(providerUrl);
+    const gasLimit = await provider.estimateGas(transaction);
+    const feeData = await provider.getFeeData();
+    const maxFeePerGas = feeData.maxFeePerGas ?? ethers.parseUnits('10', 'gwei');
+    const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? ethers.parseUnits('10', 'gwei');
+    return {
+        gasLimit,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        maxFee: maxFeePerGas * gasLimit,
+    };
+}

package/src/chains/index.d.ts

@@ -0,0 +1,12 @@
+export { Chain } from './Chain';
+export { ChainSignatureContract, type SignArgs } from './ChainSignatureContract';
+export * from './types';
+export * as utils from './utils';
+export { EVM } from './EVM/EVM';
+export { fetchEVMFeeProperties } from './EVM/utils';
+export type { EVMTransactionRequest, EVMUnsignedTransaction } from './EVM/types';
+export { Bitcoin } from './Bitcoin/Bitcoin';
+export { BTCRpcAdapters, BTCRpcAdapter } from './Bitcoin/BTCRpcAdapter';
+export type { BTCTransactionRequest, BTCUnsignedTransaction, BTCTransaction, BTCOutput, BTCInput, BTCNetworkIds, } from './Bitcoin/types';
+export { Cosmos } from './Cosmos/Cosmos';
+export type { CosmosNetworkIds, CosmosTransactionRequest, CosmosUnsignedTransaction, } from './Cosmos/types';

package/src/chains/index.js

@@ -0,0 +1,12 @@
+export { Chain } from './Chain';
+export { ChainSignatureContract } from './ChainSignatureContract';
+export * from './types';
+export * as utils from './utils';
+// EVM
+export { EVM } from './EVM/EVM';
+export { fetchEVMFeeProperties } from './EVM/utils';
+// Bitcoin
+export { Bitcoin } from './Bitcoin/Bitcoin';
+export { BTCRpcAdapters, BTCRpcAdapter } from './Bitcoin/BTCRpcAdapter';
+// Cosmos
+export { Cosmos } from './Cosmos/Cosmos';