Providers and Network Connection

/**
 * Standard JSON-RPC provider for HTTP connections to Ethereum nodes
 */
class JsonRpcProvider extends AbstractProvider {
  constructor(url?: string, network?: Networkish, options?: JsonRpcApiProviderOptions);
}

interface JsonRpcApiProviderOptions {
  polling?: boolean;
  staticNetwork?: Network;
  batchStallTime?: number;
  batchMaxSize?: number;
  batchMaxCount?: number;
  cacheTimeout?: number;
}

import { JsonRpcProvider } from "ethers";

// Connect to Infura
const provider = new JsonRpcProvider("https://mainnet.infura.io/v3/YOUR-PROJECT-ID");

// Connect to local node
const localProvider = new JsonRpcProvider("http://localhost:8545");

// Get network information
const network = await provider.getNetwork();
console.log(network.name, network.chainId);

/**
 * WebSocket provider for real-time blockchain events and faster updates
 */
class WebSocketProvider extends SocketProvider {
  constructor(url: string | WebSocketLike, network?: Networkish);
}

interface WebSocketLike {
  send(data: string): void;
  close(): void;
  addEventListener(event: string, listener: any): void;
  removeEventListener(event: string, listener: any): void;
}

import { WebSocketProvider } from "ethers";

const wsProvider = new WebSocketProvider("wss://mainnet.infura.io/ws/v3/YOUR-PROJECT-ID");

// Listen for new blocks
wsProvider.on("block", (blockNumber) => {
  console.log("New block:", blockNumber);
});

/**
 * Browser provider wrapper for injected providers like MetaMask
 */
class BrowserProvider extends JsonRpcApiProvider {
  constructor(ethereum: Eip1193Provider, network?: Networkish);
  
  getSigner(address?: string): Promise<JsonRpcSigner>;
  listAccounts(): Promise<JsonRpcSigner[]>;
  send(method: string, params: Array<any>): Promise<any>;
}

interface Eip1193Provider extends EventEmitter {
  request(args: { method: string; params?: Array<any> }): Promise<any>;
  isConnected?(): boolean;
}

import { BrowserProvider } from "ethers";

// Connect to MetaMask
const provider = new BrowserProvider(window.ethereum);

// Get connected accounts
const signer = await provider.getSigner();
const address = await signer.getAddress();

/**
 * Fallback provider with multiple backends for improved reliability
 */
class FallbackProvider extends AbstractProvider {
  constructor(providers: Array<FallbackProviderConfig>, network?: Networkish, options?: FallbackProviderOptions);
}

interface FallbackProviderConfig {
  provider: Provider;
  priority?: number;
  stallTimeout?: number;
  weight?: number;
}

interface FallbackProviderOptions {
  quorum?: number;
  eventQuorum?: number;
  eventWorkers?: number;
  cacheTimeout?: number;
}

/**
 * Creates a default provider with multiple backends for maximum reliability
 * @param network - Network to connect to (default: "homestead")
 * @param options - Configuration options for individual providers
 * @returns Configured FallbackProvider instance
 */
function getDefaultProvider(network?: Networkish, options?: any): Provider;

import { getDefaultProvider } from "ethers";

// Get default provider for mainnet
const provider = getDefaultProvider();

// Get provider for specific network
const goerliProvider = getDefaultProvider("goerli", {
  infura: "YOUR-PROJECT-ID",
  alchemy: "YOUR-API-KEY"
});

/**
 * Base provider interface with core blockchain interaction methods
 */
interface Provider {
  // Network information
  getNetwork(): Promise<Network>;
  
  // Block queries
  getBlockNumber(): Promise<number>;
  getBlock(blockHashOrBlockTag: BlockTag): Promise<null | Block>;
  
  // Account queries
  getBalance(address: string, blockTag?: BlockTag): Promise<bigint>;
  getCode(address: string, blockTag?: BlockTag): Promise<string>;
  getStorage(address: string, position: BigNumberish, blockTag?: BlockTag): Promise<string>;
  getTransactionCount(address: string, blockTag?: BlockTag): Promise<number>;
  
