eteres 0.0.1-security → 6.7.1

package/src.ts/providers/plugins-network.ts

@@ -0,0 +1,281 @@
+import { defineProperties } from "../utils/properties.js";
+
+import { assertArgument } from "../utils/index.js";
+
+import type { FeeData, Provider } from "./provider.js";
+import type { FetchRequest } from "../utils/fetch.js";
+
+
+const EnsAddress = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+
+/**
+ *  A **NetworkPlugin** provides additional functionality on a [[Network]].
+ */
+export class NetworkPlugin {
+    /**
+     *  The name of the plugin.
+     *
+     *  It is recommended to use reverse-domain-notation, which permits
+     *  unique names with a known authority as well as hierarchal entries.
+     */
+    readonly name!: string;
+
+    /**
+     *  Creates a new **NetworkPlugin**.
+     */
+    constructor(name: string) {
+        defineProperties<NetworkPlugin>(this, { name });
+    }
+
+    /**
+     *  Creates a copy of this plugin.
+     */
+    clone(): NetworkPlugin {
+        return new NetworkPlugin(this.name);
+    }
+
+//    validate(network: Network): NetworkPlugin {
+//        return this;
+//    }
+}
+
+
+/**
+ *  The gas cost parameters for a [[GasCostPlugin]].
+ */
+export type GasCostParameters = {
+    /**
+     *  The transactions base fee.
+     */
+    txBase?: number;
+
+    /**
+     *  The fee for creating a new account.
+     */
+    txCreate?: number;
+
+    /**
+     *  The fee per zero-byte in the data.
+     */
+    txDataZero?: number;
+
+    /**
+     *  The fee per non-zero-byte in the data.
+     */
+    txDataNonzero?: number;
+
+    /**
+     *  The fee per storage key in the [[link-eip-2930]] access list.
+     */
+    txAccessListStorageKey?: number;
+
+    /**
+     *  The fee per address in the [[link-eip-2930]] access list.
+     */
+    txAccessListAddress?: number;
+};
+
+/**
+ *  A **GasCostPlugin** allows a network to provide alternative values when
+ *  computing the intrinsic gas required for a transaction.
+ */
+export class GasCostPlugin extends NetworkPlugin implements GasCostParameters {
+    /**
+     *  The block number to treat these values as valid from.
+     *
+     *  This allows a hardfork to have updated values included as well as
+     *  mulutiple hardforks to be supported.
+     */
+    readonly effectiveBlock!: number;
+
+    /**
+     *  The transactions base fee.
+     */
+    readonly txBase!: number;
+
+    /**
+     *  The fee for creating a new account.
+     */
+    readonly txCreate!: number;
+
+    /**
+     *  The fee per zero-byte in the data.
+     */
+    readonly txDataZero!: number;
+
+    /**
+     *  The fee per non-zero-byte in the data.
+     */
+    readonly txDataNonzero!: number;
+
+    /**
+     *  The fee per storage key in the [[link-eip-2930]] access list.
+     */
+    readonly txAccessListStorageKey!: number;
+
+    /**
+     *  The fee per address in the [[link-eip-2930]] access list.
+     */
+    readonly txAccessListAddress!: number;
+
+
+    /**
+     *  Creates a new GasCostPlugin from %%effectiveBlock%% until the
+     *  latest block or another GasCostPlugin supercedes that block number,
+     *  with the associated %%costs%%.
+     */
+    constructor(effectiveBlock?: number, costs?: GasCostParameters) {
+        if (effectiveBlock == null) { effectiveBlock = 0; }
+        super(`org.ethers.network.plugins.GasCost#${ (effectiveBlock || 0) }`);
+
+        const props: Record<string, number> = { effectiveBlock };
+        function set(name: keyof GasCostParameters, nullish: number): void {
+            let value = (costs || { })[name];
+            if (value == null) { value = nullish; }
+            assertArgument(typeof(value) === "number", `invalud value for ${ name }`, "costs", costs);
+            props[name] = value;
+        }
+
+        set("txBase", 21000);
+        set("txCreate", 32000);
+        set("txDataZero", 4);
+        set("txDataNonzero", 16);
+        set("txAccessListStorageKey", 1900);
+        set("txAccessListAddress", 2400);
+
+        defineProperties<GasCostPlugin>(this, props);
+    }
+
+    clone(): GasCostPlugin {
+        return new GasCostPlugin(this.effectiveBlock, this);
+    }
+}
+
+/**
+ *  An **EnsPlugin** allows a [[Network]] to specify the ENS Registry
+ *  Contract address and the target network to use when using that
+ *  contract.
+ *
+ *  Various testnets have their own instance of the contract to use, but
+ *  in general, the mainnet instance supports multi-chain addresses and
+ *  should be used.
+ */
+export class EnsPlugin extends NetworkPlugin {
+
+    /**
+     *  The ENS Registrty Contract address.
+     */
+    readonly address!: string;
+
+    /**
+     *  The chain ID that the ENS contract lives on.
+     */
+    readonly targetNetwork!: number;
+
+    /**
+     *  Creates a new **EnsPlugin** connected to %%address%% on the
+     *  %%targetNetwork%%. The default ENS address and mainnet is used
+     *  if unspecified.
+     */
+    constructor(address?: null | string, targetNetwork?: null | number) {
+        super("org.ethers.plugins.network.Ens");
+        defineProperties<EnsPlugin>(this, {
+            address: (address || EnsAddress),
+            targetNetwork: ((targetNetwork == null) ? 1: targetNetwork)
+        });
+    }
+
+    clone(): EnsPlugin {
+        return new EnsPlugin(this.address, this.targetNetwork);
+    }
+}
+
+/**
+ *  A **FeeDataNetworkPlugin** allows a network to provide and alternate
+ *  means to specify its fee data.
+ *
+ *  For example, a network which does not support [[link-eip-1559]] may
+ *  choose to use a Gas Station site to approximate the gas price.
+ */
+export class FeeDataNetworkPlugin extends NetworkPlugin {
+    readonly #feeDataFunc: (provider: Provider) => Promise<FeeData>;
+
+    /**
+     *  The fee data function provided to the constructor.
+     */
+    get feeDataFunc(): (provider: Provider) => Promise<FeeData> {
+        return this.#feeDataFunc;
+    }
+
+    /**
+     *  Creates a new **FeeDataNetworkPlugin**.
+     */
+    constructor(feeDataFunc: (provider: Provider) => Promise<FeeData>) {
+        super("org.ethers.plugins.network.FeeData");
+        this.#feeDataFunc = feeDataFunc;
+    }
+
+    /**
+     *  Resolves to the fee data.
+     */
+    async getFeeData(provider: Provider): Promise<FeeData> {
+        return await this.#feeDataFunc(provider);
+    }
+
+    clone(): FeeDataNetworkPlugin {
+        return new FeeDataNetworkPlugin(this.#feeDataFunc);
+    }
+}
+
+export class FetchUrlFeeDataNetworkPlugin extends NetworkPlugin {
+    readonly #url: string;
+    readonly #processFunc: (f: () => Promise<FeeData>, p: Provider, r: FetchRequest) => Promise<{ gasPrice?: null | bigint, maxFeePerGas?: null | bigint, maxPriorityFeePerGas?: null | bigint }>;
+
+    /**
+     *  The URL to initialize the FetchRequest with in %%processFunc%%.
+     */
+    get url(): string { return this.#url; }
+
+    /**
+     *  The callback to use when computing the FeeData.
+     */
+    get processFunc(): (f: () => Promise<FeeData>, p: Provider, r: FetchRequest) => Promise<{ gasPrice?: null | bigint, maxFeePerGas?: null | bigint, maxPriorityFeePerGas?: null | bigint }> { return this.#processFunc; }
+
+    /**
+     *  Creates a new **FetchUrlFeeDataNetworkPlugin** which will
+     *  be used when computing the fee data for the network.
+     */
+    constructor(url: string, processFunc: (f: () => Promise<FeeData>, p: Provider, r: FetchRequest) => Promise<{ gasPrice?: null | bigint, maxFeePerGas?: null | bigint, maxPriorityFeePerGas?: null | bigint }>) {
+        super("org.ethers.plugins.network.FetchUrlFeeDataPlugin");
+        this.#url = url;
+        this.#processFunc = processFunc;
+    }
+
+    // We are immutable, so we can serve as our own clone
+    clone(): FetchUrlFeeDataNetworkPlugin { return this; }
+}
+
+/*
+export class CustomBlockNetworkPlugin extends NetworkPlugin {
+    readonly #blockFunc: (provider: Provider, block: BlockParams<string>) => Block<string>;
+    readonly #blockWithTxsFunc: (provider: Provider, block: BlockParams<TransactionResponseParams>) => Block<TransactionResponse>;
+
+    constructor(blockFunc: (provider: Provider, block: BlockParams<string>) => Block<string>, blockWithTxsFunc: (provider: Provider, block: BlockParams<TransactionResponseParams>) => Block<TransactionResponse>) {
+        super("org.ethers.network-plugins.custom-block");
+        this.#blockFunc = blockFunc;
+        this.#blockWithTxsFunc = blockWithTxsFunc;
+    }
+
+    async getBlock(provider: Provider, block: BlockParams<string>): Promise<Block<string>> {
+        return await this.#blockFunc(provider, block);
+    }
+
+    async getBlockions(provider: Provider, block: BlockParams<TransactionResponseParams>): Promise<Block<TransactionResponse>> {
+        return await this.#blockWithTxsFunc(provider, block);
+    }
+
+    clone(): CustomBlockNetworkPlugin {
+        return new CustomBlockNetworkPlugin(this.#blockFunc, this.#blockWithTxsFunc);
+    }
+}
+*/

package/src.ts/providers/provider-alchemy.ts

@@ -0,0 +1,134 @@
+/**
+ *  About Alchemy
+ *
+ *  @_subsection: api/providers/thirdparty:Alchemy  [providers-alchemy]
+ */
+import {
+    defineProperties, resolveProperties, assert, assertArgument,
+    FetchRequest
+} from "../utils/index.js";
+
+import { showThrottleMessage } from "./community.js";
+import { Network } from "./network.js";
+import { JsonRpcProvider } from "./provider-jsonrpc.js";
+
+import type { AbstractProvider, PerformActionRequest } from "./abstract-provider.js";
+import type { CommunityResourcable } from "./community.js";
+import type { Networkish } from "./network.js";
+
+
+const defaultApiKey = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC"
+
+function getHost(name: string): string {
+    switch(name) {
+        case "mainnet":
+            return "eth-mainnet.alchemyapi.io";
+        case "goerli":
+            return "eth-goerli.g.alchemy.com";
+        case "sepolia":
+            return "eth-sepolia.g.alchemy.com";
+
+        case "arbitrum":
+            return "arb-mainnet.g.alchemy.com";
+        case "arbitrum-goerli":
+            return "arb-goerli.g.alchemy.com";
+        case "matic":
+            return "polygon-mainnet.g.alchemy.com";
+        case "matic-mumbai":
+            return "polygon-mumbai.g.alchemy.com";
+        case "optimism":
+            return "opt-mainnet.g.alchemy.com";
+        case "optimism-goerli":
+            return "opt-goerli.g.alchemy.com";
+    }
+
+    assertArgument(false, "unsupported network", "network", name);
+}
+
+/**
+ *  The **AlchemyProvider** connects to the [[link-alchemy]]
+ *  JSON-RPC end-points.
+ *
+ *  By default, a highly-throttled API key is used, which is
+ *  appropriate for quick prototypes and simple scripts. To
+ *  gain access to an increased rate-limit, it is highly
+ *  recommended to [sign up here](link-alchemy-signup).
+ *
+ *  @_docloc: api/providers/thirdparty
+ */
+export class AlchemyProvider extends JsonRpcProvider implements CommunityResourcable {
+    readonly apiKey!: string;
+
+    constructor(_network?: Networkish, apiKey?: null | string) {
+        if (_network == null) { _network = "mainnet"; }
+        const network = Network.from(_network);
+        if (apiKey == null) { apiKey = defaultApiKey; }
+
+        const request = AlchemyProvider.getRequest(network, apiKey);
+        super(request, network, { staticNetwork: network });
+
+        defineProperties<AlchemyProvider>(this, { apiKey });
+    }
+
+    _getProvider(chainId: number): AbstractProvider {
+        try {
+            return new AlchemyProvider(chainId, this.apiKey);
+        } catch (error) { }
+        return super._getProvider(chainId);
+    }
+
+    async _perform(req: PerformActionRequest): Promise<any> {
+
+        // https://docs.alchemy.com/reference/trace-transaction
+        if (req.method === "getTransactionResult") {
+            const { trace, tx } = await resolveProperties({
+                trace: this.send("trace_transaction", [ req.hash ]),
+                tx: this.getTransaction(req.hash)
+            });
+            if (trace == null || tx == null) { return null; }
+
+            let data: undefined | string;
+            let error = false;
+            try {
+                data = trace[0].result.output;
+                error = (trace[0].error === "Reverted");
+            } catch (error) { }
+
+            if (data) {
+                assert(!error, "an error occurred during transaction executions", "CALL_EXCEPTION", {
+                    action: "getTransactionResult",
+                    data,
+                    reason: null,
+                    transaction: tx,
+                    invocation: null,
+                    revert: null // @TODO
+                });
+                return data;
+            }
+
+            assert(false, "could not parse trace result", "BAD_DATA", { value: trace });
+        }
+
+        return await super._perform(req);
+    }
+
+    isCommunityResource(): boolean {
+        return (this.apiKey === defaultApiKey);
+    }
+
+    static getRequest(network: Network, apiKey?: string): FetchRequest {
+        if (apiKey == null) { apiKey = defaultApiKey; }
+
+        const request = new FetchRequest(`https:/\/${ getHost(network.name) }/v2/${ apiKey }`);
+        request.allowGzip = true;
+
+        if (apiKey === defaultApiKey) {
+            request.retryFunc = async (request, response, attempt) => {
+                showThrottleMessage("alchemy");
+                return true;
+            }
+        }
+
+        return request;
+    }
+}

package/src.ts/providers/provider-ankr.ts

@@ -0,0 +1,122 @@
+/**
+ *  [[link-ankr]] provides a third-party service for connecting to
+ *  various blockchains over JSON-RPC.
+ *
+ *  **Supported Networks**
+ *
+ *  - Ethereum Mainnet (``mainnet``)
+ *  - Goerli Testnet (``goerli``)
+ *  - Polygon (``matic``)
+ *  - Arbitrum (``arbitrum``)
+ *
+ *  @_subsection: api/providers/thirdparty:Ankr  [providers-ankr]
+ */
+import {
+    defineProperties, FetchRequest, assertArgument
+} from "../utils/index.js";
+
+import { AbstractProvider } from "./abstract-provider.js";
+import { showThrottleMessage } from "./community.js";
+import { Network } from "./network.js";
+import { JsonRpcProvider } from "./provider-jsonrpc.js";
+
+import type { CommunityResourcable } from "./community.js";
+import type { Networkish } from "./network.js";
+import type { JsonRpcError, JsonRpcPayload } from "./provider-jsonrpc.js";
+
+
+const defaultApiKey = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972";
+
+function getHost(name: string): string {
+    switch (name) {
+        case "mainnet":
+            return "rpc.ankr.com/eth";
+        case "goerli":
+            return "rpc.ankr.com/eth_goerli";
+        case "matic":
+            return "rpc.ankr.com/polygon";
+        case "arbitrum":
+            return "rpc.ankr.com/arbitrum";
+    }
+
+    assertArgument(false, "unsupported network", "network", name);
+}
+
+
+/**
+ *  The **AnkrProvider** connects to the [[link-ankr]]
+ *  JSON-RPC end-points.
+ *
+ *  By default, a highly-throttled API key is used, which is
+ *  appropriate for quick prototypes and simple scripts. To
+ *  gain access to an increased rate-limit, it is highly
+ *  recommended to [sign up here](link-ankr-signup).
+ */
+export class AnkrProvider extends JsonRpcProvider implements CommunityResourcable {
+
+    /**
+     *  The API key for the Ankr connection.
+     */
+    readonly apiKey!: string;
+
+    /**
+     *  Create a new **AnkrProvider**.
+     *
+     *  By default connecting to ``mainnet`` with a highly throttled
+     *  API key.
+     */
+    constructor(_network?: Networkish, apiKey?: null | string) {
+        if (_network == null) { _network = "mainnet"; }
+        const network = Network.from(_network);
+        if (apiKey == null) { apiKey = defaultApiKey; }
+
+        // Ankr does not support filterId, so we force polling
+        const options = { polling: true, staticNetwork: network };
+
+        const request = AnkrProvider.getRequest(network, apiKey);
+        super(request, network, options);
+
+        defineProperties<AnkrProvider>(this, { apiKey });
+    }
+
+    _getProvider(chainId: number): AbstractProvider {
+        try {
+            return new AnkrProvider(chainId, this.apiKey);
+        } catch (error) { }
+        return super._getProvider(chainId);
+    }
+
+    /**
+     *  Returns a prepared request for connecting to %%network%% with
+     *  %%apiKey%%.
+     */
+    static getRequest(network: Network, apiKey?: null | string): FetchRequest {
+        if (apiKey == null) { apiKey = defaultApiKey; }
+
+        const request = new FetchRequest(`https:/\/${ getHost(network.name) }/${ apiKey }`);
+        request.allowGzip = true;
+
+        if (apiKey === defaultApiKey) {
+            request.retryFunc = async (request, response, attempt) => {
+                showThrottleMessage("AnkrProvider");
+                return true;
+            };
+        }
+
+        return request;
+    }
+
+    getRpcError(payload: JsonRpcPayload, error: JsonRpcError): Error {
+        if (payload.method === "eth_sendRawTransaction") {
+            if (error && error.error && error.error.message === "INTERNAL_ERROR: could not replace existing tx") {
+                error.error.message = "replacement transaction underpriced";
+            }
+        }
+
+        return super.getRpcError(payload, error);
+    }
+
+    isCommunityResource(): boolean {
+        return (this.apiKey === defaultApiKey);
+    }
+}

package/src.ts/providers/provider-browser.ts

@@ -0,0 +1,142 @@
+import { assertArgument } from "../utils/index.js";
+
+import { JsonRpcApiPollingProvider } from "./provider-jsonrpc.js";
+
+import type {
+    JsonRpcError, JsonRpcPayload, JsonRpcResult,
+    JsonRpcSigner
+} from "./provider-jsonrpc.js";
+import type { Networkish } from "./network.js";
+
+/**
+ *  The interface to an [[link-eip-1193]] provider, which is a standard
+ *  used by most injected providers, which the [[BrowserProvider]] accepts
+ *  and exposes the API of.
+ */
+export interface Eip1193Provider {
+    /**
+     *  See [[link-eip-1193]] for details on this method.
+     */
+    request(request: { method: string, params?: Array<any> | Record<string, any> }): Promise<any>;
+};
+
+/**
+ *  The possible additional events dispatched when using the ``"debug"``
+ *  event on a [[BrowserProvider]].
+ */
+export type DebugEventBrowserProvider = {
+    action: "sendEip1193Payload",
+    payload: { method: string, params: Array<any> }
+} | {
+    action: "receiveEip1193Result",
+    result: any
+} | {
+    action: "receiveEip1193Error",
+    error: Error
+};
+
+
+/**
+ *  A **BrowserProvider** is intended to wrap an injected provider which
+ *  adheres to the [[link-eip-1193]] standard, which most (if not all)
+ *  currently do.
+ */
+export class BrowserProvider extends JsonRpcApiPollingProvider {
+    #request: (method: string, params: Array<any> | Record<string, any>) => Promise<any>;
+
+    /**
+     *  Connnect to the %%ethereum%% provider, optionally forcing the
+     *  %%network%%.
+     */
+    constructor(ethereum: Eip1193Provider, network?: Networkish) {
+        super(network, { batchMaxCount: 1 });
+
+        this.#request = async (method: string, params: Array<any> | Record<string, any>) => {
+            const payload = { method, params };
+            this.emit("debug", { action: "sendEip1193Request", payload });
+            try {
+                const result = await ethereum.request(payload);
+                this.emit("debug", { action: "receiveEip1193Result", result });
+                return result;
+            } catch (e: any) {
+                const error = new Error(e.message);
+                (<any>error).code = e.code;
+                (<any>error).data = e.data;
+                (<any>error).payload = payload;
+                this.emit("debug", { action: "receiveEip1193Error", error });
+                throw error;
+            }
+        };
+    }
+
+    async send(method: string, params: Array<any> | Record<string, any>): Promise<any> {
+        await this._start();
+
+        return await super.send(method, params);
+    }
+
+    async _send(payload: JsonRpcPayload | Array<JsonRpcPayload>): Promise<Array<JsonRpcResult | JsonRpcError>> {
+        assertArgument(!Array.isArray(payload), "EIP-1193 does not support batch request", "payload", payload);
+
+        try {
+            const result = await this.#request(payload.method, payload.params || [ ]);
+            return [ { id: payload.id, result } ];
+        } catch (e: any) {
+            return [ {
+                id: payload.id,
+                error: { code: e.code, data: e.data, message: e.message }
+            } ];
+        }
+    }
+
+    getRpcError(payload: JsonRpcPayload, error: JsonRpcError): Error {
+
+        error = JSON.parse(JSON.stringify(error));
+
+        // EIP-1193 gives us some machine-readable error codes, so rewrite
+        // them into 
+        switch (error.error.code || -1) {
+            case 4001:
+                error.error.message = `ethers-user-denied: ${ error.error.message }`;
+                break;
+            case 4200:
+                error.error.message = `ethers-unsupported: ${ error.error.message }`;
+                break;
+        }
+
+        return super.getRpcError(payload, error);
+    }
+
+    /**
+     *  Resolves to ``true`` if the provider manages the %%address%%.
+     */
+    async hasSigner(address: number | string): Promise<boolean> {
+        if (address == null) { address = 0; }
+
+        const accounts = await this.send("eth_accounts", [ ]);
+        if (typeof(address) === "number") {
+            return (accounts.length > address);
+        }
+
+        address = address.toLowerCase();
+        return accounts.filter((a: string) => (a.toLowerCase() === address)).length !== 0;
+    }
+
+    async getSigner(address?: number | string): Promise<JsonRpcSigner> {
+        if (address == null) { address = 0; }
+
+        if (!(await this.hasSigner(address))) {
+            try {
+                //const resp = 
+                await this.#request("eth_requestAccounts", [ ]);
+                //console.log("RESP", resp);
+
+            } catch (error: any) {
+                const payload = error.payload;
+                throw this.getRpcError(payload, { id: payload.id, error });
+            }
+        }
+
+        return await super.getSigner(address);
+    }
+}

package/src.ts/providers/provider-cloudflare.ts

@@ -0,0 +1,24 @@
+/**
+ *  About Cloudflare
+ *
+ *  @_subsection: api/providers/thirdparty:Cloudflare  [providers-cloudflare]
+ */
+
+import { assertArgument } from "../utils/index.js";
+
+import { Network } from "./network.js";
+import { JsonRpcProvider } from "./provider-jsonrpc.js";
+
+import type { Networkish } from "./network.js";
+
+/**
+ *  About Cloudflare...
+ */
+export class CloudflareProvider extends JsonRpcProvider {
+    constructor(_network?: Networkish) {
+        if (_network == null) { _network = "mainnet"; }
+        const network = Network.from(_network);
+        assertArgument(network.name === "mainnet", "unsupported network", "network", _network);
+        super("https:/\/cloudflare-eth.com/", network, { staticNetwork: network });
+    }
+}