_section: API Providers @ There are many services which offer a web API for accessing the Ethereum Blockchain. These Providers allow connecting to them, which simplifies development, since you do not need to run your own instance or cluster of Ethereum nodes. However, this reliance on third-party services can reduce resilience, security and increase the amount of required trust. To mitigate these issues, it is recommended you use a [Default Provider](providers-getDefaultProvider). _subsection: EtherscanProvider @ @inherit<[[BaseProvider]]> @src The **EtherscanProvider** is backed by a combination of the various [Etherscan APIs](link-etherscan-api). _property: new ethers.providers.EtherscanProvider([ network = "homestead", [ apiKey ] ]) Create a new **EtherscanProvider** connected to //network// with the optional //apiKey//. The //network// may be specified as a **string** for a common network name, a **number** for a common chain ID or a [Network Object]provider-(network). If no //apiKey// is provided, a shared API key will be used, which may result in reduced performance and throttled requests. It is highly recommended for production, you register with [Etherscan](link-etherscan) for your own API key. _note: Note: Default API keys If no //apiKey// is provided, a shared API key will be used, which may result in reduced performance and throttled requests. It is highly recommended for production, you register with [Etherscan](link-etherscan) for your own API key. _definition: **Supported Networks** - ``homestead`` - Homestead (Mainnet) - ``goerli`` - Görli (clique testnet) - ``sepolia`` - Sepolia (proof-of-authority testnet) - ``arbitrum`` - Arbitrum Optimistic L2 - ``arbitrum-goerli`` - Arbitrum Optimistic L2 testnet - ``matic`` - Polgon mainnet - ``maticmum`` - Polgon testnet - ``optimism`` - Optimism Optimistic L2 - ``optimism-goerli`` - Optimism Optimistic L2 testnet _code: Etherscan Examples @lang //_hide: const EtherscanProvider = ethers.providers.EtherscanProvider; //_hide: const apiKey = "..."; // Connect to mainnet (homestead) provider = new EtherscanProvider(); // Connect to goerli testnet (these are equivalent) provider = new EtherscanProvider("goerli"); provider = new EtherscanProvider(5); network = ethers.providers.getNetwork("goerli"); //_hide: delete network._defaultProvider; //_log: network provider = new EtherscanProvider(network); // Connect to mainnet (homestead) with an API key provider = new EtherscanProvider(null, apiKey); provider = new EtherscanProvider("homestead", apiKey); _property: provider.getHistory(address) => Array @src @TODO... Explain _subsection: InfuraProvider @ @INHERIT<[[UrlJsonRpcProvider]]> @src The **InfuraProvider** is backed by the popular [INFURA](link-infura) Ethereum service. _property: new ethers.providers.InfuraProvider([ network = "homestead", [ apiKey ] ]) @SRC Create a new **InfuraProvider** connected to //network// with the optional //apiKey//. The //network// may be specified as a **string** for a common network name, a **number** for a common chain ID or a [Network Object]provider-(network). The //apiKey// can be a **string** Project ID or an **object** with the properties ``projectId`` and ``projectSecret`` to specify a [Project Secret](link-infura-secret) which can be used on non-public sources (like on a server) to further secure your API access and quotas. _property: InfuraProvider.getWebSocketProvider([ network [ , apiKey ] ]) => [[WebSocketProvider]] @ @SRC Create a new [[WebSocketProvider]] using the INFURA web-socket endpoint to connect to //network// with the optional //apiKey//. The //network// and //apiKey// are specified the same as [the constructor](InfuraProvider). _note: Note: Default API keys If no //apiKey// is provided, a shared API key will be used, which may result in reduced performance and throttled requests. It is highly recommended for production, you register with [INFURA](link-infura) for your own API key. _definition: **Supported Networks** - ``homestead`` - Homestead (Mainnet) - ``goerli`` - Görli (clique testnet) - ``sepolia`` - Sepolia (proof-of-authority testnet) - ``arbitrum`` - Arbitrum Optimistic L2 - ``arbitrum-goerli`` - Arbitrum Optimistic L2 testnet - ``matic`` - Polgon mainnet - ``maticmum`` - Polgon testnet - ``optimism`` - Optimism Optimistic L2 - ``optimism-goerli`` - Optimism Optimistic L2 testnet _code: INFURA Examples @lang //_hide: const InfuraProvider = ethers.providers.InfuraProvider; //_hide: const projectId = "..."; //_hide: const projectSecret = "..."; // Connect to mainnet (homestead) provider = new InfuraProvider(); // Connect to the goerli testnet // (see EtherscanProvider above for other network examples) provider = new InfuraProvider("goerli"); // Connect to mainnet with a Project ID (these are equivalent) provider = new InfuraProvider(null, projectId); provider = new InfuraProvider("homestead", projectId); // Connect to mainnet with a Project ID and Project Secret provider = new InfuraProvider("homestead", { projectId: projectId, projectSecret: projectSecret }); // Connect to the INFURA WebSocket endpoints with a WebSocketProvider provider = InfuraProvider.getWebSocketProvider() //_hide: await provider.destroy(); _subsection: AlchemyProvider @ @inherit<[[UrlJsonRpcProvider]]> @src The **AlchemyProvider** is backed by [Alchemy](link-alchemy). _property: new ethers.providers.AlchemyProvider([ network = "homestead", [ apiKey ] ]) Create a new **AlchemyProvider** connected to //network// with the optional //apiKey//. The //network// may be specified as a **string** for a common network name, a **number** for a common chain ID or a [Network Object](providers-Network). _note: Note: Default API keys If no //apiKey// is provided, a shared API key will be used, which may result in reduced performance and throttled requests. It is highly recommended for production, you register with [Alchemy](link-alchemy) for your own API key. _definition: **Supported Networks** - ``homestead`` - Homestead (Mainnet) - ``goerli`` - Görli (clique testnet) - ``arbitrum`` - Arbitrum Optimistic L2 - ``arbitrum-goerli`` - Arbitrum Optimistic L2 testnet - ``matic`` - Polgon mainnet - ``maticmum`` - Polgon testnet - ``optimism`` - Optimism Optimistic L2 - ``optimism-goerli`` - Optimism Optimistic L2 testnet _code: Alchemy Examples @lang //_hide: const AlchemyProvider = ethers.providers.AlchemyProvider; //_hide: const apiKey = "..."; // Connect to mainnet (homestead) provider = new AlchemyProvider(); // Connect to the goerli testnet // (see EtherscanProvider above for other network examples) provider = new AlchemyProvider("goerli"); // Connect to mainnet with an API key (these are equivalent) provider = new AlchemyProvider(null, apiKey); provider = new AlchemyProvider("homestead", apiKey); // Connect to the Alchemy WebSocket endpoints with a WebSocketProvider provider = AlchemyProvider.getWebSocketProvider() //_hide: provider.destroy(); _subsection: CloudflareProvider @ @inherit<[[UrlJsonRpcProvider]]> @src The CloudflareProvider is backed by the [Cloudflare Ethereum Gateway](link-cloudflare). _property: new ethers.providers.CloudflareProvider() Create a new **CloudflareProvider** connected to mainnet (i.e. "homestead"). _definition: **Supported Networks** - ``homestead`` - Homestead (Mainnet) _code: Cloudflare Examples @lang //_hide: const CloudflareProvider = ethers.providers.CloudflareProvider; // Connect to mainnet (homestead) provider = new CloudflareProvider(); _subsection: PocketProvider @ @inherit<[[UrlJsonRpcProvider]]> @src The **PocketProvider** is backed by [Pocket](link-pocket). _property: new ethers.providers.PocketProvider([ network = "homestead", [ apiKey ] ]) Create a new **PocketProvider** connected to //network// with the optional //apiKey//. The //network// may be specified as a **string** for a common network name, a **number** for a common chain ID or a [Network Object](providers-Network). _note: Note: Default API keys If no //apiKey// is provided, a shared API key will be used, which may result in reduced performance and throttled requests. It is highly recommended for production, you register with [Pocket](link-pocket) for your own API key. _definition: **Supported Networks** - ``homestead`` - Homestead (Mainnet) - ``goerli`` - Görli (clique testnet) - ``matic`` - Polgon mainnet - ``maticmum`` - Polgon testnet _code: Pocket Examples @lang //_hide: const PocketProvider = ethers.providers.PocketProvider; //_hide: const applicationId = "..."; //_hide: const applicationSecretKey = "..."; //_hide: const loadBalancer = true; // Connect to mainnet (homestead) provider = new PocketProvider(); // Connect to the goerli testnet // (see EtherscanProvider above for other network examples) provider = new PocketProvider("goerli"); // Connect to mainnet with an Application ID (these are equivalent) provider = new PocketProvider(null, applicationId); provider = new PocketProvider("homestead", applicationId); // Connect to mainnet with an application ID, application secret // and specify whether to use the load balances provider = new PocketProvider("homestead", { applicationId: applicationId, applicationSecretKey: applicationSecretKey, loadBalancer: loadBalancer // true or false }); _subsection: AnkrProvider @ @inherit<[[UrlJsonRpcProvider]]> @src The **AnkrProvider** is backed by [Ankr](link-ankr). _property: new ethers.providers.AnkrProvider([ network = "homestead", [ apiKey ] ]) Create a new **AnkrProvider** connected to //network// with the optional //apiKey//. The //network// may be specified as a **string** for a common network name, a **number** for a common chain ID or a [Network Object](providers-Network). _note: Note: Default API keys If no //apiKey// is provided, a shared API key will be used, which may result in reduced performance and throttled requests. It is highly recommended for production, you register with [Ankr](link-ankr) for your own API key. _definition: **Supported Networks** - ``homestead`` - Homestead (Mainnet) - ``matic`` - Polygon - ``arbitrum`` - Arbitrum (L2; optimistic roll-up) _code: Ankr Examples @lang //_hide: const AnkrProvider = ethers.providers.AnkrProvider; //_hide: const apiKey = "..."; // Connect to mainnet (homestead) provider = new AnkrProvider(); // Connect to polygont // (see EtherscanProvider above for other network examples) provider = new AnkrProvider("matic"); // Connect to mainnet with an API Key (these are equivalent) provider = new AnkrProvider(null, apiKey); provider = new AnkrProvider("homestead", apiKey);