  // Transaction operations
  call(transaction: TransactionRequest, blockTag?: BlockTag): Promise<string>;
  estimateGas(transaction: TransactionRequest): Promise<bigint>;
  sendTransaction(signedTransaction: string): Promise<TransactionResponse>;
  
  // Transaction and receipt queries
  getTransaction(hash: string): Promise<null | TransactionResponse>;
  getTransactionReceipt(hash: string): Promise<null | TransactionReceipt>;
  
  // Event logs
  getLogs(filter: Filter): Promise<Array<Log>>;
  
  // Gas fees
  getFeeData(): Promise<FeeData>;
  
  // ENS resolution
  resolveName(name: string): Promise<null | string>;
  lookupAddress(address: string): Promise<null | string>;
}

type BlockTag = number | string | "latest" | "earliest" | "pending" | "safe" | "finalized";

interface Network {
  name: string;
  chainId: bigint;
  ensAddress?: string;
}

interface Block {
  hash: string;
  number: number;
  timestamp: number;
  parentHash: string;
  gasLimit: bigint;
  gasUsed: bigint;
  miner: string;
  difficulty: bigint;
  transactions: Array<string>;
}

interface FeeData {
  gasPrice?: bigint;
  maxFeePerGas?: bigint;
  maxPriorityFeePerGas?: bigint;
}

/**
 * Event subscription methods for real-time blockchain monitoring
 */
interface EventProvider {
  on(event: ProviderEvent, listener: Listener): Provider;
  off(event: ProviderEvent, listener?: Listener): Provider;
  once(event: ProviderEvent, listener: Listener): Provider;
  removeAllListeners(event?: ProviderEvent): Provider;
}

type ProviderEvent = "block" | "pending" | "error" | "network" | Filter | string;
type Listener = (...args: Array<any>) => void;

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("YOUR-RPC-URL");

// Listen for new blocks
provider.on("block", (blockNumber) => {
  console.log("New block:", blockNumber);
});

// Listen for pending transactions
provider.on("pending", (txHash) => {
  console.log("Pending transaction:", txHash);
});

// Listen for contract events
const filter = {
  address: "0x...",
  topics: ["0x..."] // Event signature hash
};

provider.on(filter, (log) => {
  console.log("Contract event:", log);
});

/**
 * Network configuration for custom or non-standard networks
 */
class Network {
  constructor(name: string, chainId: BigNumberish);
  
  readonly name: string;
  readonly chainId: bigint;
  readonly ensAddress?: string;
  
  static from(network: Networkish): Network;
}

type Networkish = Network | string | bigint | number | {
  name?: string;
  chainId?: BigNumberish;
  ensAddress?: string;
};

import { Network, JsonRpcProvider } from "ethers";

// Create custom network
const customNetwork = new Network("my-network", 1337);

// Use with provider
const provider = new JsonRpcProvider("http://localhost:8545", customNetwork);

/**
 * Infura provider supporting mainnet, testnets, and Layer 2 networks
 */
class InfuraProvider extends JsonRpcProvider implements CommunityResourcable {
  constructor(network?: Networkish, projectId?: string | null, projectSecret?: string | null);
  
  readonly projectId: string;
  readonly projectSecret: string | null;
  
  static getWebSocketProvider(network?: Networkish, projectId?: string): InfuraWebSocketProvider;
  static getRequest(network: Network, projectId?: string | null, projectSecret?: string | null): FetchRequest;
  
  isCommunityResource(): boolean;
}

/**
 * Infura WebSocket provider for real-time blockchain events
 */
class InfuraWebSocketProvider extends WebSocketProvider implements CommunityResourcable {
  constructor(network?: Networkish, projectId?: string);
  
  readonly projectId: string;
  readonly projectSecret: string | null;
  
  isCommunityResource(): boolean;
}

import { InfuraProvider, InfuraWebSocketProvider } from "ethers";

// HTTP provider
const provider = new InfuraProvider("mainnet", "YOUR-PROJECT-ID");

// With project secret for authenticated requests
const authProvider = new InfuraProvider("mainnet", "YOUR-PROJECT-ID", "YOUR-PROJECT-SECRET");

// WebSocket provider for real-time events
const wsProvider = new InfuraWebSocketProvider("mainnet", "YOUR-PROJECT-ID");

