ethers.js/lib.esm/providers/network.js

274 lines
9.7 KiB
JavaScript
Raw Normal View History

2022-11-30 23:44:23 +03:00
/**
* About networks
*
* @_subsection: api/providers:Networks [networks]
*/
2022-09-27 10:45:27 +03:00
import { accessListify } from "../transaction/index.js";
2022-11-30 23:44:23 +03:00
import { getBigInt, assertArgument } from "../utils/index.js";
2022-09-05 23:57:11 +03:00
import { EnsPlugin, GasCostPlugin } from "./plugins-network.js";
/* * * *
// Networks which operation against an L2 can use this plugin to
// specify how to access L1, for the purpose of resolving ENS,
// for example.
export class LayerOneConnectionPlugin extends NetworkPlugin {
readonly provider!: Provider;
// @TODO: Rename to ChainAccess and allow for connecting to any chain
constructor(provider: Provider) {
super("org.ethers.plugins.layer-one-connection");
defineProperties<LayerOneConnectionPlugin>(this, { provider });
}
clone(): LayerOneConnectionPlugin {
return new LayerOneConnectionPlugin(this.provider);
}
}
*/
/* * * *
export class PriceOraclePlugin extends NetworkPlugin {
readonly address!: string;
constructor(address: string) {
super("org.ethers.plugins.price-oracle");
defineProperties<PriceOraclePlugin>(this, { address });
}
clone(): PriceOraclePlugin {
return new PriceOraclePlugin(this.address);
}
}
*/
// Networks or clients with a higher need for security (such as clients
// that may automatically make CCIP requests without user interaction)
// can use this plugin to anonymize requests or intercept CCIP requests
// to notify and/or receive authorization from the user
/* * * *
export type FetchDataFunc = (req: Frozen<FetchRequest>) => Promise<FetchRequest>;
export class CcipPreflightPlugin extends NetworkPlugin {
readonly fetchData!: FetchDataFunc;
constructor(fetchData: FetchDataFunc) {
super("org.ethers.plugins.ccip-preflight");
defineProperties<CcipPreflightPlugin>(this, { fetchData });
}
clone(): CcipPreflightPlugin {
return new CcipPreflightPlugin(this.fetchData);
}
}
*/
const Networks = new Map();
2022-09-27 10:45:27 +03:00
// @TODO: Add a _ethersNetworkObj variable to better detect network ovjects
2022-09-05 23:57:11 +03:00
export class Network {
2022-11-30 23:44:23 +03:00
#name;
#chainId;
#plugins;
constructor(name, chainId) {
this.#name = name;
this.#chainId = getBigInt(chainId);
this.#plugins = new Map();
2022-09-05 23:57:11 +03:00
}
toJSON() {
return { name: this.name, chainId: this.chainId };
}
2022-11-30 23:44:23 +03:00
get name() { return this.#name; }
set name(value) { this.#name = value; }
get chainId() { return this.#chainId; }
set chainId(value) { this.#chainId = getBigInt(value, "chainId"); }
2022-09-05 23:57:11 +03:00
get plugins() {
2022-11-30 23:44:23 +03:00
return Array.from(this.#plugins.values());
2022-09-05 23:57:11 +03:00
}
attachPlugin(plugin) {
2022-11-30 23:44:23 +03:00
if (this.#plugins.get(plugin.name)) {
2022-09-05 23:57:11 +03:00
throw new Error(`cannot replace existing plugin: ${plugin.name} `);
}
2022-11-30 23:44:23 +03:00
this.#plugins.set(plugin.name, plugin.clone());
2022-09-05 23:57:11 +03:00
return this;
}
getPlugin(name) {
2022-11-30 23:44:23 +03:00
return (this.#plugins.get(name)) || null;
2022-09-05 23:57:11 +03:00
}
// Gets a list of Plugins which match basename, ignoring any fragment
getPlugins(basename) {
return (this.plugins.filter((p) => (p.name.split("#")[0] === basename)));
}
clone() {
2022-09-27 10:45:27 +03:00
const clone = new Network(this.name, this.chainId);
2022-09-05 23:57:11 +03:00
this.plugins.forEach((plugin) => {
clone.attachPlugin(plugin.clone());
});
return clone;
}
computeIntrinsicGas(tx) {
2023-02-02 12:05:47 +03:00
const costs = this.getPlugin("org.ethers.plugins.network.GasCost") || (new GasCostPlugin());
2022-09-05 23:57:11 +03:00
let gas = costs.txBase;
if (tx.to == null) {
gas += costs.txCreate;
}
if (tx.data) {
for (let i = 2; i < tx.data.length; i += 2) {
if (tx.data.substring(i, i + 2) === "00") {
gas += costs.txDataZero;
}
else {
gas += costs.txDataNonzero;
}
}
}
if (tx.accessList) {
2022-09-27 10:45:27 +03:00
const accessList = accessListify(tx.accessList);
2022-09-05 23:57:11 +03:00
for (const addr in accessList) {
gas += costs.txAccessListAddress + costs.txAccessListStorageKey * accessList[addr].storageKeys.length;
}
}
return gas;
}
2022-09-16 05:58:45 +03:00
/**
* Returns a new Network for the %%network%% name or chainId.
*/
2022-09-05 23:57:11 +03:00
static from(network) {
2022-10-20 12:03:32 +03:00
injectCommonNetworks();
2022-09-05 23:57:11 +03:00
// Default network
if (network == null) {
2022-09-30 05:57:27 +03:00
return Network.from("mainnet");
2022-09-05 23:57:11 +03:00
}
// Canonical name or chain ID
if (typeof (network) === "number") {
network = BigInt(network);
}
if (typeof (network) === "string" || typeof (network) === "bigint") {
const networkFunc = Networks.get(network);
if (networkFunc) {
return networkFunc();
}
if (typeof (network) === "bigint") {
return new Network("unknown", network);
}
2022-11-09 10:57:02 +03:00
assertArgument(false, "unknown network", "network", network);
2022-09-05 23:57:11 +03:00
}
// Clonable with network-like abilities
if (typeof (network.clone) === "function") {
const clone = network.clone();
//if (typeof(network.name) !== "string" || typeof(network.chainId) !== "number") {
//}
return clone;
}
// Networkish
if (typeof (network) === "object") {
2022-11-09 10:57:02 +03:00
assertArgument(typeof (network.name) === "string" && typeof (network.chainId) === "number", "invalid network object name or chainId", "network", network);
2022-09-05 23:57:11 +03:00
const custom = new Network((network.name), (network.chainId));
if (network.ensAddress || network.ensNetwork != null) {
custom.attachPlugin(new EnsPlugin(network.ensAddress, network.ensNetwork));
}
//if ((<any>network).layerOneConnection) {
// custom.attachPlugin(new LayerOneConnectionPlugin((<any>network).layerOneConnection));
//}
return custom;
}
2022-11-09 10:57:02 +03:00
assertArgument(false, "invalid network", "network", network);
2022-09-05 23:57:11 +03:00
}
2022-09-16 05:58:45 +03:00
/**
* Register %%nameOrChainId%% with a function which returns
* an instance of a Network representing that chain.
*/
2022-09-05 23:57:11 +03:00
static register(nameOrChainId, networkFunc) {
if (typeof (nameOrChainId) === "number") {
nameOrChainId = BigInt(nameOrChainId);
}
const existing = Networks.get(nameOrChainId);
if (existing) {
2022-11-09 10:57:02 +03:00
assertArgument(false, `conflicting network for ${JSON.stringify(existing.name)}`, "nameOrChainId", nameOrChainId);
2022-09-05 23:57:11 +03:00
}
Networks.set(nameOrChainId, networkFunc);
}
}
2022-10-20 12:03:32 +03:00
// See: https://chainlist.org
let injected = false;
function injectCommonNetworks() {
if (injected) {
return;
}
injected = true;
/// Register popular Ethereum networks
function registerEth(name, chainId, options) {
const func = function () {
const network = new Network(name, chainId);
// We use 0 to disable ENS
if (options.ensNetwork != null) {
network.attachPlugin(new EnsPlugin(null, options.ensNetwork));
}
if (options.priorityFee) {
// network.attachPlugin(new MaxPriorityFeePlugin(options.priorityFee));
}
/*
if (options.etherscan) {
const { url, apiKey } = options.etherscan;
network.attachPlugin(new EtherscanPlugin(url, apiKey));
}
*/
network.attachPlugin(new GasCostPlugin());
return network;
};
// Register the network by name and chain ID
Network.register(name, func);
Network.register(chainId, func);
if (options.altNames) {
options.altNames.forEach((name) => {
Network.register(name, func);
});
}
}
registerEth("mainnet", 1, { ensNetwork: 1, altNames: ["homestead"] });
registerEth("ropsten", 3, { ensNetwork: 3 });
registerEth("rinkeby", 4, { ensNetwork: 4 });
registerEth("goerli", 5, { ensNetwork: 5 });
registerEth("kovan", 42, { ensNetwork: 42 });
2023-03-07 10:11:03 +03:00
registerEth("sepolia", 11155111, {});
2022-10-20 12:03:32 +03:00
registerEth("classic", 61, {});
registerEth("classicKotti", 6, {});
registerEth("xdai", 100, { ensNetwork: 1 });
2023-02-23 05:53:56 +03:00
registerEth("optimism", 10, {
ensNetwork: 1,
etherscan: { url: "https:/\/api-optimistic.etherscan.io/" }
});
registerEth("optimism-goerli", 420, {
etherscan: { url: "https:/\/api-goerli-optimistic.etherscan.io/" }
});
registerEth("arbitrum", 42161, {
ensNetwork: 1,
etherscan: { url: "https:/\/api.arbiscan.io/" }
});
registerEth("arbitrum-goerli", 421613, {
etherscan: { url: "https:/\/api-goerli.arbiscan.io/" }
});
2022-10-20 12:03:32 +03:00
// Polygon has a 35 gwei maxPriorityFee requirement
registerEth("matic", 137, {
ensNetwork: 1,
// priorityFee: 35000000000,
etherscan: {
2023-02-23 05:53:56 +03:00
// apiKey: "W6T8DJW654GNTQ34EFEYYP3EZD9DD27CT7",
2022-10-20 12:03:32 +03:00
url: "https:/\/api.polygonscan.com/"
}
});
2023-02-23 14:31:09 +03:00
registerEth("matic-mumbai", 80001, {
altNames: ["maticMumbai", "maticmum"],
2022-10-20 12:03:32 +03:00
// priorityFee: 35000000000,
etherscan: {
2023-02-23 05:53:56 +03:00
// apiKey: "W6T8DJW654GNTQ34EFEYYP3EZD9DD27CT7",
2022-10-20 12:03:32 +03:00
url: "https:/\/api-testnet.polygonscan.com/"
}
});
registerEth("bnb", 56, {
ensNetwork: 1,
etherscan: {
2023-02-23 05:53:56 +03:00
// apiKey: "EVTS3CU31AATZV72YQ55TPGXGMVIFUQ9M9",
2022-10-20 12:03:32 +03:00
url: "http:/\/api.bscscan.com"
}
});
registerEth("bnbt", 97, {
etherscan: {
2023-02-23 05:53:56 +03:00
// apiKey: "EVTS3CU31AATZV72YQ55TPGXGMVIFUQ9M9",
2022-10-20 12:03:32 +03:00
url: "http:/\/api-testnet.bscscan.com"
}
});
}
2022-09-05 23:57:11 +03:00
//# sourceMappingURL=network.js.map