@instadapp/interop-x 0.0.0-dev.f39d622 → 0.0.0-dev.f45bd03

package/src/typechain/factories/index.ts

@@ -2,6 +2,7 @@
 /* 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";

package/src/typechain/index.ts

@@ -2,6 +2,7 @@
 /* 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";
@@ -9,6 +10,7 @@ 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";

package/src/utils/gnosis.ts

@@ -1,6 +1,8 @@
 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 {
@@ -20,22 +22,23 @@ export const buildSignatureBytes = (signatures: Signature[]): string => {
   return signatureBytes;
 };
 
-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 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 = {
@@ -43,20 +46,24 @@ export const signGnosisSafeTx = async (
     chainId,
   };
 
-  const types = {
-    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" },
-    ],
-  };
+  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,
@@ -72,7 +79,33 @@ export const signGnosisSafeTx = async (
     value,
   };
 
-  return await signer._signTypedData(domain, types, message);
+  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 (
@@ -120,4 +153,14 @@ export const generateGnosisTransaction = async (
   }
 
   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);
+}

package/src/utils/validate.ts

@@ -7,6 +7,8 @@ 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";
 
 export const validateChains = ({ sourceChainId, targetChainId }) => {
     if (!sourceChainId) {
@@ -32,12 +34,12 @@ export const validateChains = ({ sourceChainId, targetChainId }) => {
 
 
 export const validateSourceLiquidity = async ({
-    position,
+    position = null as unknown as IPosition,
     sourceChainId,
     isSupply = false,
-    sourceProvider = null as unknown as ethers.providers.JsonRpcProvider,
+    sourceProvider = null as unknown as JsonRpcRetryProvider,
 }) => {
-    sourceProvider = sourceProvider || new ethers.providers.JsonRpcProvider(getRpcProviderUrl(sourceChainId));
+    sourceProvider = sourceProvider || new JsonRpcRetryProvider(getRpcProviderUrl(sourceChainId));
 
 
     const sourceBalanceResolverContract = getContract(
@@ -46,9 +48,7 @@ export const validateSourceLiquidity = async ({
         sourceProvider,
     )
 
-    const srcBalance = await sourceBalanceResolverContract.methods
-        .checkLiquidity(position, addresses[sourceChainId].interopX, isSupply, false)
-        .call();
+    const srcBalance = await sourceBalanceResolverContract.checkLiquidity(position, addresses[sourceChainId].interopX, isSupply, false)
 
     if (!srcBalance.isOk) {
 
@@ -67,11 +67,11 @@ export const validateSourceLiquidity = async ({
 };
 
 export const validateTargetLiquidity = async ({
-    position,
+    position = null as unknown as IPosition,
     targetChainId,
-    targetProvider = null as unknown as ethers.providers.JsonRpcProvider,
+    targetProvider = null as unknown as JsonRpcRetryProvider,
 }) => {
-    targetProvider = targetProvider || new ethers.providers.JsonRpcProvider(getRpcProviderUrl(targetChainId));
+    targetProvider = targetProvider || new JsonRpcRetryProvider(getRpcProviderUrl(targetChainId));
 
 
     const sourceBalanceResolverContract = getContract(
@@ -80,9 +80,7 @@ export const validateTargetLiquidity = async ({
         targetProvider,
     )
 
-    const targetBalance = await sourceBalanceResolverContract.methods
-        .checkLiquidity(position, addresses[targetChainId].interopX, true, true)
-        .call();
+    const targetBalance = await sourceBalanceResolverContract.checkLiquidity(position, addresses[targetChainId].interopX, true, true)
 
     if (!targetBalance.isOk) {
 
@@ -103,7 +101,7 @@ export const validateTargetLiquidity = async ({
 
 const mapTokenAddressToMainnetToken = (
     address: string,
-    targetChainId: number|string
+    targetChainId: number | string
 ) => {
     targetChainId = String(targetChainId);
     const token = tokens[targetChainId].find(
@@ -122,9 +120,9 @@ const mapTokenAddressToMainnetToken = (
 };
 
 export const validateLiquidityCap = async (
-    position: any,
-    sourceChainId: number|string,
-    targetChainId: number|string
+    position: IPosition,
+    sourceChainId: number | string,
+    targetChainId: number | string
 ) => {
     const cap = capPerChain[targetChainId] || 1_000_000;
     const mainnetPrices = Prices.getMainnetPrices();
@@ -132,9 +130,9 @@ export const validateLiquidityCap = async (
 
     let total = new BigNumber(0);
 
-    const supplyPosition = position[0];
+    const supplyPosition = position.supply;
 
-    for (const [srcTokenAddress, tokenAddress, amount] of supplyPosition) {
+    for (const { sourceToken: srcTokenAddress, targetToken: tokenAddress, amount } of supplyPosition) {
         let tokenPrice;
         let token;
 
@@ -160,7 +158,7 @@ export const validateLiquidityCap = async (
         }
 
 
-        total = total.plus((tokenPrice * amount) / 10 ** token.decimals);
+        total = total.plus((tokenPrice * Number(amount)) / 10 ** token.decimals);
     }
 
     if (total.isGreaterThan(cap)) {