Ethereum: How to control the logic behind EthersJs fallbackProvider choices

EthersJS FallbackProvider Control Logic: Ensuring Consistency Across Multiple RPCs

When using EthersJS to handle multiple RPCs, one of the main challenges is ensuring consistency across different providers. FallbackProvider is a crucial component in this regard, but its flexibility can sometimes lead to inconsistencies if not configured correctly. In this article, we will explore how to control ethersJs FallbackProvider logic and resolve common issues that may arise.

Why is consistency important?

In the context of EthersJS, consistency across multiple RPCs is critical to maintaining a single, unified view of the state of the blockchain. If one provider has a different quorum (the minimum number of signatures required to validate transactions) than another, this can lead to inconsistencies in the final state of the network.

Default quorum for fallback provider

By default, FallbackProvider uses 4 of the 6 available blockchains (or chains, if you prefer) to make a decision. This means that if one provider fails or is unresponsive for an extended period, the decision may be left to other providers.

Problem: Event during quorum determination

A common problem with FallbackProvider is that setting a custom quorum can cause inconsistent decisions across multiple RPCs. When setting quorum, EthersJS will use the default blockchain if it is used by another provider. This means that if one provider has a higher quorum than others, it can be chosen as the fallback option, even if it is not the right choice for your specific use case.

Solution: Customizing FallbackProvider

To control the logic of ethersJs FallbackProvider and ensure consistency across multiple RPCs, you can customize its behavior. Here are some strategies to achieve this:

• Override default quorum: You can override the default quorum rule of 4 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: 1000000,

  maxPriorityFeePerGas: 1.5, // adjust the gas limit for each supplier

});

In this example, Provider A has a custom quorum of 4, while Provider 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 provider with the highest quorum when making a decision. For example:

const fallbackProvider = new ethers.providers.FallbackProvider({
service providers: [
{
name: “Service Provider A”,
address: 
gas limit: 1000000,
maxPriorityFeePerGas: 1.5,
},
{
name: “Service Provider B”,
address: 
gas limit: 1000000,
maxPriorityFeePerGas: 1.5,
},
],
fallback: (event, provider) => {
if (provider.quorum > 4) {
// Provider A is selected as fallback
return "Service Provider A";
} else {
// Provider B is selected as a fallback
return “Service Provider B”;
}
},
});

In this example, Provider A has a quorum of 4, so it is chosen as an alternative 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({

service providers: [

{

name: “Service Provider A”,

address:

gas limit: 1000000,

maxPriorityFeePerGas: 1.

KUSAMA MARKET