@instadapp/interop-x 0.0.0-dev.0bace53 → 0.0.0-dev.0ca1aa1

package/src/typechain/factories/index.ts

@@ -1,6 +1,10 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
+export { AaveV2Resolver__factory } from "./AaveV2Resolver__factory";
+export { AaveV3Resolver__factory } from "./AaveV3Resolver__factory";
+export { BalanceResolver__factory } from "./BalanceResolver__factory";
 export { Erc20__factory } from "./Erc20__factory";
 export { GnosisSafe__factory } from "./GnosisSafe__factory";
-export { InteropXContract__factory } from "./InteropXContract__factory";
+export { InstList__factory } from "./InstList__factory";
+export { InteropX__factory } from "./InteropX__factory";

package/src/typechain/index.ts

@@ -1,10 +1,18 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
+export type { AaveV2Resolver } from "./AaveV2Resolver";
+export type { AaveV3Resolver } from "./AaveV3Resolver";
+export type { BalanceResolver } from "./BalanceResolver";
 export type { Erc20 } from "./Erc20";
 export type { GnosisSafe } from "./GnosisSafe";
-export type { InteropXContract } from "./InteropXContract";
+export type { InstList } from "./InstList";
+export type { InteropX } from "./InteropX";
 export * as factories from "./factories";
+export { AaveV2Resolver__factory } from "./factories/AaveV2Resolver__factory";
+export { AaveV3Resolver__factory } from "./factories/AaveV3Resolver__factory";
+export { BalanceResolver__factory } from "./factories/BalanceResolver__factory";
 export { Erc20__factory } from "./factories/Erc20__factory";
 export { GnosisSafe__factory } from "./factories/GnosisSafe__factory";
-export { InteropXContract__factory } from "./factories/InteropXContract__factory";
+export { InstList__factory } from "./factories/InstList__factory";
+export { InteropX__factory } from "./factories/InteropX__factory";

package/src/utils/aave.ts

