@instadapp/interop-x 0.0.0-dev.8a0297a → 0.0.0-dev.8a917f1

package/src/utils/index.ts

@@ -10,13 +10,25 @@ 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();
 
 axiosRetry(http, { retries: 3, retryDelay: axiosRetry.exponentialDelay });
 
 
+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) + '...'
 }
@@ -76,11 +88,11 @@ export const signGnosisSafeTx = async ({
 export const getRpcProviderUrl = (chainId: ChainId) => {
   switch (chainId) {
     case 1:
-      return 'https://rpc.instadapp.io/mainnet';
+      return 'https://rpc.ankr.com/eth';
     case 137:
-      return 'https://rpc.instadapp.io/polygon';
+      return 'https://rpc.ankr.com/polygon';
     case 43114:
-      return 'https://rpc.instadapp.io/avalanche';
+      return 'https://rpc.ankr.com/avalanche';
     default:
       throw new Error(`Unknown chainId: ${chainId}`);
   }
@@ -136,10 +148,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') {
@@ -169,9 +192,9 @@ export const buildDataForTransaction = async (transaction: Transaction, type?: '
 
   const { data } = await interopBridgeContract.populateTransaction.mint(
     transaction.submitEvent.user,
-    ethers.BigNumber.from(transaction.submitEvent.amount),
-    transaction.sourceChainId,
-    transaction.sourceTransactionHash,
+    ethers.BigNumber.from(transaction.submitEvent.amount.toString()),
+    ethers.BigNumber.from(transaction.submitEvent.sourceChainId.toString()),
+    transaction.submitTransactionHash,
   );
 
   transactions.push({
@@ -184,6 +207,58 @@ 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, sourceChainId, targetChainId, itoken: itokenAddress } = transaction.submitEvent;
+
+  const itoken = itokens[sourceChainId].find(token => token.address.toLowerCase() === itokenAddress.toLowerCase());
+
+  if (!itoken) {
+    throw Error('Cannot build data for transaction without itoken');
+  }
+
+  const token = tokens[targetChainId].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(targetChainId as ChainId));
+  const targetWallet = new ethers.Wallet(config.privateKey, targetChainProvider);
+  const gatewayAddress = addresses[targetChainId].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(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) {
@@ -196,15 +271,21 @@ export function getContract<TContract extends ethers.Contract>(address: string,
     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)) {
+      if (typeof value === 'function' && (contract.functions.hasOwnProperty(prop) || ['queryFilter'].includes(String(prop)))) {
         return async (...args: any[]) => {
           try {
-            return await value(...args);
+            return await value.bind(contract)(...args);
           } catch (error) {
             throw new Error(`Error calling "${String(prop)}" on "${address}": ${error.reason || error.message}`)
           }
@@ -222,7 +303,7 @@ export function getContract<TContract extends ethers.Contract>(address: string,
             if (typeof value === 'function') {
               return async (...args: any[]) => {
                 try {
-                  return await value(...args);
+                  return await value.bind(contract)(...args);
                 } catch (error) {
                   throw new Error(`Error calling "${String(prop)}" using "${parentProp}" on "${address}": ${error.reason || error.message}`)
                 }