@instadapp/interop-x 0.0.0-dev.9b26e43 → 0.0.0-dev.9d8d8b4

package/src/utils/validate.ts

@@ -0,0 +1,179 @@
+import abi from "@/abi";
+import { addresses, capPerChain, tokens } from "@/constants";
+import { InvalidChaindIdError, LowLiquidityError } from "@/errors";
+import { ethers } from "ethers";
+import { getContract, getRpcProviderUrl } from "./web3";
+import BigNumber from "bignumber.js";
+import { chainIdToName, formatUsd } from "./formatting";
+import { isNativeWrappedToken } from "./tokens";
+import { Prices } from "@/services";
+import { JsonRpcRetryProvider } from "@/providers";
+import { IPosition } from "@/db";
+import { BalanceResolver } from "@/typechain";
+import { getDsaAccountAddress } from "./dsa";
+
+export const validateChains = ({ sourceChainId, targetChainId }) => {
+    if (!sourceChainId) {
+        throw new InvalidChaindIdError("Source chain id is required");
+    }
+
+    if (!targetChainId) {
+        throw new InvalidChaindIdError("Target chain id is required");
+    }
+
+    if (sourceChainId == targetChainId) {
+        throw new InvalidChaindIdError("Source and target chain cannot be the same");
+    }
+
+    if (!addresses[sourceChainId]) {
+        throw new InvalidChaindIdError("Invalid source chain id");
+    }
+
+    if (!addresses[targetChainId]) {
+        throw new InvalidChaindIdError("Invalid target chain id");
+    }
+};
+
+
+export const validateSourceLiquidity = async ({
+    position = null as unknown as IPosition,
+    sourceChainId,
+    sourceDsaId,
+    isSupply = false,
+    sourceProvider = null as unknown as JsonRpcRetryProvider,
+}) => {
+    sourceProvider = sourceProvider || new JsonRpcRetryProvider(getRpcProviderUrl(sourceChainId));
+
+
+    const sourceBalanceResolverContract = getContract<BalanceResolver>(
+        addresses[sourceChainId].balanceResolver,
+        abi.balanceResolver,
+        sourceProvider,
+    )
+
+    const srcDsaAddress = await getDsaAccountAddress({ dsaId: sourceDsaId, chainId: sourceChainId , provider: sourceProvider });
+    const srcBalance = await sourceBalanceResolverContract.checkLiquidity(position, srcDsaAddress, isSupply, false)
+
+    if (!srcBalance.isOk) {
+
+        let liquidityRequired = ""
+
+        srcBalance.withdraw.forEach(a => {
+            const token = tokens[sourceChainId].find(t => t.address.toLowerCase() === a.token.toLowerCase());
+
+            if (token && (new BigNumber(a.liquidityShort.toString()).isZero()) == false) {
+                liquidityRequired += `- Need ${new BigNumber(a.liquidityShort.toString()).dividedBy(10 ** token.decimals).toFormat()} ${token.symbol}\n`
+            }
+        })
+
+        throw new LowLiquidityError(`Liquidity low on ${chainIdToName(sourceChainId)}: \n` + liquidityRequired);
+    }
+};
+
+export const validateTargetLiquidity = async ({
+    position = null as unknown as IPosition,
+    targetChainId,
+    targetDsaId,
+    targetProvider = null as unknown as JsonRpcRetryProvider,
+}) => {
+    targetProvider = targetProvider || new JsonRpcRetryProvider(getRpcProviderUrl(targetChainId));
+
+
+    const sourceBalanceResolverContract = getContract<BalanceResolver>(
+        addresses[targetChainId].balanceResolver,
+        abi.balanceResolver,
+        targetProvider,
+    )
+    // TODO:
+
+    const targetDsaAddress = await getDsaAccountAddress({ dsaId: targetDsaId, chainId: targetChainId, provider: targetProvider });
+
+    const targetBalance = await sourceBalanceResolverContract.checkLiquidity(position, targetDsaAddress, true, true)
+
+    if (!targetBalance.isOk) {
+
+        let liquidityRequired = ""
+
+        targetBalance.supply.forEach(a => {
+            const token = tokens[targetChainId].find(t => t.address.toLowerCase() === a.token.toLowerCase());
+
+
+            if (token) {
+                liquidityRequired += `- Need ${new BigNumber(a.liquidityShort.toString()).dividedBy(10 ** token.decimals).toFormat()} ${token.symbol}\n`
+            }
+        })
+
+        throw new LowLiquidityError(`Liquidity low on ${chainIdToName(targetChainId)}: \n` + liquidityRequired);
+    }
+};
+
+const mapTokenAddressToMainnetToken = (
+    address: string,
+    targetChainId: number | string
+) => {
+    targetChainId = String(targetChainId);
+    const token = tokens[targetChainId].find(
+        (t) => t.address.toLowerCase() === address.toLowerCase()
+    );
+
+    if (targetChainId === "1") {
+        return token;
+    }
+
+    if (!token) {
+        return null;
+    }
+
+    return tokens["1"].find((t) => t.symbol === token.symbol);
+};
+
+export const validateLiquidityCap = async (
+    position: IPosition,
+    sourceChainId: number | string,
+    targetChainId: number | string
+) => {
+    const cap = capPerChain[targetChainId] || 1_000_000;
+    const mainnetPrices = Prices.getMainnetPrices();
+    const nativeTokenPrice = Prices.getNetworkTokenPrices()[targetChainId];
+
+    let total = new BigNumber(0);
+
+    const supplyPosition = position.supply;
+
+    for (const { sourceToken: srcTokenAddress, targetToken: tokenAddress, amount } of supplyPosition) {
+        let tokenPrice;
+        let token;
+
+        if (isNativeWrappedToken(srcTokenAddress, sourceChainId)) {
+            tokenPrice = nativeTokenPrice;
+            token = tokens[targetChainId].find(t => t.address === '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE');
+        } else {
+            const mainnetToken = mapTokenAddressToMainnetToken(
+                tokenAddress,
+                targetChainId
+            );
+            if (!mainnetToken) {
+                throw new Error(`Token ${tokenAddress} is not valid.`);
+            }
+
+            tokenPrice = mainnetPrices[mainnetToken.address];
+
+            if (!tokenPrice) {
+                throw new Error(`Token ${tokenAddress} is not valid!`);
+            }
+
+            token = mainnetToken;
+        }
+
+
+        total = total.plus((tokenPrice * Number(amount)) / 10 ** token.decimals);
+    }
+
+    if (total.isGreaterThan(cap)) {
+        throw new Error(
+            `Total amount of tokens in the transaction is greater than the maximum limit of estimated ${formatUsd(
+                cap
+            )}`
+        );
+    }
+};

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;
+        },
+    });
+}