@@ -0,0 +1,355 @@
+import {
+    BigNumber
+} from "bignumber.js";
+import { http } from "./http";
+import { chainIdToNetwork } from "./web3";
+
+const getIsolationApi = (network: string) =>
+    `https://api.instadapp.io/defi/${network}/aave/v3/isolated`;
+
+const getEmodeApi = (network: string) =>
+    `https://api.instadapp.io/defi/${network}/aave/v3/emode`;
+
+const getPositionApi = (network: string) =>
+    `https://api.instadapp.io/defi/${network}/aave/v3/position`;
+
+const safeHF = 1.3;
+const isolatedDebtCeilingSafeMargin = 0.8;
+
+export const aaveV3ValidateCrossChainPosition = async ({ sourceAddress, targetAddress, sourceChainId, targetChainId, }) => {
+    let totalSupplySource = new BigNumber(0),
+        totalDebtSource = new BigNumber(0),
+        totalSupplyTarget = new BigNumber(0),
+        totalDebtTarget = new BigNumber(0),
+        totalDebtSourceInUsd = new BigNumber(0),
+        totalDebtTargetInUsd = new BigNumber(0);
+
+    const sourceNetwork = chainIdToNetwork(sourceChainId);
+    const targetNetwork = chainIdToNetwork(targetChainId);
+
+    //fetch user position
+    const { data: userSourcePosition } = await http.get(getPositionApi(sourceNetwork), {
+        params: {
+            user: sourceAddress,
+        },
+    })
+
+    const { data: userTargetPosition } = await http.get(getPositionApi(targetNetwork), {
+        params: {
+            user: targetAddress
+        },
+    })
+
+    const { data: targetEmode } = await http.get(getEmodeApi(targetNetwork), {
+        params: {
+            user: targetAddress
+        },
+    })
+
+
+    const { data: sourceIso } = await http.get(getIsolationApi(sourceNetwork), {
+        params: {
+            user: sourceAddress,
+        },
+    })
+
+    const { data: targetIso } = await http.get(getIsolationApi(targetNetwork), {
+        params: {
+            user: targetAddress
+        },
+    })
+
+
+    const sourceDeposits: any = [];
+    const sourceDebts: any = [];
+    const targetDeposits: any = [];
+    const targetDebts: any = [];
+
+    userSourcePosition.data.forEach((info: any) => {
+        if (info.supply > "0") sourceDeposits.push(info);
+        if (info.borrow > "0") sourceDebts.push(info);
+    });
+
+    userTargetPosition.data.forEach((info: any) => {
+        if (info.supply > "0") targetDeposits.push(info);
+        if (info.borrow > "0") targetDebts.push(info);
+    });
+
+    const sourceIsoAssets = sourceIso.isolatedAssets;
+    const targetIsoAssets = targetIso.isolatedAssets;
+
+    sourceDeposits.forEach((asset: any) => {
+        totalSupplySource = totalSupplySource.plus(
+            new BigNumber(asset.supply).multipliedBy(
+                new BigNumber(10).pow(new BigNumber(asset.aDecimals))
+            )
+        );
+    });
+
+    sourceDebts.forEach((asset: any) => {
+        totalDebtSource = totalDebtSource.plus(
+            new BigNumber(asset.borrow).multipliedBy(10 ** asset.aDecimals)
+        );
+
+        totalDebtSourceInUsd = totalDebtSourceInUsd.plus(
+            new BigNumber(asset.borrow).multipliedBy(asset.priceInUsd)
+        );
+    });
+
+    targetDeposits.forEach((asset: any) => {
+        totalSupplyTarget = totalSupplyTarget.plus(
+            new BigNumber(asset.supply).pow(10 ** asset.aDecimals)
+        );
+    });
+
+    targetDebts.forEach((asset: any) => {
+        totalDebtTarget = totalDebtTarget.plus(
+            new BigNumber(asset.borrow).pow(10 ** asset.aDecimals)
+        );
+
+        totalDebtTargetInUsd = totalDebtTargetInUsd.plus(
+            new BigNumber(asset.borrow).multipliedBy(asset.priceInUsd)
+        );
+    });
+
+    /**
+     * user deposit on source chain should be available on target chain
+     * user debts on source chain should be available on target chain
+     */
+    let bool = false;
+    sourceDebts.forEach((asset: any) => {
+        if (!userTargetPosition.data.find((x: any) => x.key === asset.key))
+            bool = true;
+    });
+
+    sourceDeposits.forEach((asset: any) => {
+        if (!userTargetPosition.data.find((x: any) => x.key === asset.key))
+            bool = true;
+    });
+    if (bool) throw "user asset on source chain not available on target chain";
+
+    /**
+     * checking conditions related to EMODE
+     */
+    if (
+        userSourcePosition.emodeId > "0" &&
+        userTargetPosition.emodeId !== userSourcePosition.emodeId
+    )
+        /**
+         * if user position on emode on source chain and not on target chain, can't migrate.
+         * as in source chain tvl and lt for position will be greater > tvl and lt for the same assets.
+         */
+        throw "User emode Id not same between respective chains";
+    else if (
+        userSourcePosition.emodeId === userTargetPosition.emodeId &&
+        userTargetPosition.emodeId > "0"
+    ) {
+        /**
+         * if the user emode Id is same on both chain
+         * @conditions user debt tokens on source chain must be present on the target chain emode Id.
+         */
+        sourceDebts.forEach((asset: any) => {
+            if (
+                !targetEmode[userTargetPosition.emodeId].find(
+                    (x: any) => x.key === asset.aTokenKey
+                )
+            )
+                bool = true;
+        });
+        if (bool) throw "user source debt not a valid debt for target emode";
+
+        let liquidationThreshold = new BigNumber(0);
+
+        /**
+         * liquidation threshold = (∑Collateral amount * liquidation threshold) / ​∑collateral amount
+         */
+        sourceDeposits.forEach((asset: any) => {
+            const lt = userTargetPosition.data.find(
+                (x: any) => x.key === asset.key
+            ).eModeLiquidation;
+            liquidationThreshold.plus(
+                new BigNumber(asset.supply).pow(10 ** asset.aDecimals).multipliedBy(lt)
+            );
+        });
+
+        targetDeposits.forEach((asset: any) => {
+            liquidationThreshold.plus(
+                new BigNumber(asset.supply)
+                    .pow(10 ** asset.aDecimals)
+                    .multipliedBy(asset.eModeLiquidation)
+            );
+        });
+
+        liquidationThreshold = liquidationThreshold.dividedBy(
+            totalSupplySource.plus(totalSupplyTarget)
+        );
+
+        let hfAfterMigration = totalSupplySource
+            .plus(totalSupplyTarget)
+            .dividedBy(totalDebtSource.plus(totalDebtTarget))
+            .dividedBy(liquidationThreshold);
+
+        /**
+         * checking user HF on the target chain
+         * HF = (debt / collateral) / liquidation threshold
+         */
+        if (hfAfterMigration.lt(safeHF))
+            throw "position not safe to migrate on target chain";
+    } else if (userTargetPosition.emodeId > "0") {
+        /**
+         * if the user have emode on target chain
+         * @conditions user debt tokens on source chain must be present on the target chain emode Id.
+         */
+        sourceDebts.forEach((asset: any) => {
+            if (
+                !targetEmode[userTargetPosition.emodeId].find(
+                    (x: any) => x.key === asset.aTokenKey
+                )
+            )
+                bool = true;
+        });
+        if (bool) throw "user source debt not a valid debt for target emode";
+
+        let liquidationThreshold = new BigNumber(0);
+
+        /**
+         * liquidation threshold = (∑Collateral amount * liquidation threshold) / ​∑collateral amount
+         */
+        sourceDeposits.forEach((asset: any) => {
+            const lt = userTargetPosition.data.find(
+                (x: any) => x.key === asset.key
+            ).eModeLiquidation;
+            liquidationThreshold.plus(
+                new BigNumber(asset.supply).pow(10 ** asset.aDecimals).multipliedBy(lt)
+            );
+        });
+
+        targetDeposits.forEach((asset: any) => {
+            liquidationThreshold.plus(
+                new BigNumber(asset.supply)
+                    .pow(10 ** asset.aDecimals)
+                    .multipliedBy(asset.eModeLiquidation)
+            );
+        });
+
+        liquidationThreshold = liquidationThreshold.dividedBy(
+            totalSupplySource.plus(totalSupplyTarget)
+        );
+
+        let hfAfterMigration = totalSupplySource
+            .plus(totalSupplyTarget)
+            .dividedBy(totalDebtSource.plus(totalDebtTarget))
+            .dividedBy(liquidationThreshold);
+
+        /**
+         * checking user HF on the target chain
+         * HF = (debt / collateral) / liquidation threshold
+         */
+        if (hfAfterMigration.lt(safeHF))
+            throw "position not safe to migrate on target chain";
+    }
+
+
+    // checking conditions related to ISOLATION MODE
+    let isSourceOnlyIsolatedAssetEnabledAsCollateral = true,
+        sourceIsolatedAssetAsCollateral: any = [];
+
+    let isTargetOnlyIsolatedAssetEnabledAsCollateral = true,
+        targteIsolatedAssetAsCollateral: any = [];
+
+    /**
+     * user should have enabled only isolated asset as collateral for supply
+     */
+    sourceDeposits.forEach((asset: any) => {
+        if (asset.isEnabledAsCollateral) {
+            const ele = sourceIsoAssets.find((x: any) => x.key === asset.aTokenKey);
+            if (!ele) isSourceOnlyIsolatedAssetEnabledAsCollateral = false;
+            sourceIsolatedAssetAsCollateral.push(asset);
+        }
+    });
+
+    if (sourceIsolatedAssetAsCollateral.length === 0)
+        isSourceOnlyIsolatedAssetEnabledAsCollateral = false;
+
+    targetDeposits.forEach((asset: any) => {
+        if (asset.isEnabledAsCollateral) {
+            const ele = targetIsoAssets.find((x: any) => x.key === asset.aTokenKey);
+            if (!ele) isTargetOnlyIsolatedAssetEnabledAsCollateral = false;
+            targteIsolatedAssetAsCollateral.push(asset);
+        }
+    });
+
+    if (targteIsolatedAssetAsCollateral.length === 0)
+        isTargetOnlyIsolatedAssetEnabledAsCollateral = false;
+
+    if (isSourceOnlyIsolatedAssetEnabledAsCollateral) {
+        const ele = targetIsoAssets.find(
+            (x: any) => x.key === sourceIsolatedAssetAsCollateral[0].aTokenKey
+        );
+
+        /**
+         * if user isolated asset on source chain is also isolated on target chain
+         */
+        if (ele)
+            if (isTargetOnlyIsolatedAssetEnabledAsCollateral) {
+                /**
+                 * if the user is in isolation mode on both chain then.
+                 * @conditions user total debt on source chain should be less than target chain isolated debt ceiling.
+                 */
+                const maxDebtCeiling = new BigNumber(
+                    targteIsolatedAssetAsCollateral[0].isolationDebtCeiling
+                ).multipliedBy(isolatedDebtCeilingSafeMargin);
+
+                if (
+                    maxDebtCeiling.lt(totalDebtSourceInUsd.plus(totalDebtTargetInUsd))
+                ) {
+                    throw "position not safe to migrate on target chain: target isolated debt ceiling will reach";
+                }
+
+                sourceDebts.forEach((asset: any) => {
+                    if (
+                        !targetIso.borrowableInIsolation.find(
+                            (x: any) => x.key === asset.aTokenKey
+                        )
+                    ) {
+                        throw "user source debt not isolated on target chain";
+                    }
+                });
+            } else {
+                throw "can't migrate due to user on isolation mode on only one chain";
+            }
+    } else {
+        const tokenInfoSupply: any = [
+            [],
+            [],
+            []
+        ];
+        const tokenInfoBorrow: any = [
+            [],
+            [],
+            []
+        ];
+
+        sourceDeposits.forEach((asset: any) => {
+            tokenInfoSupply[0].push(asset.underlyingTokenAddress);
+            const ele = userTargetPosition.data.find((x: any) => x.key === asset.key);
+            tokenInfoSupply[1].push(ele.underlyingTokenAddress);
+            tokenInfoSupply[2].push(
+                new BigNumber(asset.supply)
+                    .multipliedBy(10 ** asset.aDecimals)
+                    .toString()
+            );
+        });
+
+        sourceDebts.forEach((asset: any) => {
+            tokenInfoBorrow[0].push(asset.underlyingTokenAddress);
+            const ele = userTargetPosition.data.find((x: any) => x.key === asset.key);
+            tokenInfoBorrow[1].push(ele.underlyingTokenAddress);
+            tokenInfoBorrow[2].push(
+                new BigNumber(asset.borrow)
+                    .multipliedBy(10 ** asset.aDecimals)
+                    .toString()
+            );
+        });
+    }
+}

