315 lines
11 KiB
Plaintext
315 lines
11 KiB
Plaintext
_section: API Providers @<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 @<EtherscanProvider> @inherit<[[BaseProvider]]> @src<providers:class.EtherscanProvider>
|
|
|
|
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)
|
|
- ``ropsten`` - Ropsten (proof-of-work testnet)
|
|
- ``rinkeby`` - Rinkeby (proof-of-authority testnet)
|
|
- ``goerli`` - Görli (clique testnet)
|
|
- ``kovan`` - Kovan (proof-of-authority testnet)
|
|
|
|
_code: Etherscan Examples @lang<javascript>
|
|
|
|
//_hide: const EtherscanProvider = ethers.providers.EtherscanProvider;
|
|
//_hide: const apiKey = "...";
|
|
|
|
// Connect to mainnet (homestead)
|
|
provider = new EtherscanProvider();
|
|
|
|
// Connect to rinkeby testnet (these are equivalent)
|
|
provider = new EtherscanProvider("rinkeby");
|
|
provider = new EtherscanProvider(4);
|
|
|
|
network = ethers.providers.getNetwork("rinkeby");
|
|
//_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<History> @src<providers>
|
|
@TODO... Explain
|
|
|
|
|
|
_subsection: InfuraProvider @<InfuraProvider> @INHERIT<[[UrlJsonRpcProvider]]> @src<providers:class.InfuraProvider>
|
|
|
|
The **InfuraProvider** is backed by the popular [INFURA](link-infura)
|
|
Ethereum service.
|
|
|
|
_property: new ethers.providers.InfuraProvider([ network = "homestead", [ apiKey ] ]) @SRC<providers>
|
|
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]] @<InfuraProvider-getWebSocketProvider> @SRC<providers:InfuraProvider.getWebSocketProvider>
|
|
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)
|
|
- ``ropsten`` - Ropsten (proof-of-work testnet)
|
|
- ``rinkeby`` - Rinkeby (proof-of-authority testnet)
|
|
- ``goerli`` - Görli (clique testnet)
|
|
- ``kovan`` - Kovan (proof-of-authority testnet)
|
|
- ``matic`` - Polygon
|
|
- ``maticmum`` - Polygon Mumbai Testnet
|
|
- ``optimism`` - Optimism (L2; optimistic roll-up)
|
|
- ``optimism-kovan`` - Optimism Testnet (L2; optimistic roll-up testnet)
|
|
- ``arbitrum`` - Arbitrum (L2; optimistic roll-up)
|
|
- ``arbitrum-rinkeby`` - Arbitrum Testnet (L2; optimistic roll-up testnet)
|
|
|
|
_code: INFURA Examples @lang<javascript>
|
|
|
|
//_hide: const InfuraProvider = ethers.providers.InfuraProvider;
|
|
//_hide: const projectId = "...";
|
|
//_hide: const projectSecret = "...";
|
|
|
|
// Connect to mainnet (homestead)
|
|
provider = new InfuraProvider();
|
|
|
|
// Connect to the ropsten testnet
|
|
// (see EtherscanProvider above for other network examples)
|
|
provider = new InfuraProvider("ropsten");
|
|
|
|
// 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 @<AlchemyProvider> @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.AlchemyProvider>
|
|
|
|
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)
|
|
- ``ropsten`` - Ropsten (proof-of-work testnet)
|
|
- ``rinkeby`` - Rinkeby (proof-of-authority testnet)
|
|
- ``goerli`` - Görli (clique testnet)
|
|
- ``kovan`` - Kovan (proof-of-authority testnet)
|
|
- ``matic`` - Polygon
|
|
- ``maticmum`` - Polygon Mumbai Testnet
|
|
- ``optimism`` - Optimism (L2; optimistic roll-up)
|
|
- ``optimism-kovan`` - Optimism Testnet (L2; optimistic roll-up testnet)
|
|
- ``arbitrum`` - Arbitrum (L2; optimistic roll-up)
|
|
- ``arbitrum-rinkeby`` - Arbitrum Testnet (L2; optimistic roll-up testnet)
|
|
|
|
_code: Alchemy Examples @lang<javascript>
|
|
|
|
//_hide: const AlchemyProvider = ethers.providers.AlchemyProvider;
|
|
//_hide: const apiKey = "...";
|
|
|
|
// Connect to mainnet (homestead)
|
|
provider = new AlchemyProvider();
|
|
|
|
// Connect to the ropsten testnet
|
|
// (see EtherscanProvider above for other network examples)
|
|
provider = new AlchemyProvider("ropsten");
|
|
|
|
// 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 @<CloudflareProvider> @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.CloudflareProvider>
|
|
|
|
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<javascript>
|
|
|
|
//_hide: const CloudflareProvider = ethers.providers.CloudflareProvider;
|
|
|
|
// Connect to mainnet (homestead)
|
|
provider = new CloudflareProvider();
|
|
|
|
|
|
_subsection: PocketProvider @<PocketProvider> @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.PocketProvider>
|
|
|
|
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)
|
|
- ``ropsten`` - Ropsten (proof-of-work testnet)
|
|
- ``rinkeby`` - Rinkeby (proof-of-authority testnet)
|
|
- ``goerli`` - Görli (clique testnet)
|
|
|
|
_code: Pocket Examples @lang<javascript>
|
|
|
|
//_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 ropsten testnet
|
|
// (see EtherscanProvider above for other network examples)
|
|
provider = new PocketProvider("ropsten");
|
|
|
|
// 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 @<AnkrProvider> @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.AnkrProvider>
|
|
|
|
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<javascript>
|
|
|
|
//_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);
|