@instadapp/interop-x 0.0.0-dev.051cd4e

package/src/typechain/factories/index.ts

@@ -0,0 +1,7 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export { Erc20__factory } from "./Erc20__factory";
+export { GnosisSafe__factory } from "./GnosisSafe__factory";
+export { InteropBridgeToken__factory } from "./InteropBridgeToken__factory";
+export { InteropXGateway__factory } from "./InteropXGateway__factory";

package/src/typechain/index.ts

@@ -0,0 +1,12 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { Erc20 } from "./Erc20";
+export type { GnosisSafe } from "./GnosisSafe";
+export type { InteropBridgeToken } from "./InteropBridgeToken";
+export type { InteropXGateway } from "./InteropXGateway";
+export * as factories from "./factories";
+export { Erc20__factory } from "./factories/Erc20__factory";
+export { GnosisSafe__factory } from "./factories/GnosisSafe__factory";
+export { InteropBridgeToken__factory } from "./factories/InteropBridgeToken__factory";
+export { InteropXGateway__factory } from "./factories/InteropXGateway__factory";

package/src/types.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from 'events'
+import { IPeerInfo } from '@/net'
+
+/**
+ * Types for the central event bus, emitted
+ * by different components of the client.
+ */
+export enum Event {
+  PEER_CONNECTED = 'peer:connected',
+  PEER_DISCONNECTED = 'peer:disconnected',
+  PEER_ERROR = 'peer:error',
+  POOL_PEER_ADDED = 'pool:peer:added',
+  POOL_PEER_REMOVED = 'pool:peer:removed',
+  POOL_PEER_BANNED = 'pool:peer:banned',
+}
+export interface EventParams {
+  [Event.PEER_CONNECTED]: [connectedPeer: IPeerInfo]
+  [Event.PEER_DISCONNECTED]: [disconnectedPeer: IPeerInfo]
+  [Event.PEER_ERROR]: [error: Error, peerCausingError: IPeerInfo]
+  [Event.POOL_PEER_ADDED]: [addedPeer: IPeerInfo]
+  [Event.POOL_PEER_REMOVED]: [removedPeer: IPeerInfo]
+  [Event.POOL_PEER_BANNED]: [bannedPeer: IPeerInfo]
+}
+
+export declare interface EventBus<T extends Event> {
+  emit(event: T, ...args: EventParams[T]): boolean
+  on(event: T, listener: (...args: EventParams[T]) => void): this
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export class EventBus<T extends Event> extends EventEmitter { }
+export type EventBusType = EventBus<Event.PEER_CONNECTED> &
+  EventBus<Event.PEER_DISCONNECTED> &
+  EventBus<Event.POOL_PEER_ADDED> &
+  EventBus<Event.POOL_PEER_REMOVED> &
+  EventBus<Event.POOL_PEER_BANNED>
+
+
+export type ChainId = 1 | 137 | 43114;

package/src/utils/index.ts

@@ -0,0 +1,307 @@
+/**
+ * @module util
+ */
+import axios from 'axios'
+import axiosRetry from "axios-retry";
+import { addresses, itokens, tokens } from '@/constants';
+import { ChainId } from '@/types'
+import { ethers } from 'ethers';
+import { encodeMulti, MetaTransaction, OperationType } from 'ethers-multisend';
+import { Transaction } from '@/db';
+import config from '@/config';
+import abi from '@/abi';
+import { InteropBridgeToken, InteropXGateway } from '@/typechain';
+
+export const http = axios.create();
+
+axiosRetry(http, { retries: 3, retryDelay: axiosRetry.exponentialDelay });
+
+
+export function short(buffer: Buffer): string {
+  return buffer.toString('hex').slice(0, 8) + '...'
+}
+
+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 }) => {
+  const gnosisSafe = addresses[chainId].gnosisSafe;
+
+  const domain = {
+    verifyingContract: gnosisSafe,
+    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' },
+    ],
+  };
+
+  const message = {
+    baseGas,
+    data,
+    gasPrice,
+    gasToken,
+    nonce: Number(nonce),
+    operation,
+    refundReceiver,
+    safeAddress: gnosisSafe,
+    safeTxGas: String(safeTxGas),
+    to,
+    value,
+  };
+
+  return await signer._signTypedData(domain, types, message)
+};
+
+export const getRpcProviderUrl = (chainId: ChainId) => {
+  switch (chainId) {
+    case 1:
+      return 'https://rpc.instadapp.io/mainnet';
+    case 137:
+      return 'https://rpc.instadapp.io/polygon';
+    case 43114:
+      return 'https://rpc.instadapp.io/avalanche';
+    default:
+      throw new Error(`Unknown chainId: ${chainId}`);
+  }
+}
+
+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;
+};
+
+/**
+ * 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>
+}
+
+
+export const generateInteropTransactionHash = (data: { action: string, submitTransactionHash: string, sourceChainId: string | number, targetChainId: string | number }) => {
+  return ethers.utils.solidityKeccak256(['string', 'string', 'string', 'string'], [
+    String(data.action),
+    String(data.submitTransactionHash),
+    String(data.sourceChainId),
+    String(data.targetChainId),
+  ]);
+}
+
+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: ${transaction.action}`)
+  }
+
+  if (transaction.action === 'deposit' && transaction.sourceStatus === 'pending') {
+    throw Error('Cannot build data for pending deposit transaction');
+  }
+
+  if (!transaction.submitEvent) {
+    throw Error('Cannot build data for transaction without submitEvent');
+  }
+
+
+  const token = tokens[transaction.sourceChainId].find(token => token.address.toLowerCase() === transaction.submitEvent.token.toLowerCase());
+
+  if (!token) {
+    throw Error('Cannot build data for transaction without token');
+  }
+
+  const itoken = itokens[transaction.targetChainId].find(itoken => itoken.symbol.toLowerCase() === token.symbol.toLowerCase());
+
+  if (!itoken) {
+    throw Error('Cannot build data for transaction without itoken');
+  }
+
+  const targetChainProvider = new ethers.providers.JsonRpcProvider(getRpcProviderUrl(transaction.targetChainId as ChainId));
+  const targetWallet = new ethers.Wallet(config.privateKey, targetChainProvider);
+  const interopBridgeContract = getContract<InteropBridgeToken>(itoken.address, abi.interopBridgeToken, targetWallet);
+
+  const { data } = await interopBridgeContract.populateTransaction.mint(
+    transaction.submitEvent.user,
+    ethers.BigNumber.from(transaction.submitEvent.amount.toString()),
+    ethers.BigNumber.from(transaction.submitEvent.sourceChainId.toString()),
+    transaction.submitTransactionHash,
+  );
+
+  transactions.push({
+    to: itoken.address,
+    data: data!,
+    value: '0',
+    operation: OperationType.Call,
+  });
+
+  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;
+    },
+  });
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2017",
+    "noImplicitAny": false,
+    "noUnusedLocals": false,
+    "strictNullChecks": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "sourceMap": false,
+    "noEmit": false,
+    "outDir": "dist",
+    "baseUrl": "src",
+    "paths": { 
+      "@/*" : ["./*" ]
+    },
+    "typeRoots": [
+      "./node_modules/@types",
+      "./@types"
+    ]
+  },
+  "include": [
+    "src/**/*",
+  ]
+}