package/src/utils/async.ts

@@ -0,0 +1,22 @@
+/**
+ * Call an async function with a maximum time limit (in milliseconds) for the timeout
+ *  Resolved promise for async function call, or an error if time limit reached
+ */
+export const asyncCallWithTimeout = async <T>(
+    asyncPromise: Promise<T>,
+    timeout: number
+) => {
+    let timeoutHandle;
+
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeoutHandle = setTimeout(
+            () => reject(new Error("Async call timeout limit reached")),
+            timeout
+        );
+    });
+
+    return Promise.race([asyncPromise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutHandle);
+        return result;
+    }) as Promise<T>;
+};

package/src/utils/dsa.ts

@@ -0,0 +1,56 @@
+import Web3EthAbi from "web3-eth-abi";
+import { connectors } from "@/abi/connectors";
+import { getContract, getRpcProviderUrl } from "./web3";
+import { InstList } from "@/typechain";
+import { addresses } from "@/constants";
+import abi from "@/abi";
+import { JsonRpcRetryProvider } from "@/providers";
+import { ChainId } from "@/types";
+import { ethers } from "ethers";
+
+export const encodeConnectorMethod = (params: {
+    connector: string;
+    method: string;
+    args: string[];
+}) => {
+    const connectorInterface = getInterface(
+        connectors.versions[2][params.connector],
+        params.method
+    );
+
+    if (!connectorInterface)
+        throw new Error(`ConnectorInterface '${params.method}' not found`);
+
+    //@ts-ignore
+    return Web3EthAbi.encodeFunctionCall(connectorInterface, params.args);
+};
+
+const getInterface = (abiItems: any[], method: string) => {
+    const abiItem = abiItems.find((abiItem) => abiItem.name === method);
+
+    if (!abiItem) {
+        console.error(`${method} is an invalid method.`);
+        return;
+    }
+
+    return abiItem;
+};
+
+
+export const getDsaAccountAddress = async ({
+    dsaId,
+    chainId,
+    provider = null as ethers.providers.Provider | null,
+}) => {
+    if (!dsaId) throw new Error("DSA id is required");
+
+    provider = provider || new JsonRpcRetryProvider(getRpcProviderUrl(chainId));
+
+    const instListContract = getContract<InstList>(
+        addresses[chainId].instList,
+        abi.instList,
+        provider,
+    );
+
+    return await instListContract.accountAddr(dsaId)
+}

