@instadapp/interop-x 0.0.0-dev.7a02577 → 0.0.0-dev.80dece2

package/src/utils/index.ts

@@ -10,7 +10,7 @@ import { encodeMulti, MetaTransaction, OperationType } from 'ethers-multisend';
 import { Transaction } from '@/db';
 import config from '@/config';
 import abi from '@/abi';
-import { InteropBridgeToken } from '@/typechain';
+import { InteropBridgeToken, InteropXGateway } from '@/typechain';
 
 export const http = axios.create();
 
@@ -136,10 +136,21 @@ export const generateInteropTransactionHash = (data: { action: string, submitTra
 export const buildDataForTransaction = async (transaction: Transaction, type?: 'source' | 'target') => {
   type = type || transaction.sourceStatus === 'pending' ? 'source' : 'target';
 
+  switch (transaction.action) {
+    case "deposit":
+      return await buildDepositDataForTransaction(transaction, type);
+    case "withdraw":
+      return await buildWithdrawDataForTransaction(transaction, type);
+    default:
+      throw new Error(`Unknown action: ${transaction.action}`);
+  }
+}
+
+export const buildDepositDataForTransaction = async (transaction: Transaction, type: 'source' | 'target') => {
   const transactions: MetaTransaction[] = [];
 
-  if(transaction.action != 'deposit') {
-    throw new Error('Invalid action');
+  if (transaction.action !== 'deposit') {
+    throw new Error(`Invalid action: ${transaction.action}`)
   }
 
   if (transaction.action === 'deposit' && transaction.sourceStatus === 'pending') {
@@ -165,13 +176,13 @@ export const buildDataForTransaction = async (transaction: Transaction, type?: '
 
   const targetChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(transaction.targetChainId as ChainId));
   const targetWallet = new ethers.Wallet(config.privateKey, targetChainProvider);
-  const interopBridgeContract = new ethers.Contract(itoken.address, abi.interopBridgeToken, targetWallet) as InteropBridgeToken;
+  const interopBridgeContract = getContract<InteropBridgeToken>(itoken.address, abi.interopBridgeToken, targetWallet);
 
   const { data } = await interopBridgeContract.populateTransaction.mint(
-    transaction.submitEvent.to,
-    transaction.submitEvent.amount,
-    transaction.sourceChainId,
-    transaction.sourceTransactionHash,
+    transaction.submitEvent.user,
+    ethers.BigNumber.from(transaction.submitEvent.amount.toString()),
+    ethers.BigNumber.from(transaction.submitEvent.sourceChainId.toString()),
+    transaction.submitTransactionHash,
   );
 
   transactions.push({
@@ -183,3 +194,114 @@ export const buildDataForTransaction = async (transaction: Transaction, type?: '
 
   return encodeMulti(transactions).data
 }
+
+export const buildWithdrawDataForTransaction = async (transaction: Transaction, type: 'source' | 'target') => {
+  const transactions: MetaTransaction[] = [];
+
+  if (transaction.action !== 'withdraw') {
+    throw new Error(`Invalid action: ${transaction.action}`)
+  }
+
+  if (transaction.action === 'withdraw' && transaction.sourceStatus === 'pending') {
+    throw Error('Cannot build data for pending withdraw transaction');
+  }
+
+  if (!transaction.submitEvent) {
+    throw Error('Cannot build data for transaction without submitEvent');
+  }
+
+  const { to, amount, chainId, itoken: itokenAddress } = transaction.submitEvent;
+
+  const itoken = itokens[transaction.sourceChainId].find(token => token.address.toLowerCase() === itokenAddress.toLowerCase());
+
+  if (!itoken) {
+    throw Error('Cannot build data for transaction without itoken');
+  }
+
+  const token = tokens[chainId].find(t => t.symbol.toLowerCase() === itoken.symbol.toLowerCase());
+
+  if (!token) {
+    throw Error('Cannot build data for transaction without token');
+  }
+
+  const targetChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(transaction.targetChainId as ChainId));
+  const targetWallet = new ethers.Wallet(config.privateKey, targetChainProvider);
+  const gatewayAddress = addresses[chainId].interopXGateway;
+  const interopBridgeContract = getContract<InteropXGateway>(gatewayAddress, abi.interopXGateway, targetWallet);
+
+  const { data } = await interopBridgeContract.populateTransaction.systemWithdraw(
+    ethers.BigNumber.from(amount.toString()),
+    to,
+    token.address,
+    ethers.BigNumber.from(transaction.sourceChainId.toString()),
+    transaction.submitTransactionHash,
+  );
+
+  transactions.push({
+    to: gatewayAddress,
+    data: data!,
+    value: '0',
+    operation: OperationType.Call,
+  });
+
+  return encodeMulti(transactions).data
+}
+
+
+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)))) {
+        return async (...args: any[]) => {
+          try {
+            return await value.bind(contract)(...args);
+          } catch (error) {
+            throw new Error(`Error calling "${String(prop)}" on "${address}": ${error.reason || error.message}`)
+          }
+        }
+      }
+
+
+      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 value.bind(contract)(...args);
+                } catch (error) {
+                  throw new Error(`Error calling "${String(prop)}" using "${parentProp}" on "${address}": ${error.reason || error.message}`)
+                }
+              }
+            }
+          }
+        })
+      }
+
+      return value;
+    },
+  });
+}