@instadapp/interop-x 0.0.0-dev.0b0cc3f → 0.0.0-dev.0fcef2e

package/src/gnosis/actions/aaveV2/source.ts

@@ -0,0 +1,174 @@
+import abi from "@/abi";
+import config from "@/config";
+import { addresses } from "@/constants";
+import { Transaction } from "@/db";
+import { JsonRpcRetryProvider } from "@/providers";
+import { AaveV2Resolver, InstList, InteropX } from "@/typechain";
+import { ChainId } from "@/types";
+import { encodeConnectorMethod, getContract, getRpcProviderUrl } from "@/utils";
+import { ethers } from "ethers";
+import { MetaTransaction, OperationType } from "ethers-multisend";
+
+const safeUserRatioGap = "800000000000000000"
+
+export default async function (transaction: Transaction) {
+  const transactions: MetaTransaction[] = [];
+  const logs: any[] = [];
+
+  const {
+    position,
+    actionId,
+    actionIdHashHash,
+    sourceSender,
+    sourceDsaId,
+    targetDsaId,
+    sourceChainId,
+    targetChainId,
+    vnonce,
+    metadata,
+  } = transaction.submitEvent;
+
+  const sourceChainProvider = new JsonRpcRetryProvider(
+    getRpcProviderUrl(sourceChainId as ChainId)
+  );
+  const sourceWallet = new ethers.Wallet(
+    config.privateKey,
+    sourceChainProvider
+  );
+  const targetChainProvider = new JsonRpcRetryProvider(
+    getRpcProviderUrl(targetChainId as ChainId)
+  );
+  const targetWallet = new ethers.Wallet(
+    config.privateKey,
+    targetChainProvider
+  );
+  const dsaAddress = addresses[sourceChainId].dsaAddress;
+  const sourceUserAddress =
+    Number(sourceDsaId) == 0 ? sourceSender : dsaAddress;
+  const interopAddress = addresses[sourceChainId].interopX;
+  const contract = getContract<InteropX>(
+    interopAddress,
+    abi.interopX,
+    sourceWallet
+  );
+
+  const sourceResolverContract = getContract<AaveV2Resolver>(
+    addresses[sourceChainId].aaveV2Resolver,
+    abi.aaveV2Resolver,
+    sourceWallet
+  );
+
+  const targetResolverContract = getContract<AaveV2Resolver>(
+    addresses[targetChainId].aaveV2Resolver,
+    abi.aaveV2Resolver,
+    targetWallet
+  );
+
+  const sourceAavePosition = await sourceResolverContract.checkAavePosition(sourceUserAddress, position, safeUserRatioGap, false)
+
+  const userSourceAaveIsOk = sourceAavePosition.isOk;
+
+  if (!userSourceAaveIsOk) {
+    throw new Error("Source chain aave position is not safe to migrate.");
+  }
+
+  const targetInstListContract = getContract<InstList>(
+    addresses[targetChainId].instList,
+    abi.instList,
+    targetChainProvider,
+  );
+
+  const targetDsaAddress = await targetInstListContract.accountAddr(targetDsaId)
+
+  const targetAavePosition = await targetResolverContract
+    .checkAavePosition(targetDsaAddress, position, safeUserRatioGap, true)
+
+  const userTargetAaveIsOk = targetAavePosition.isOk;
+
+  if (!userTargetAaveIsOk) {
+    throw new Error("Target chain aave position will not be safe after migration.");
+  }
+
+  const targetAavePositionWithFee = await targetResolverContract
+    .checkAavePosition(targetDsaAddress, position, safeUserRatioGap, true);
+
+  const userTargetAaveIsOkWithFee = targetAavePositionWithFee.isOk;
+
+  if (!userTargetAaveIsOkWithFee) {
+    throw new Error("Target chain aave position will not be safe after migration due to minimum fee.");
+  }
+
+  const sourceSpells: any[] = [];
+  const commonSpells: any[] = [];
+
+  for (const withdraw of position.withdraw) {
+    let spellData = {
+      connector: "AAVE-V2-A",
+      method: "payback",
+      args: [withdraw.sourceToken, withdraw.amount, "2", "0", "0"],
+    };
+
+    sourceSpells.push({
+      connector: spellData.connector,
+      data: encodeConnectorMethod(spellData),
+    });
+
+    let spellDataBasicWithdraw = {
+      connector: "BASIC-A",
+      method: "withdraw",
+      args: [withdraw.sourceToken, withdraw.amount, sourceUserAddress, "0", "0"],
+    };
+
+    commonSpells.push({
+      connector: spellDataBasicWithdraw.connector,
+      data: encodeConnectorMethod(spellDataBasicWithdraw),
+    });
+  }
+
+  for (const supply of position.supply) {
+    let spellDataWithdraw = {
+      connector: "AAVE-V2-A",
+      method: "withdraw",
+      args: [supply.sourceToken, supply.amount, "0", "0"],
+    };
+
+    sourceSpells.push({
+      connector: spellDataWithdraw.connector,
+      data: encodeConnectorMethod(spellDataWithdraw),
+    });
+
+    let spellDataBasicWithdraw = {
+      connector: "BASIC-A",
+      method: "withdraw",
+      args: [supply.sourceToken, supply.amount, dsaAddress, "0", "0"],
+    };
+
+    sourceSpells.push({
+      connector: spellDataBasicWithdraw.connector,
+      data: encodeConnectorMethod(spellDataBasicWithdraw),
+    });
+  }
+
+  const { data } = await contract.populateTransaction.sourceAction(
+    sourceSpells,
+    commonSpells,
+    position,
+    actionId,
+    sourceSender,
+    sourceDsaId,
+    targetDsaId,
+    sourceChainId,
+    targetChainId,
+    vnonce,
+    metadata
+  );
+
+  transactions.push({
+    to: interopAddress,
+    data: data!,
+    value: "0",
+    operation: OperationType.Call,
+  });
+
+  return { transactions, logs };
+}