package/src/utils/formatting.ts

@@ -0,0 +1,68 @@
+const locale = "en-US";
+
+export function formatUsd(value: any, fractionDigits = 0) {
+    const formatter = new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: fractionDigits,
+        maximumFractionDigits: fractionDigits
+    });
+
+    return formatter.format(value);
+}
+
+export function shortenHash(hash: string, length: number = 4) {
+    if (!hash) return;
+
+    if (hash.length < 12) return hash;
+
+    const beginningChars = hash.startsWith("0x") ? length + 2 : length;
+
+    const shortened = hash.substr(0, beginningChars) + "…" + hash.substr(-length);
+
+    return shortened;
+}
+
+export function short(buffer: Buffer): string {
+    return buffer.toString("hex").slice(0, 8) + "...";
+}
+
+export const chainIdToName = (chainId: string | number) => {
+    switch (String(chainId)) {
+        case "1":
+            return "Mainnet";
+        case "137":
+            return "Polygon";
+        case "43114":
+            return "Avalanche";
+        default:
+            return "Mainnet";
+    }
+};
+
+export const getChainIdNativeSymbol = (chainId: string | number) => {
+    switch (String(chainId)) {
+        case "137":
+            return "MATIC";
+        case "43114":
+            return "AVAX";
+        case "1":
+            return "ETH";
+        default:
+            return "ETH";
+    }
+};
+
+
+export const getExplorerUrl = (chainId: string | number, suffix = '/') => {
+    switch (String(chainId)) {
+        case "1":
+            return `https://etherscan.io${suffix}`;
+        case "137":
+            return `https://polygonscan.com${suffix}`;
+        case "43114":
+            return `https://snowtrace.io${suffix}`;
+        default:
+            return `https://etherscan.io${suffix}`;
+    }
+}

