@instadapp/interop-x 0.0.0-dev.e916c22 → 0.0.0-dev.ea4acf6

package/src/utils/web3.ts

@@ -0,0 +1,132 @@
+import { UnsupportedChaindIdError } from "@/errors";
+import { ChainId } from "@/types";
+import retry from "async-retry";
+import { ethers } from "ethers";
+
+export const getRpcProviderUrl = (chainId: ChainId) => {
+    switch (chainId) {
+        case 1:
+            return "https://rpc.ankr.com/eth";
+        case 137:
+            return "https://rpc.ankr.com/polygon";
+        case 43114:
+            return "https://rpc.ankr.com/avalanche";
+        default:
+            throw new UnsupportedChaindIdError(chainId);
+    }
+};
+
+
+export class ContractError extends Error {
+    method: string;
+    address: string;
+    args: any[];
+}
+
+export function getContract<TContract extends ethers.Contract>(
+    address: string,
+    contractInterface: ethers.ContractInterface | any,
+    signerOrProvider: ethers.Signer | ethers.providers.Provider
+) {
+    if (
+        !ethers.utils.getAddress(address) ||
+        address === ethers.constants.AddressZero
+    ) {
+        throw Error(`Invalid 'address' parameter '${address}'.`);
+    }
+
+    const contract = new ethers.Contract(
+        address,
+        contractInterface,
+        signerOrProvider
+    ) as TContract;
+
+    // Make sure the contract properties is writable
+    const desc = Object.getOwnPropertyDescriptor(contract, "functions");
+
+    if (!desc || desc.writable !== true) {
+        return contract;
+    }
+
+    return new Proxy(contract, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+
+            if (
+                typeof value === "function" &&
+                (contract.functions.hasOwnProperty(prop) ||
+                    ["queryFilter"].includes(String(prop)))
+            ) {
+                let isConstant = false;
+
+                try {
+                    isConstant = contract.interface.getFunction(String(prop)).constant;
+                } catch (error) { }
+
+                return async (...args: any[]) => {
+                    try {
+                        return await retry(
+                            async () => await value.bind(contract)(...args),
+                            { retries: isConstant ? 1 : 3 }
+                        );
+                    } catch (error) {
+                        const err = new ContractError(
+                            `Error calling "${String(prop)}" on "${address}": ${error.reason || error.message
+                            }`
+                        );
+
+                        err.method = String(prop);
+                        err.address = address;
+                        err.args = [...args];
+
+                        throw err;
+                    }
+                };
+            }
+
+            if (
+                typeof value === "object" &&
+                [
+                    "populateTransaction",
+                    "estimateGas",
+                    "functions",
+                    "callStatic",
+                ].includes(String(prop))
+            ) {
+                const parentProp = String(prop);
+
+                return new Proxy(value, {
+                    get(target, prop, receiver) {
+                        const value = Reflect.get(target, prop, receiver);
+
+                        if (typeof value === "function") {
+                            return async (...args: any[]) => {
+                                try {
+                                    return await retry(
+                                        async () => await value.bind(contract)(...args),
+                                        { retries: parentProp === "callStatic" ? 3 : 1 }
+                                    );
+                                } catch (error) {
+                                    const err = new ContractError(
+                                        `Error calling "${String(
+                                            prop
+                                        )}" using "${parentProp}" on "${address}": ${error.reason || error.message
+                                        }`
+                                    );
+
+                                    err.method = String(prop);
+                                    err.address = address;
+                                    err.args = [...args];
+
+                                    throw err;
+                                }
+                            };
+                        }
+                    },
+                });
+            }
+
+            return value;
+        },
+    });
+}