package/src/gnosis/actions/aaveV2/target.ts

@@ -0,0 +1,168 @@
+import abi from "@/abi";
+import config from "@/config";
+import { addresses } from "@/constants";
+import { Transaction } from "@/db";
+import { JsonRpcRetryProvider } from "@/providers";
+import { AaveV2Resolver, InteropX } from "@/typechain";
+import { InstList } from "@/typechain/InstList";
+import { ChainId } from "@/types";
+import { encodeConnectorMethod, getContract, getRpcProviderUrl } from "@/utils";
+import { ethers } from "ethers";
+import { MetaTransaction, OperationType } from "ethers-multisend";
+
+const safeUserRatioGap = "800000000000000000"
+
+export default async function (transaction: Transaction) {
+    const transactions: MetaTransaction[] = [];
+    const logs: any[] = [];
+
+    const {
+        sourceSpells,
+        position,
+        actionId,
+        sourceSender,
+        sourceDsaId,
+        targetDsaId,
+        sourceChainId,
+        targetChainId,
+        vnonce,
+        metadata,
+    } = transaction.validateEvent;
+
+    const targetChainProvider = new JsonRpcRetryProvider(
+        getRpcProviderUrl(targetChainId as ChainId)
+    );
+    const targetWallet = new ethers.Wallet(
+        config.privateKey,
+        targetChainProvider
+    );
+
+    const targetResolverContract = getContract<AaveV2Resolver>(
+        addresses[targetChainId].aaveV2Resolver,
+        abi.aaveV2Resolver,
+        targetWallet
+    );
+
+    const targetInstListContract = getContract<InstList>(
+        addresses[targetChainId].instList,
+        abi.instList,
+        targetChainProvider,
+    );
+
+    const targetDsaAddress = await targetInstListContract.accountAddr(targetDsaId)
+
+
+    const targetAavePosition = await targetResolverContract
+        .checkAavePosition(targetDsaAddress, position, safeUserRatioGap, true)
+
+    const userTargetAaveIsOk = targetAavePosition.isOk;
+
+    if (!userTargetAaveIsOk) {
+        throw new Error("Target chain aave position will not be safe after migration.");
+    }
+
+    const targetAavePositionWithFee = await targetResolverContract
+        .checkAavePosition(targetDsaAddress, position, safeUserRatioGap, true);
+
+    const userTargetAaveIsOkWithFee = targetAavePositionWithFee.isOk;
+
+    if (!userTargetAaveIsOkWithFee) {
+        throw new Error("Target chain aave position will not be safe after migration due to minimum fee.");
+    }
+
+    const dsaAddress = addresses[targetChainId].dsaAddress;
+    const interopAddress = addresses[targetChainId].interopX;
+    const contract = getContract<InteropX>(
+        interopAddress,
+        abi.interopX,
+        targetWallet
+    );
+
+    const targetSpells: any[] = [];
+    const commonSpells: any[] = [];
+
+    for (const supplyToken of position.supply) {
+        let spellData = {
+            connector: "AAVE-V2-A",
+            method: "deposit",
+            args: [supplyToken.targetToken, supplyToken.amount, "0", "0"],
+        };
+
+        targetSpells.push({
+            connector: spellData.connector,
+            data: encodeConnectorMethod(spellData),
+        });
+
+        let spellDataBasicWithdraw = {
+            connector: "BASIC-A",
+            method: "withdraw",
+            args: [supplyToken.targetToken, supplyToken.amount, targetDsaAddress, "0", "0"],
+        };
+
+        commonSpells.push({
+            connector: spellDataBasicWithdraw.connector,
+            data: encodeConnectorMethod(spellDataBasicWithdraw),
+        });
+    }
+
+    for (const withdrawToken of position.withdraw) {
+
+        let spellData = {
+            connector: "AAVE-V2-A",
+            method: "borrow",
+            args: [
+                withdrawToken.targetToken,
+                withdrawToken.amount,
+                "2",
+                "0",
+                "0",
+            ],
+        };
+
+        targetSpells.push({
+            connector: spellData.connector,
+            data: encodeConnectorMethod(spellData),
+        });
+
+        let spellData2 = {
+            connector: "BASIC-A",
+            method: "withdraw",
+            args: [
+                withdrawToken.targetToken,
+                withdrawToken.amount,
+                dsaAddress,
+                "0",
+                "0",
+            ],
+        };
+
+        targetSpells.push({
+            connector: spellData.connector,
+            data: encodeConnectorMethod(spellData2),
+        });
+    }
+
+    const { data } = await contract.populateTransaction.targetAction(
+        sourceSpells,
+        targetSpells,
+        commonSpells,
+        position,
+        actionId,
+        sourceSender,
+        sourceDsaId,
+        targetDsaId,
+        sourceChainId,
+        targetChainId,
+        vnonce,
+        metadata
+    );
+
+    transactions.push({
+        to: interopAddress,
+        data: data!,
+        value: "0",
+        operation: OperationType.Call,
+    });
+
+    return { transactions, logs }
+}