package/src/utils/gnosis.ts

@@ -0,0 +1,166 @@
+import { addresses } from "@/constants";
+import { peerPool } from "@/net";
+import { GnosisSafe } from "@/typechain";
+import { ChainId } from "@/types";
+import { messagePrefix } from "@ethersproject/hash";
+import { ethers, Wallet } from "ethers";
+
+export interface Signature {
+  signer: string;
+  hash?: string;
+  data: string;
+}
+
+export const buildSignatureBytes = (signatures: Signature[]): string => {
+  signatures.sort((left, right) =>
+    left.signer.toLowerCase().localeCompare(right.signer.toLowerCase())
+  );
+  let signatureBytes = "0x";
+  for (const sig of signatures) {
+    signatureBytes += sig.data.slice(2);
+  }
+  return signatureBytes;
+};
+
+const gnosisSignatureTypes = {
+  SafeTx: [
+    { type: "address", name: "to" },
+    { type: "uint256", name: "value" },
+    { type: "bytes", name: "data" },
+    { type: "uint8", name: "operation" },
+    { type: "uint256", name: "safeTxGas" },
+    { type: "uint256", name: "baseGas" },
+    { type: "uint256", name: "gasPrice" },
+    { type: "address", name: "gasToken" },
+    { type: "address", name: "refundReceiver" },
+    { type: "uint256", name: "nonce" },
+  ],
+};
+
+export const getGnosisSignatureAddress = ({ signature, message, chainId }: { signature: string, message: Record<string, any>, chainId: ChainId }) => {
+
+  const gnosisSafe = addresses[chainId].gnosisSafe;
+
+  const domain = {
+    verifyingContract: gnosisSafe,
+    chainId,
+  };
+
+  return ethers.utils.verifyTypedData(domain, gnosisSignatureTypes, message, signature)
+
+}
+
+export const generateGnosisSignatureMessage = ({
+  to,
+  data = null as any,
+  value = "0",
+  operation = "1",
+  baseGas = "0",
+  gasPrice = "0",
+  gasToken = "0x0000000000000000000000000000000000000000",
+  refundReceiver = "0x0000000000000000000000000000000000000000",
+  safeTxGas = "79668" as string | number,
+  nonce = "0",
+  chainId = 137 as ChainId,
+}) => {
+  const gnosisSafe = addresses[chainId].gnosisSafe;
+
+  const message = {
+    baseGas,
+    data,
+    gasPrice,
+    gasToken,
+    nonce: Number(nonce),
+    operation,
+    refundReceiver,
+    safeAddress: gnosisSafe,
+    safeTxGas: String(safeTxGas),
+    to,
+    value,
+  };
+
+  return message;
+}
+
+export const signGnosisSafeTx = async ({
+  to,
+  data = null as any,
+  value = "0",
+  operation = "1",
+  baseGas = "0",
+  gasPrice = "0",
+  gasToken = "0x0000000000000000000000000000000000000000",
+  refundReceiver = "0x0000000000000000000000000000000000000000",
+  safeTxGas = "79668" as string | number,
+  nonce = "0",
+  chainId = 137 as ChainId,
+}, { signer }: { signer: Wallet }
+) => {
+  const gnosisSafe = addresses[chainId].gnosisSafe;
+
+  const domain = {
+    verifyingContract: gnosisSafe,
+    chainId,
+  };
+
+  const message = generateGnosisSignatureMessage({ to, data, value, operation, baseGas, gasPrice, gasToken, refundReceiver, safeTxGas, nonce, chainId });
+
+  return await signer._signTypedData(domain, gnosisSignatureTypes, message);
+};
+
+export const generateGnosisTransaction = async (
+  transactionData: any,
+  safeContract: GnosisSafe
+) => {
+  console.log(transactionData);
+
+  let isExecuted = await safeContract.dataHashes(
+    await safeContract.getTransactionHash(
+      transactionData.to,
+      transactionData.value,
+      transactionData.data,
+      transactionData.operation,
+      transactionData.safeTxGas,
+      transactionData.baseGas,
+      transactionData.gasPrice,
+      transactionData.gasToken,
+      transactionData.refundReceiver,
+      transactionData.nonce
+    )
+  );
+
+  while (isExecuted == 1) {
+    transactionData.safeTxGas = ethers.BigNumber.from(
+      String(transactionData.safeTxGas)
+    )
+      .add(1)
+      .toString();
+
+    isExecuted = await safeContract.dataHashes(
+      await safeContract.getTransactionHash(
+        transactionData.to,
+        transactionData.value,
+        transactionData.data,
+        transactionData.operation,
+        transactionData.safeTxGas,
+        transactionData.baseGas,
+        transactionData.gasPrice,
+        transactionData.gasToken,
+        transactionData.refundReceiver,
+        transactionData.nonce
+      )
+    );
+  }
+
+  return transactionData;
+};
+
+export const getGnosisOwnerPeerIds = async ({ gnosisContract = null as unknown as GnosisSafe }) => {
+  const owners = await gnosisContract
+    .getOwners()
+    .then((owners) => owners.map((owner) => owner.toLowerCase()));
+
+  return peerPool.activePeers
+    .filter((peer) => owners.includes(peer.publicAddress.toLowerCase()))
+    .map((peer) => peer.id);
+}