Implement transaction/dry-run

openapi/openapi-proposal.yaml

@@ -351,6 +351,10 @@ paths:
       responses:
         "200":
           description: successful operation
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/TransactionDryRun'
         "500":
           description: failed to dry-run transaction
           content:
@@ -1737,6 +1741,42 @@ components:
           items:
             type: string
             format: ss58
+    TransactionDryRun:
+      type: object
+      properties:
+        resultType:
+          type: string
+          enum:
+          - DispatchOutcome
+          - TransactionValidityError
+          description: Either `DispatchOutcome` if the transaction is valid or `TransactionValidityError` if the result is invalid.
+        result:
+          type: string
+          enum:
+          - Ok
+          - CannotLookup
+          - NoUnsignedValidator
+          - Custom(u8)
+          - Call
+          - Payment
+          - Future
+          - Stale
+          - BadProof
+          - AncientBirthBlock
+          - ExhaustsResources
+          - BadMandatory
+          - MandatoryDispatch
+          description: 'If there was an error it will be the cause of the error. If the
+            transaction executed correctly it will be `Ok: []`'
+        validityErrorType:
+          type: string
+          enum:
+          - InvalidTransaction
+          - UnknownTransaction
+      description: >-
+        References:
+        - `UnknownTransaction`: https://crates.parity.io/sp_runtime/transaction_validity/enum.UnknownTransaction.html
+        - `InvalidTransaction`: https://crates.parity.io/sp_runtime/transaction_validity/enum.InvalidTransaction.html
     Transaction:
       type: object
       properties:

src/controllers/transaction/TransactionDryRunController.ts

@@ -0,0 +1,41 @@
+import { ApiPromise } from '@polkadot/api';
+import { BadRequest } from 'http-errors';
+
+import { TransactionDryRunService } from '../../services';
+import { IPostRequestHandler, ITx } from '../../types/requests';
+import AbstractController from '../AbstractController';
+
+export default class TransactionDryRunController extends AbstractController<
+	TransactionDryRunService
+> {
+	constructor(api: ApiPromise) {
+		super(api, '/transaction/dry-run', new TransactionDryRunService(api));
+		this.initRoutes();
+	}
+
+	protected initRoutes(): void {
+		this.router.post(
+			this.path,
+			TransactionDryRunController.catchWrap(this.dryRunTransaction)
+		);
+	}
+
+	private dryRunTransaction: IPostRequestHandler<ITx> = async (
+		{ body: { tx }, query: { at } },
+		res
+	): Promise<void> => {
+		if (!tx) {
+			throw new BadRequest('Missing field `tx` on request body.');
+		}
+
+		const hash =
+			typeof at === 'string'
+				? await this.getHashForBlock(at)
+				: await this.api.rpc.chain.getFinalizedHead();
+
+		TransactionDryRunController.sanitizedSend(
+			res,
+			await this.service.dryRuntExtrinsic(hash, tx)
+		);
+	};
+}

src/controllers/transaction/index.ts

@@ -1,3 +1,4 @@
 export { default as TransactionFeeEstimate } from './TransactionFeeEstimateController';
 export { default as TransactionSubmit } from './TransactionSubmitController';
 export { default as TransactionMaterial } from './TransactionMaterialController';
+export { default as TransactionDryRun } from './TransactionDryRunController';

src/main.ts