package/src/gnosis/actions/aaveV3/index.ts

@@ -0,0 +1,9 @@
+import { Transaction } from "@/db";
+import source from "./source";
+import target from "./target";
+
+
+
+export default async function (transaction: Transaction, type: 'source' | 'target') {
+    return type === 'source' ? source(transaction) : target(transaction);
+}

package/src/gnosis/actions/aaveV3/source.ts

@@ -0,0 +1,119 @@
+import abi from "@/abi";
+import config from "@/config";
+import { addresses } from "@/constants";
+import { Transaction } from "@/db";
+import { JsonRpcRetryProvider } from "@/providers";
+import { InteropX } from "@/typechain";
+import { ChainId } from "@/types";
+import { encodeConnectorMethod, getContract, getRpcProviderUrl } from "@/utils";
+import { ethers } from "ethers";
+import { MetaTransaction, OperationType } from "ethers-multisend";
+
+export default async function (transaction: Transaction) {
+  const transactions: MetaTransaction[] = [];
+  const logs: any[] = [];
+
+  const {
+    position,
+    actionId,
+    actionIdHashHash,
+    sourceSender,
+    sourceDsaId,
+    targetDsaId,
+    sourceChainId,
+    targetChainId,
+    vnonce,
+    metadata,
+  } = transaction.submitEvent;
+
+  const sourceChainProvider = new JsonRpcRetryProvider(
+    getRpcProviderUrl(sourceChainId as ChainId)
+  );
+  const sourceWallet = new ethers.Wallet(
+    config.privateKey,
+    sourceChainProvider
+  );
+  const dsaAddress = addresses[sourceChainId].dsaAddress;
+  const sourceUserAddress =
+    Number(sourceDsaId) == 0 ? sourceSender : dsaAddress;
+  const interopAddress = addresses[sourceChainId].interopX;
+  const contract = getContract<InteropX>(
+    interopAddress,
+    abi.interopX,
+    sourceWallet
+  );
+
+  const sourceSpells: any[] = [];
+  const commonSpells: any[] = [];
+
+  for (const withdraw of position.withdraw) {
+    let spellData = {
+      connector: "AAVE-V3-A",
+      method: "payback",
+      args: [withdraw.sourceToken, withdraw.amount, "2", "0", "0"],
+    };
+
+    sourceSpells.push({
+      connector: spellData.connector,
+      data: encodeConnectorMethod(spellData),
+    });
+
+    let spellDataBasicWithdraw = {
+      connector: "BASIC-A",
+      method: "withdraw",
+      args: [withdraw.sourceToken, withdraw.amount, sourceUserAddress, "0", "0"],
+    };
+
+    commonSpells.push({
+      connector: spellDataBasicWithdraw.connector,
+      data: encodeConnectorMethod(spellDataBasicWithdraw),
+    });
+  }
+
+  for (const supply of position.supply) {
+    let spellDataWithdraw = {
+      connector: "AAVE-V3-A",
+      method: "withdraw",
+      args: [supply.sourceToken, supply.amount, "0", "0"],
+    };
+
+    sourceSpells.push({
+      connector: spellDataWithdraw.connector,
+      data: encodeConnectorMethod(spellDataWithdraw),
+    });
+
+    let spellDataBasicWithdraw = {
+      connector: "BASIC-A",
+      method: "withdraw",
+      args: [supply.sourceToken, supply.amount, dsaAddress, "0", "0"],
+    };
+
+    sourceSpells.push({
+      connector: spellDataBasicWithdraw.connector,
+      data: encodeConnectorMethod(spellDataBasicWithdraw),
+    });
+  }
+
+  const { data } = await contract.populateTransaction.sourceAction(
+    sourceSpells,
+    commonSpells,
+    position,
+    actionId,
+    sourceSender,
+    sourceDsaId,
+    targetDsaId,
+    sourceChainId,
+    targetChainId,
+    vnonce,
+    metadata
+  );
+
+  transactions.push({
+    to: interopAddress,
+    data: data!,
+    value: "0",
+    operation: OperationType.Call,
+  });
+
+  return { transactions, logs };
+}

