feat: improve detecting reverted txs, code tidying

Author: 0x31

packages/ren/src/gateway.ts

@@ -568,7 +568,6 @@ export class Gateway<
 
                 await transaction.initialize();
 
-                // Check if deposit has already been submitted.
                 this.eventEmitter.emit("transaction", transaction);
                 // this.deposits.set(deposit);
                 this.config.logger.debug("new deposit:", inputTx);

packages/ren/src/utils/defaultTransactionHandler.ts

@@ -39,17 +39,29 @@ const chainTransactionHandler = async (
                 }, retries);
                 break;
             case ChainTransactionStatus.Confirming:
-                await utils.tryNTimes(async (i: number) => {
-                    try {
-                        await tx.wait();
-                    } catch (error: unknown) {
-                        // Log error every 10 attempts.
-                        if ((i + 1) % 10 === 0) {
-                            console.error(error);
-                        }
-                        throw error;
-                    }
-                }, retries);
+                await new Promise((resolve, reject) =>
+                    resolve(
+                        utils.tryNTimes(async (i: number) => {
+                            try {
+                                await tx.wait();
+                            } catch (error: unknown) {
+                                if (
+                                    ErrorWithCode.isErrorWithCode(error) &&
+                                    error.code ===
+                                        RenJSError.CHAIN_TRANSACTION_REVERTED
+                                ) {
+                                    reject(error);
+                                    throw error;
+                                }
+                                // Log error every 10 attempts.
+                                if ((i + 1) % 10 === 0) {
+                                    console.error(error);
+                                }
+                                throw error;
+                            }
+                        }, retries),
+                    ),
+                );
                 break;
             case ChainTransactionStatus.Reverted:
                 throw new ErrorWithCode(

packages/utils/src/common.ts

@@ -42,7 +42,7 @@ export const decodeRenVMSelector = (
     };
 };
 
-const EMPTY_SIGNATURE =
+export const EMPTY_SIGNATURE =
     "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
 export const isEmptySignature = (sig: Uint8Array): boolean =>
     utils.toURLBase64(sig) === EMPTY_SIGNATURE;

packages/utils/src/txSubmitter.ts

@@ -1,3 +1,4 @@
+import { ErrorWithCode, RenJSError } from "./errors";
 import { isDefined, newPromiEvent } from "./internal/common";
 import { sleep } from "./internal/sleep";
 import { Chain, ChainTransaction, SyncOrPromise } from "./types/chain";
@@ -358,6 +359,16 @@ export class DefaultTxWaiter implements TxWaiter {
                         }
                     }
                 } catch (error: unknown) {
+                    this.updateProgress({
+                        ...this.progress,
+                        status: ChainTransactionStatus.Reverted,
+                    });
+                    if (
+                        ErrorWithCode.isErrorWithCode(error) &&
+                        error.code === RenJSError.CHAIN_TRANSACTION_REVERTED
+                    ) {
+                        throw error;
+                    }
                     console.error(error);
                 }
                 await sleep(15 * sleep.SECONDS);

packages/utils/src/types/chain.ts

