Controlling the Logic Behind EthersJS FallbackProvider: Ensuring Consistency Across Multiple RPCs
When using EthersJS to handle multiple RPCs, one of the main concerns is ensuring consistency across different providers. The FallbackProvider is a crucial component in this regard, but its flexibility can sometimes lead to inconsistencies if not properly configured. In this article, we will explore how to control the logic behind ethersJs FallbackProvider and troubleshoot common issues that may arise.
Why is Consistency Important?
In the context of EthersJS, consistency across multiple RPCs is crucial to maintain a single, unified view of the blockchain state. If one provider has a different quorum (the minimum number of signatures required to validate transactions) than another, it can lead to inconsistencies in the final state of the network.
Default Fallback Provider Quorum
The FallbackProvider defaults to 4 of the 6 available blockchains (or chains, if you prefer) to make a decision. This means that if one provider goes down or is unresponsive for an extended period of time, it can fall back to the other providers to make a decision.
Issue: Event when setting a quorum
A common issue with FallbackProvider is that setting a custom quorum can lead to inconsistent decisions across multiple RPCs. When you set a quorum, EthersJS will use the default blockchain(s) in case another provider relies on them. This means that if one provider has a higher quorum than the others, it can be chosen as a fallback, even if it is not the right choice for your specific use case.
Solution: Customizing the FallbackProvider
To control the logic behind ethersJs FallbackProvider and ensure consistency across multiple RPCs, you can customize its behavior. Here are some strategies to achieve this:
- Override the default quorum: You can override the default 4 quorum rule by setting a custom quorum for each provider. For example:
const fallbackProvider = new ethers.providers.FallbackProvider({
providers: [ethers.providers.JsonRpcProvider(' // Provider A
ethers.providers.JsonRpcProvider(' // Provider B
},
Gas Limit: 1,000,000,
maxPriorityFeePerGas: 1.5, // adjust gas limit for each provider
});
In this example, Vendor A has a custom quorum of 4, while Vendor B falls back to the default quorum of 6.
- Use a quorum-based fallback strategy
: You can use a quorum-based approach where you select the vendor with the highest quorum when making a decision. For example:
const fallbackProvider = new ethers.providers.FallbackProvider({
providers: [
{
name: "Provider A",
address: '
gas limit: 1,000,000,
maxPriorityFeePerGas: 1.5,
},
{
name: "Provider B",
address: '
gas limit: 1,000,000,
maxPriorityFeePerGas: 1.5,
},
],
fallback: (event, provider) => {
if (provider.quorum > 4) {
// Provider A is chosen as a fallback
return "Provider A";
} else {
// Provider B is chosen as a fallback
return "Provider B";
}
},
});
In this example, Provider A has a quorum of 4, so it is chosen as a fallback when making a decision.
- Use a consensus algorithm: You can use a consensus algorithm such as Proof of Stake (PoS) or Delegated Proof of Stake (DPoS) to ensure that multiple providers agree on a quorum. For example:
“`javascript
const fallbackProvider = new ethers.providers.FallbackProvider({
providers: [
{
name: ‘Provider A’,
address: ‘
gas limit: 1,000,000,
maxPriorityFeePerGas: 1.
