Peter/feat dry running (#1499)

* chore: update monetary to latest 0.7.3

* feat(transaction): dry-run transaction before submission and revert execution if dry-running fails

* test: mock submittable extrinsic

* refactor: rename to dryRun and document functionality

* refactor: move submission code to separate folder

src/hooks/transaction/hooks/use-transaction.ts

@@ -9,6 +9,7 @@ import { useSubstrate } from '@/lib/substrate';
 import { useGetLiquidityPools } from '../../api/amm/use-get-liquidity-pools';
 import { useGetBalances } from '../../api/tokens/use-get-balances';
 import { getExtrinsic, getStatus } from '../extrinsics';
+import { submitTransaction } from '../submission/submit';
 import { Transaction, TransactionActions } from '../types';
 import {
   TransactionResult,
@@ -21,7 +22,6 @@ import {
 } from '../types/hook';
 import { wrapWithTxFeeSwap } from '../utils/fee';
 import { getActionData, getAmountWithFeeDeducted } from '../utils/params';
-import { submitTransaction } from '../utils/submit';
 import { FeeEstimateResult, useFeeEstimate } from './use-fee-estimate';
 import { useTransactionNotifications } from './use-transaction-notifications';
 

src/hooks/transaction/submission/dry-run.ts

@@ -0,0 +1,36 @@
+import { SubmittableExtrinsic } from '@polkadot/api/types';
+
+import { getErrorMessage } from './error';
+
+/**
+ * Dry-run signed submittable extrinsic if dry-running is enabled on RPC node.
+ *
+ * @throws If extrinsic execution failed during dry running.
+ * @param signedExtrinsic Extrinsic to be dry run.
+ * @returns {SubmittableExtrinsic} Dry-ran extrinsic.
+ */
+
+const dryRun = async (signedExtrinsic: SubmittableExtrinsic<'promise'>): Promise<SubmittableExtrinsic<'promise'>> => {
+  // Dry-run if enabled on RPC node.
+  // Source: Polkadot.js, https://github.com/polkadot-js/api/blob/319535a1e938e89522ff18ef2d1cef66a5af597c/packages/api/src/submittable/createClass.ts#L110
+  if (signedExtrinsic.hasDryRun) {
+    const dryRunResult = await window.bridge.api.rpc.system.dryRun(signedExtrinsic.toHex());
+
+    // If dry-running fails, code execution throws and extrinsic is not submitted.
+    if (dryRunResult.isErr) {
+      const error = dryRunResult.asErr;
+      const errMessage = error.toString();
+      throw new Error(errMessage);
+    }
+
+    // Handle dry-run result nested error.
+    if (dryRunResult.isOk && dryRunResult.asOk.isErr) {
+      const error = dryRunResult.asOk.asErr;
+      const errMessage = getErrorMessage(window.bridge.api, error);
+      throw new Error(errMessage);
+    }
+  }
+  return signedExtrinsic;
+};
+
+export { dryRun };

src/hooks/transaction/submission/error.ts

@@ -0,0 +1,23 @@
+import { ApiPromise } from '@polkadot/api';
+import { DispatchError } from '@polkadot/types/interfaces';
+
+const getErrorMessage = (api: ApiPromise, dispatchError: DispatchError): string => {
+  const { isModule, asModule, isBadOrigin } = dispatchError;
+
+  // Runtime error in one of the parachain modules
+  if (isModule) {
+    // for module errors, we have the section indexed, lookup
+    const decoded = api.registry.findMetaError(asModule);
+    const { docs, name, section } = decoded;
+    return `The error code is ${section}.${name}. ${docs.join(' ')}.`;
+  }
+
+  // Bad origin
+  if (isBadOrigin) {
+    return `The error is caused by using an incorrect account. The error code is BadOrigin ${dispatchError}.`;
+  }
+
+  return `The error is ${dispatchError}.`;
+};
+
+export { getErrorMessage };

src/hooks/transaction/utils/submit.ts → src/hooks/transaction/submission/submit.ts

@@ -1,12 +1,13 @@
 import { ExtrinsicData } from '@interlay/interbtc-api';
 import { ApiPromise } from '@polkadot/api';
 import { AddressOrPair, SubmittableExtrinsic } from '@polkadot/api/types';
-import { DispatchError } from '@polkadot/types/interfaces';
 import { ExtrinsicStatus } from '@polkadot/types/interfaces/author';
 import { ISubmittableResult } from '@polkadot/types/types';
 
 import { TransactionResult } from '../hooks/use-transaction';
 import { TransactionEvents } from '../types';
+import { dryRun } from './dry-run';
+import { getErrorMessage } from './error';
 
 type HandleTransactionResult = { result: ISubmittableResult; unsubscribe: () => void };
 
@@ -23,9 +24,12 @@ const handleTransaction = async (
 
   return new Promise<HandleTransactionResult>((resolve, reject) => {
     let unsubscribe: () => void;
-
     (extrinsicData.extrinsic as SubmittableExtrinsic<'promise'>)
-      .signAndSend(account, { nonce: -1 }, callback)
+      // Extrinsic is signed at first and then we use the same signed extrinsic
+      // for dry-running and submission.
+      .signAsync(account, { nonce: -1 })
+      .then(dryRun)
+      .then((signedExtrinsic) => signedExtrinsic.send(callback))
       .then((unsub) => (unsubscribe = unsub))
       .catch((error) => reject(error));
 
@@ -48,25 +52,6 @@ const handleTransaction = async (
   });
 };
 
-const getErrorMessage = (api: ApiPromise, dispatchError: DispatchError) => {
-  const { isModule, asModule, isBadOrigin } = dispatchError;
-
-  // Runtime error in one of the parachain modules
-  if (isModule) {
-    // for module errors, we have the section indexed, lookup
-    const decoded = api.registry.findMetaError(asModule);
-    const { docs, name, section } = decoded;
-    return `The error code is ${section}.${name}. ${docs.join(' ')}.`;
-  }
-
-  // Bad origin
-  if (isBadOrigin) {
-    return `The error is caused by using an incorrect account. The error code is BadOrigin ${dispatchError}.`;
-  }
-
-  return `The error is ${dispatchError}.`;
-};
-
 /**
  * Handles transaction submittion and error
  * @param {ApiPromise} api polkadot api wrapper

src/test/mocks/@interlay/interbtc-api/extrinsic.ts

@@ -3,14 +3,17 @@ import { SubmittableExtrinsic } from '@polkadot/api/types';
 import { ISubmittableResult } from '@polkadot/types/types';
 
 const EXTRINSIC: SubmittableExtrinsic<'promise', ISubmittableResult> = ({
-  signAndSend: jest.fn().mockImplementation(async (_a, _b, cb) => {
-    return new Promise((resolve) => {
-      resolve(jest.fn());
+  signAsync: jest.fn().mockResolvedValue({
+    send: jest.fn().mockImplementation(async (callback) => {
+      return new Promise((resolve) => {
+        resolve(jest.fn());
 
-      setTimeout(() => {
-        cb({ status: { isReady: true, isInBlock: true, isFinalized: true, type: 'Finalized' } });
-      }, 1);
-    });
+        setTimeout(() => {
+          callback({ status: { isReady: true, isInBlock: true, isFinalized: true, type: 'Finalized' } });
+        }, 1);
+      });
+    }),
+    hadDryRun: false
   })
 } as unknown) as SubmittableExtrinsic<'promise', ISubmittableResult>;