@@ -96,6 +96,12 @@ export interface ChainCommon {
     /** Override the chain's provider. */
     provider?: any;
     withProvider?: (...providers: any[]) => SyncOrPromise<this>;
+    checkProviderNetwork?: () => SyncOrPromise<{
+        result: boolean;
+        actualNetworkId: string | number;
+        expectedNetworkId: string | number;
+        expectedNetworkLabel: string;
+    }>;
 
     /** Override the chain's signer. */
     signer?: any;

packages/utils/test/common.spec.ts

@@ -1,11 +1,8 @@
 import BigNumber from "bignumber.js";
-import chai, { expect } from "chai";
-import chaiAsPromised from "chai-as-promised";
+import { expect } from "chai";
 
 import { utils } from "../src/internal";
 
-chai.use(chaiAsPromised);
-
 describe("common utils", () => {
     context("sleep", () => {
         it("correct amount of time passes", async () => {

test/gateway.spec.ts

@@ -1,3 +1,4 @@
+import { Solana } from "@renproject/chains";
 import { getERC20Instance } from "@renproject/chains-ethereum/src/contracts";
 import BigNumber from "bignumber.js";
 import chai from "chai";
@@ -7,12 +8,14 @@ import {
     Arbitrum,
     Avalanche,
     BinanceSmartChain,
+    Catalog,
     Ethereum,
+    EthereumBaseChain,
     EVMParam,
+    Goerli,
     Polygon,
 } from "packages/chains/chains-ethereum/src";
 import { Filecoin } from "packages/chains/chains-filecoin/src";
-import { Solana } from "packages/chains/chains-solana/src";
 import { Terra } from "packages/chains/chains-terra/src";
 import RenJS from "packages/ren/src";
 import { GatewayParams } from "packages/ren/src/params";
@@ -436,36 +439,143 @@ describe("Gateway", () => {
         await defaultGatewayHandler(await renJS.gateway(gatewayParams));
     }).timeout(100000000000);
 
-    it("DAI/fromBinanceSmartChain", async () => {
+    it("USDT/toCatalog", async () => {
         const network = RenNetwork.Testnet;
 
-        const asset = Ethereum.assets.DAI;
-        const from = initializeChain(BinanceSmartChain, network);
-        const to = initializeChain(Ethereum, network);
+        const from = initializeChain(Goerli, network);
+        const catalog = initializeChain(Catalog, network);
+        const bsc = initializeChain(BinanceSmartChain, network);
+        const polygon = initializeChain(Polygon, network);
+        const renJS = new RenJS(network).withChains(
+            from,
+            catalog,
+            bsc,
+            polygon,
+        );
+        console.log(await from.signer!.getAddress());
 
-        const renJS = new RenJS(network).withChains(from, to);
+        console.log(
+            Goerli.assets.USDT,
+            (await from.getBalance(Goerli.assets.USDT))
+                .shiftedBy(-(await from.assetDecimals(Goerli.assets.USDT)))
+                .toFixed(),
+        );
+        console.log(
+            Goerli.assets.DAI,
+            (await from.getBalance(Goerli.assets.DAI))
+                .shiftedBy(-(await from.assetDecimals(Goerli.assets.DAI)))
+                .toFixed(),
+        );
+        console.log(
+            Goerli.assets.USDC,
+            (await from.getBalance(Goerli.assets.USDC))
+                .shiftedBy(-(await from.assetDecimals(Goerli.assets.USDC)))
+                .toFixed(),
+        );
 
-        const gatewayParams = {
-            asset,
-            from: from.Account({ amount: 0.5, convertUnit: true }),
-            to: to.Address("0x797522fb74d42bb9fbf6b76dea24d01a538d5d66"),
-        };
+        const options: Array<[string, EthereumBaseChain]> = [
+            // [Goerli.assets.USDT, catalog],
+            // [Goerli.assets.USDC, catalog],
+            // [Goerli.assets.DAI, catalog],
+            [Goerli.assets.USDT, bsc],
+            [Goerli.assets.USDC, bsc],
+            [Goerli.assets.DAI, bsc],
+            [Goerli.assets.USDT, polygon],
+            [Goerli.assets.USDC, polygon],
+            [Goerli.assets.DAI, polygon],
+        ];
+
+        for (const [asset, to] of options) {
+            // const asset = Ethereum.assets.USDT;
+            const decimals = await from.assetDecimals(asset);
+
+            const amount = 100.2;
+
+            const gatewayParams = {
+                asset,
+                from: from.Account({ amount, convertUnit: true }),
+                to: to.Address("0x5eb99e19183728404AaeBc8eEF47C085dBE86F54"),
+            };
 
-        await defaultGatewayHandler(await renJS.gateway(gatewayParams));
+            await defaultGatewayHandler(
+                await renJS.gateway(gatewayParams),
+                new BigNumber(amount).shiftedBy(decimals),
+            );
+
+            console.log(
+                asset,
+                "on",
+                to.chain,
+                (
+                    await to.getBalance(
+                        asset,
+                        "0x5eb99e19183728404AaeBc8eEF47C085dBE86F54",
+                    )
+                )
+                    .shiftedBy(-(await to.assetDecimals(asset)))
+                    .toFixed(),
+            );
+        }
     }).timeout(100000000000);
 
-    it("BTC/fromEthereum", async () => {
+    it("BTC/to catalog chains", async () => {
         const network = RenNetwork.Testnet;
 
-        const asset = Bitcoin.assets.BTC;
-        const from = initializeChain(Ethereum, network);
-        const to = initializeChain(Solana, network);
+        const from = initializeChain(Bitcoin, network);
+        const asset = from.assets.BTC;
+        const catalog = initializeChain(Catalog, network);
+        const bsc = initializeChain(BinanceSmartChain, network);
+        const polygon = initializeChain(Polygon, network);
+        const ethereum = initializeChain(Ethereum, network);
+        const renJS = new RenJS(network).withChains(
+            from,
+            catalog,
+            bsc,
+            polygon,
+            ethereum,
+        );
+
+        const options: EthereumBaseChain[] = [catalog, bsc, polygon, ethereum];
+
+        for (const to of options) {
+            // const asset = Ethereum.assets.USDT;
+
+            const gatewayParams = {
+                asset,
+                from: from.GatewayAddress(),
+                to: to.Address("0x5eb99e19183728404AaeBc8eEF47C085dBE86F54"),
+            };
+
+            await defaultGatewayHandler(await renJS.gateway(gatewayParams));
+
+            console.log(
+                asset,
+                "on",
+                to.chain,
+                (
+                    await to.getBalance(
+                        asset,
+                        "0x5eb99e19183728404AaeBc8eEF47C085dBE86F54",
+                    )
+                )
+                    .shiftedBy(-(await to.assetDecimals(asset)))
+                    .toFixed(),
+            );
+        }
+    }).timeout(100000000000);
+
+    it.only("REN/toSolana", async () => {
+        const network = RenNetwork.Testnet;
+
+        const asset = Ethereum.assets.REN;
+        const from = initializeChain(Solana, network);
+        const to = initializeChain(Ethereum, network);
 
         const renJS = new RenJS(network).withChains(from, to);
 
         const gatewayParams: GatewayParams = {
             asset,
-            from: from.Account({ amount: 1, convertUnit: true }),
+            from: from.Account({ amount: 95, convertUnit: true }),
             to: to.Account(),
         };
 

test/index.ts

@@ -1,25 +1,18 @@
 /* eslint-disable no-console */
 
-import { AbiCoder } from "ethers/lib/utils";
 import { Ethereum } from "packages/chains/chains-ethereum/src";
 import { BinanceSmartChain } from "packages/chains/chains/src";
 import RenJS from "packages/ren/src";
 import { RenNetwork } from "packages/utils";
 
-import { getEVMProvider } from "./utils/testUtils";
+import { initializeChain } from "./utils/testUtils";
 
 const network = RenNetwork.Testnet;
 
 const main = async () => {
     // Initialize Ethereum and BSC chains.
-    const ethereum = new Ethereum({
-        network,
-        ...getEVMProvider(Ethereum, network),
-    });
-    const bsc = new BinanceSmartChain({
-        network,
-        ...getEVMProvider(BinanceSmartChain, network),
-    });
+    const ethereum = initializeChain(Ethereum, network);
+    const bsc = initializeChain(BinanceSmartChain, network);
 
     // Create RenJS instance. NOTE - chains must now be linked to RenJS using
     // `withChains`.

test/simple.spec.ts

@@ -5,7 +5,7 @@ import chalk from "chalk";
 import { BinanceSmartChain } from "packages/chains/chains/src";
 import RenJS from "packages/ren/src";
 
-import { getEVMProvider } from "./utils/testUtils";
+import { initializeChain } from "./utils/testUtils";
 
 const network = RenNetwork.Testnet;
 
@@ -18,14 +18,8 @@ const network = RenNetwork.Testnet;
 
 describe("DAI/toBinanceSmartChain - simpler", () => {
     it("DAI/toBinanceSmartChain - simpler", async () => {
-        const ethereum = new Ethereum({
-            network,
-            ...getEVMProvider(Ethereum, network),
-        });
-        const bsc = new BinanceSmartChain({
-            network,
-            ...getEVMProvider(BinanceSmartChain, network),
-        });
+        const ethereum = initializeChain(Ethereum, network);
+        const bsc = initializeChain(BinanceSmartChain, network);
 
         const renJS = new RenJS(network).withChains(ethereum, bsc);
 

test/utils/defaultGatewayHandler.ts

@@ -6,6 +6,7 @@ import { printChain, sendFunds } from "./testUtils";
 
 export const defaultGatewayHandler = async (
     gateway: Gateway,
+    amount?: BigNumber | number | string,
     logger: Logger = console,
 ): Promise<void> => {
     const asset = gateway.params.asset;
@@ -29,7 +30,7 @@ export const defaultGatewayHandler = async (
         -decimalsOnFromChain,
     );
     const receivedAmount = gateway.fees
-        .estimateOutput(gateway.fees.minimumAmount)
+        .estimateOutput(amount || gateway.fees.minimumAmount)
         .shiftedBy(-decimalsOnFromChain);
 
     try {
@@ -117,7 +118,7 @@ export const defaultGatewayHandler = async (
                 gateway.gatewayAddress
             } (to receive at least ${receivedAmount.toFixed()})`,
         );
-        const SEND_FUNDS = false;
+        const SEND_FUNDS = true;
         if (SEND_FUNDS) {
             try {
                 await sendFunds(