package/src/gnosis/actions/aaveV3/target.ts

@@ -0,0 +1,142 @@
+import abi from "@/abi";
+import config from "@/config";
+import { addresses } from "@/constants";
+import { Transaction } from "@/db";
+import { JsonRpcRetryProvider } from "@/providers";
+import { InteropX } from "@/typechain";
+import { InstList } from "@/typechain/InstList";
+import { ChainId } from "@/types";
+import { encodeConnectorMethod, getContract, getRpcProviderUrl } from "@/utils";
+import { ethers } from "ethers";
+import { MetaTransaction, OperationType } from "ethers-multisend";
+
+
+export default async function (transaction: Transaction) {
+    const transactions: MetaTransaction[] = [];
+    const logs: any[] = [];
+
+    const {
+        sourceSpells,
+        position,
+        actionId,
+        sourceSender,
+        sourceDsaId,
+        targetDsaId,
+        sourceChainId,
+        targetChainId,
+        vnonce,
+        metadata,
+    } = transaction.validateEvent;
+
+    const targetChainProvider = new JsonRpcRetryProvider(
+        getRpcProviderUrl(targetChainId as ChainId)
+    );
+    const targetWallet = new ethers.Wallet(
+        config.privateKey,
+        targetChainProvider
+    );
+
+
+    const targetInstListContract = getContract<InstList>(
+        addresses[targetChainId].instList,
+        abi.instList,
+        targetChainProvider,
+    );
+
+    const targetDsaAddress = await targetInstListContract.accountAddr(targetDsaId)
+    const dsaAddress = addresses[targetChainId].dsaAddress;
+    const interopAddress = addresses[targetChainId].interopX;
+    const contract = getContract<InteropX>(
+        interopAddress,
+        abi.interopX,
+        targetWallet
+    );
+
+    const targetSpells: any[] = [];
+    const commonSpells: any[] = [];
+
+    for (const supplyToken of position.supply) {
+        let spellData = {
+            connector: "AAVE-V3-A",
+            method: "deposit",
+            args: [supplyToken.targetToken, supplyToken.amount, "0", "0"],
+        };
+
+        targetSpells.push({
+            connector: spellData.connector,
+            data: encodeConnectorMethod(spellData),
+        });
+
+        let spellDataBasicWithdraw = {
+            connector: "BASIC-A",
+            method: "withdraw",
+            args: [supplyToken.targetToken, supplyToken.amount, targetDsaAddress, "0", "0"],
+        };
+
+        commonSpells.push({
+            connector: spellDataBasicWithdraw.connector,
+            data: encodeConnectorMethod(spellDataBasicWithdraw),
+        });
+    }
+
+    for (const withdrawToken of position.withdraw) {
+
+        let spellData = {
+            connector: "AAVE-V3-A",
+            method: "borrow",
+            args: [
+                withdrawToken.targetToken,
+                withdrawToken.amount,
+                "2",
+                "0",
+                "0",
+            ],
+        };
+
+        targetSpells.push({
+            connector: spellData.connector,
+            data: encodeConnectorMethod(spellData),
+        });
+
+        let spellData2 = {
+            connector: "BASIC-A",
+            method: "withdraw",
+            args: [
+                withdrawToken.targetToken,
+                withdrawToken.amount,
+                dsaAddress,
+                "0",
+                "0",
+            ],
+        };
+
+        targetSpells.push({
+            connector: spellData.connector,
+            data: encodeConnectorMethod(spellData2),
+        });
+    }
+
+    const { data } = await contract.populateTransaction.targetAction(
+        sourceSpells,
+        targetSpells,
+        commonSpells,
+        position,
+        actionId,
+        sourceSender,
+        sourceDsaId,
+        targetDsaId,
+        sourceChainId,
+        targetChainId,
+        vnonce,
+        metadata
+    );
+
+    transactions.push({
+        to: interopAddress,
+        data: data!,
+        value: "0",
+        operation: OperationType.Call,
+    });
+
+    return { transactions, logs }
+}

package/src/gnosis/actions/index.ts

@@ -0,0 +1,7 @@
+import aaveV2 from "./aaveV2"
+import aaveV3 from "./aaveV3"
+
+export default {
+    'A:AAVE-V2:AAVE-V2': aaveV2,
+    'A:AAVE-V3:AAVE-V3': aaveV3,
+}

package/src/gnosis/index.ts

@@ -0,0 +1,19 @@
+import { Transaction } from "@/db";
+import { encodeMulti } from "ethers-multisend";
+import actions from "./actions";
+
+export const buildGnosisAction = async (transaction: Transaction, type: 'source' | 'target') => {
+    // type = type || (transaction.sourceStatus === 'success' ? 'target' : 'source')
+
+    if (actions.hasOwnProperty(transaction.actionId)) {
+
+        const { transactions, logs } = await actions[transaction.actionId](transaction, type);
+
+        return {
+            data: encodeMulti(transactions).data,
+            logs
+        };
+    }
+
+    throw new Error(`Unknown action: ${transaction.actionId}`);
+}