@@ -80,6 +80,7 @@ async function main() {
 	const txArtifactsController = new controllers.TransactionMaterial(api);
 	const txFeeEstimateController = new controllers.TransactionFeeEstimate(api);
 	const txSubmitController = new controllers.TransactionSubmit(api);
+	const transactionDryRunController = new controllers.TransactionDryRun(api);
 
 	// Create our App
 	const app = new App({
@@ -101,6 +102,7 @@ async function main() {
 			txArtifactsController,
 			txFeeEstimateController,
 			txSubmitController,
+			transactionDryRunController,
 		],
 		postMiddleware: [
 			middleware.txError,

src/services/transaction/TransactionDryRunService.ts

@@ -0,0 +1,83 @@
+import { BlockHash } from '@polkadot/types/interfaces';
+
+import {
+	ITransactionDryRun,
+	TransactionResultType,
+	ValidityErrorType,
+} from '../../types/responses';
+import { AbstractService } from '../AbstractService';
+import { extractCauseAndStack } from './extractCauseAndStack';
+
+/**
+ * Dry run an extrinsic.
+ *
+ * Returns:
+ * - `at`:
+ * 		- `hash`: The block's hash.
+ * 		- `height`: The block's height.
+ * - `dryRunResult`:
+ * 		- `resultType`: Either `DispatchOutcome` if the construction is valid
+ * 			or `TransactionValidityError` if the transaction has invalid construction.
+ * 		- `result`: If there was an error it will be the cause of the error. If the
+ * 			transaction executed correctly it will be `Ok: []`.
+ * 		- `validityErrorType`: Only present if the `resultType` is
+ * 			`TransactionValidityError`. Either `InvalidTransaction` or `UnknownTransaction`.
+ *
+ * References:
+ * - `UnknownTransaction`: https://crates.parity.io/sp_runtime/transaction_validity/enum.UnknownTransaction.html
+ * - `InvalidTransaction`: https://crates.parity.io/sp_runtime/transaction_validity/enum.InvalidTransaction.html
+ */
+export class TransactionDryRunService extends AbstractService {
+	async dryRuntExtrinsic(
+		hash: BlockHash,
+		extrinsic: string
+	): Promise<ITransactionDryRun> {
+		const api = await this.ensureMeta(hash);
+
+		try {
+			const [applyExtrinsicResult, { number }] = await Promise.all([
+				api.rpc.system.dryRun(extrinsic, hash),
+				api.rpc.chain.getHeader(hash),
+			]);
+
+			let dryRunResult;
+			if (applyExtrinsicResult.isOk) {
+				dryRunResult = {
+					resultType: TransactionResultType.DispatchOutcome,
+					result: applyExtrinsicResult.asOk,
+				};
+			} else {
+				const { asError } = applyExtrinsicResult;
+				dryRunResult = {
+					resultType: TransactionResultType.TransactionValidityError,
+					result: asError.isInvalid
+						? asError.asInvalid
+						: asError.asUnknown,
+					validityErrorType: asError.isInvalid
+						? ValidityErrorType.Invalid
+						: ValidityErrorType.Unknown,
+				};
+			}
+
+			return {
+				at: {
+					hash,
+					height: number.unwrap().toString(10),
+				},
+				dryRunResult,
+			};
+		} catch (err) {
+			const { cause, stack } = extractCauseAndStack(err);
+
+			throw {
+				at: {
+					hash,
+				},
+				error: 'Unable to dry-run transaction',
+				extrinsic,
+				cause,
+				stack,
+			};
+		}
+	}
+}

src/services/transaction/index.ts

@@ -1,3 +1,4 @@
 export * from './TransactionSubmitService';
 export * from './TransactionFeeEstimateService';
 export * from './TransactionMaterialService';
+export * from './TransactionDryRunService';

src/types/responses/TransactionDryRun.ts

@@ -0,0 +1,31 @@
+import {
+	DispatchOutcome,
+	InvalidTransaction,
+	UnknownTransaction,
+} from '@polkadot/types/interfaces';
+
+import { IAt } from '.';
+
+export enum TransactionResultType {
+	TransactionValidityError = 'TransactionValidityError',
+	DispatchOutcome = 'DispatchOutcome',
+}
+
+export enum ValidityErrorType {
+	Invalid = 'InvalidTransaction',
+	Unknown = 'UnknownTransaction',
+}
+
+export type TransactionResult =
+	| DispatchOutcome
+	| InvalidTransaction
+	| UnknownTransaction;
+
+export interface ITransactionDryRun {
+	at: IAt;
+	dryRunResult: {
+		resultType: TransactionResultType;
+		result: TransactionResult;
+		validityErrorType?: ValidityErrorType;
+	};
+}

src/types/responses/index.ts

@@ -17,3 +17,4 @@ export * from './AccountStakingPayouts';
 export * from './NodeNetwork';
 export * from './NodeVersion';
 export * from './NodeTransactionPool';
+export * from './TransactionDryRun';