// Layer 2 networks
const arbitrumProvider = new InfuraProvider("arbitrum", "YOUR-PROJECT-ID");
const polygonProvider = new InfuraProvider("matic", "YOUR-PROJECT-ID");

/**
 * Alchemy provider with enhanced blockchain data access and tracing support
 */
class AlchemyProvider extends JsonRpcProvider implements CommunityResourcable {
  constructor(network?: Networkish, apiKey?: string | null);
  
  readonly apiKey: string;
  
  static getRequest(network: Network, apiKey?: string): FetchRequest;
  
  isCommunityResource(): boolean;
}

import { AlchemyProvider } from "ethers";

// Basic connection
const provider = new AlchemyProvider("mainnet", "YOUR-API-KEY");

// Layer 2 networks
const arbitrumProvider = new AlchemyProvider("arbitrum", "YOUR-API-KEY");
const optimismProvider = new AlchemyProvider("optimism", "YOUR-API-KEY");

// Enhanced trace capabilities
const txResult = await provider.send("trace_transaction", [txHash]);

/**
 * Etherscan provider using Etherscan's REST API instead of JSON-RPC
 */
class EtherscanProvider extends AbstractProvider implements CommunityResourcable {
  constructor(network?: Networkish, apiKey?: string | null);
  
  readonly apiKey: string | null;
  
  static getRequest(network: Network, apiKey?: string | null): FetchRequest;
  
  isCommunityResource(): boolean;
}

/**
 * Etherscan network plugin for ENS resolution via Etherscan API
 */
class EtherscanPlugin extends NetworkPlugin {
  constructor(apiKey?: string | null);
  
  readonly baseUrl: string;
  readonly apiKey: string | null;
}

import { EtherscanProvider, EtherscanPlugin } from "ethers";

// Basic Etherscan provider
const provider = new EtherscanProvider("mainnet", "YOUR-API-KEY");

// Using as network plugin
const network = new Network("mainnet", 1);
network.attachPlugin(new EtherscanPlugin("YOUR-API-KEY"));

/**
 * QuickNode provider for high-performance blockchain access
 */
class QuickNodeProvider extends JsonRpcProvider implements CommunityResourcable {
  constructor(network?: Networkish, token?: string | null);
  readonly token: string | null;
}

/**
 * Ankr provider for decentralized RPC access
 */
class AnkrProvider extends JsonRpcProvider implements CommunityResourcable {
  constructor(network?: Networkish, apiKey?: string | null);
  readonly apiKey: string | null;
}

/**
 * Cloudflare provider using Cloudflare's Ethereum gateway
 */
class CloudflareProvider extends JsonRpcProvider {
  constructor(network?: Networkish);
}

/**
 * Blockscout provider for Blockscout-compatible networks
 */
class BlockscoutProvider extends JsonRpcProvider {
  constructor(network?: Networkish, baseUrl?: string);
  readonly baseUrl: string;
}

/**
 * Chainstack provider for Chainstack's managed blockchain infrastructure
 */
class ChainstackProvider extends JsonRpcProvider implements CommunityResourcable {
  constructor(network?: Networkish, apiKey?: string | null);
  readonly apiKey: string | null;
}

/**
 * Pocket provider for Pocket Network's decentralized infrastructure
 */
class PocketProvider extends JsonRpcProvider implements CommunityResourcable {
  constructor(network?: Networkish, apiKey?: string | null, applicationId?: string | null);
  readonly apiKey: string | null;
  readonly applicationId: string | null;
}

import { 
  QuickNodeProvider, 
  AnkrProvider, 
  CloudflareProvider, 
  BlockscoutProvider,
  ChainstackProvider,
  PocketProvider 
} from "ethers";

// QuickNode
const quicknode = new QuickNodeProvider("mainnet", "YOUR-TOKEN");

// Ankr
const ankr = new AnkrProvider("mainnet", "YOUR-API-KEY");

// Cloudflare (no API key required)
const cloudflare = new CloudflareProvider("mainnet");

// Chainstack
const chainstack = new ChainstackProvider("mainnet", "YOUR-API-KEY");

// Pocket Network
const pocket = new PocketProvider("mainnet", "YOUR-API-KEY", "YOUR-APP-ID");