fix(types): Bump polkadot-js/api to decode CompactSolution for 24 noms (

#553)

* fix(types): Bump polkadot-js/api to decode CompactSolution for 24 nominees

* Lint

package.json

@@ -40,8 +40,8 @@
   },
   "dependencies": {
     "@polkadot/api": "beta",
-    "@polkadot/apps-config": "beta",
-    "@polkadot/util-crypto": "beta",
+    "@polkadot/apps-config": "^0.90.1",
+    "@polkadot/util-crypto": "^6.4.1",
     "@substrate/calc": "^0.2.0",
     "confmgr": "^1.0.6",
     "express": "^4.17.1",

src/chains-config/metadata-consts/dockConsts.ts

@@ -3,24 +3,7 @@ import { MetadataConsts } from '../../types/chains-config';
 export const dockMainnetDefinitions: MetadataConsts[] = [
 	{
 		runtimeVersions: [
-			1,
-			2,
-			3,
-			4,
-			5,
-			6,
-			7,
-			8,
-			9,
-			10,
-			11,
-			12,
-			13,
-			14,
-			15,
-			16,
-			17,
-			18,
+			1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
 		],
 		extrinsicBaseWeight: BigInt(125000000),
 	},

src/chains-config/metadata-consts/kusamaConsts.ts

@@ -4,20 +4,8 @@ import { extrinsicBaseWeight, perClass } from './substrateConsts';
 export const kusamaDefinitions: MetadataConsts[] = [
 	{
 		runtimeVersions: [
-			1062,
-			2005,
-			2007,
-			2008,
-			2011,
-			2012,
-			2013,
-			2015,
-			2019,
-			2022,
-			2023,
-			2024,
-			2025,
-			2026,
+			1062, 2005, 2007, 2008, 2011, 2012, 2013, 2015, 2019, 2022, 2023, 2024,
+			2025, 2026,
 		],
 		extrinsicBaseWeight,
 	},

src/chains-config/metadata-consts/polkadotConsts.ts

@@ -4,26 +4,7 @@ import { extrinsicBaseWeight, perClass } from './substrateConsts';
 export const polkadotDefinitions: MetadataConsts[] = [
 	{
 		runtimeVersions: [
-			0,
-			1,
-			5,
-			6,
-			7,
-			8,
-			9,
-			10,
-			11,
-			12,
-			13,
-			14,
-			15,
-			16,
-			17,
-			18,
-			23,
-			24,
-			25,
-			26,
+			0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 23, 24, 25, 26,
 		],
 		extrinsicBaseWeight,
 	},

src/chains-config/metadata-consts/westendConsts.ts

@@ -4,22 +4,7 @@ import { extrinsicBaseWeight, perClass } from './substrateConsts';
 export const westendDefinitions: MetadataConsts[] = [
 	{
 		runtimeVersions: [
-			6,
-			7,
-			8,
-			20,
-			28,
-			29,
-			30,
-			31,
-			32,
-			33,
-			24,
-			35,
-			41,
-			43,
-			44,
-			45,
+			6, 7, 8, 20, 28, 29, 30, 31, 32, 33, 24, 35, 41, 43, 44, 45,
 		],
 		extrinsicBaseWeight,
 	},

src/controllers/AbstractController.ts

@@ -76,18 +76,16 @@ export default abstract class AbstractController<T extends AbstractService> {
 	 *
 	 * @param cb ExpressHandler
 	 */
-	protected static catchWrap = (cb: RequestHandler): RequestHandler => async (
-		req,
-		res,
-		next
-	): Promise<void> => {
-		try {
-			// eslint-disable-next-line @typescript-eslint/await-thenable
-			await cb(req, res, next);
-		} catch (err) {
-			next(err);
-		}
-	};
+	protected static catchWrap =
+		(cb: RequestHandler): RequestHandler =>
+		async (req, res, next): Promise<void> => {
+			try {
+				// eslint-disable-next-line @typescript-eslint/await-thenable
+				await cb(req, res, next);
+			} catch (err) {
+				next(err);
+			}
+		};
 
 	/**
 	 * Create or retrieve the corresponding BlockHash for the given block identifier.

src/controllers/AbstractControllers.spec.ts

@@ -48,18 +48,18 @@ const MockController = class MockController extends AbstractController<AbstractS
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const MockService = new (class MockService extends AbstractService {})(
-	(api as unknown) as ApiPromise
+	api as unknown as ApiPromise
 );
 
 const controller = new MockController(
-	(api as unknown) as ApiPromise,
+	api as unknown as ApiPromise,
 	'/mock',
 	MockService
 );
 
 // Mock arguments for Express RequestHandler
-const req = ('req' as unknown) as Request;
-const res = ('res' as unknown) as Response;
+const req = 'req' as unknown as Request;
+const res = 'res' as unknown as Response;
 
 describe('AbstractController', () => {
 	describe('catchWrap', () => {

src/logging/consoleOverride.ts

@@ -29,7 +29,7 @@ export function consoleOverride(logger: Logger): void {
 			// eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
 			logger[winstonLevel].call(
 				logger,
-				(format.apply(format, args as [string]) as unknown) as object
+				format.apply(format, args as [string]) as unknown as object
 			);
 		};
 	});

src/logging/transformers/nodeUtilFormat.ts

@@ -10,7 +10,7 @@ import * as winston from 'winston';
 export const nodeUtilFormat = winston.format(
 	(info: TransformableInfo, _opts: unknown) => {
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-		const args = info[(SPLAT as unknown) as string];
+		const args = info[SPLAT as unknown as string];
 		if (args) {
 			info.message = format(info.message, ...args);
 		}

src/logging/transformers/stripTimestamp.ts

@@ -4,7 +4,8 @@ import { format } from 'winston';
 /**
  * Regex that matches timestamps with the format of `YYYY-MM-DD HH:MM`
  */
-const timestampRegex = /[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[01][0-9]):[0-5][0-9]/;
+const timestampRegex =
+	/[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[01][0-9]):[0-5][0-9]/;
 
 /**
  * Slice out the timestamp from a message so it is not redundant with the winston

src/middleware/error/errorMiddleware.spec.ts

@@ -9,9 +9,8 @@ import {
 
 const errorMiddlewareCallsNextWithErr = callsNextWithErr(errorMiddleware);
 
-const errorMiddlewareCatchesErrWithStatus = catchesErrWithStatus(
-	errorMiddleware
-);
+const errorMiddlewareCatchesErrWithStatus =
+	catchesErrWithStatus(errorMiddleware);
 
 describe('errorMiddleware', () => {
 	errorMiddlewareCallsNextWithErr('ILegacyError', {

src/middleware/error/httpErrorMiddleware.spec.ts

@@ -8,13 +8,11 @@ import {
 	catchesErrWithStatus,
 } from './testTools';
 
-const httpErrorMiddlewareCallsNextWithErr = callsNextWithErr(
-	httpErrorMiddleware
-);
+const httpErrorMiddlewareCallsNextWithErr =
+	callsNextWithErr(httpErrorMiddleware);
 
-const httpErrorMiddlewareCatchesErrWithStatus = catchesErrWithStatus(
-	httpErrorMiddleware
-);
+const httpErrorMiddlewareCatchesErrWithStatus =
+	catchesErrWithStatus(httpErrorMiddleware);
 
 describe('httpErrorMiddleware', () => {
 	httpErrorMiddlewareCallsNextWithErr('Error', new Error('This is an error'));

src/middleware/error/testTools.ts

@@ -12,30 +12,29 @@ const mockReq = {} as Request;
  * @param name name of the error type
  * @param err error
  */
-export const callsNextWithErr = (ware: ErrorRequestHandler) => (
-	name: string,
-	err: unknown
-): void => {
-	it(`calls next on error of type ${name}`, () => {
-		const next = jest.fn();
-		const send = jest.fn();
-		const status = jest.fn((_code: number) => {
-			return {
-				send,
-			};
-		});
+export const callsNextWithErr =
+	(ware: ErrorRequestHandler) =>
+	(name: string, err: unknown): void => {
+		it(`calls next on error of type ${name}`, () => {
+			const next = jest.fn();
+			const send = jest.fn();
+			const status = jest.fn((_code: number) => {
+				return {
+					send,
+				};
+			});
 
-		ware(
-			err,
-			mockReq,
-			({ headersSent: false, status } as unknown) as Response,
-			next
-		);
-		expect(status).not.toBeCalled();
-		expect(send).not.toBeCalled();
-		expect(next).toBeCalledTimes(1);
-	});
-};
+			ware(
+				err,
+				mockReq,
+				{ headersSent: false, status } as unknown as Response,
+				next
+			);
+			expect(status).not.toBeCalled();
+			expect(send).not.toBeCalled();
+			expect(next).toBeCalledTimes(1);
+		});
+	};
 
 /**
  * Assert that a middleware function (`ware`) will catch `err` and set status to
@@ -46,32 +45,30 @@ export const callsNextWithErr = (ware: ErrorRequestHandler) => (
  * @param err error
  * @param code expected code to be sent as status
  */
-export const catchesErrWithStatus = (ware: ErrorRequestHandler) => (
-	name: string,
-	err: unknown,
-	code: number
-): void => {
-	it(`catches ${name} and sends status code ${code}`, () => {
-		const next = jest.fn();
-		const send = jest.fn();
-		const status = jest.fn((_code: number) => {
-			return {
-				send,
-			};
-		});
+export const catchesErrWithStatus =
+	(ware: ErrorRequestHandler) =>
+	(name: string, err: unknown, code: number): void => {
+		it(`catches ${name} and sends status code ${code}`, () => {
+			const next = jest.fn();
+			const send = jest.fn();
+			const status = jest.fn((_code: number) => {
+				return {
+					send,
+				};
+			});
 
-		ware(
-			err,
-			mockReq,
-			({ headersSent: false, status } as unknown) as Response,
-			next
-		);
-		expect(send).toBeCalledTimes(1);
-		expect(status).toBeCalledWith<[number]>(code);
-		expect(status).toBeCalledTimes(1);
-		expect(next).not.toBeCalled();
-	});
-};
+			ware(
+				err,
+				mockReq,
+				{ headersSent: false, status } as unknown as Response,
+				next
+			);
+			expect(send).toBeCalledTimes(1);
+			expect(status).toBeCalledWith<[number]>(code);
+			expect(status).toBeCalledTimes(1);
+			expect(next).not.toBeCalled();
+		});
+	};
 
 /**
  * Assert that a middleware function (`ware`) will catch `err`, set status to
@@ -83,34 +80,31 @@ export const catchesErrWithStatus = (ware: ErrorRequestHandler) => (
  * @param code expected code to be sent as status
  * @param response expected response body
  */
-export const catchesErrWithResponse = (ware: ErrorRequestHandler) => (
-	name: string,
-	err: unknown,
-	code: number,
-	response: unknown
-): void => {
-	it(`catches ${name} and sends status code ${code}`, () => {
-		const next = jest.fn();
-		const send = jest.fn();
-		const status = jest.fn((_code: number) => {
-			return {
-				send,
-			};
-		});
+export const catchesErrWithResponse =
+	(ware: ErrorRequestHandler) =>
+	(name: string, err: unknown, code: number, response: unknown): void => {
+		it(`catches ${name} and sends status code ${code}`, () => {
+			const next = jest.fn();
+			const send = jest.fn();
+			const status = jest.fn((_code: number) => {
+				return {
+					send,
+				};
+			});
 
-		ware(
-			err,
-			mockReq,
-			({ headersSent: false, status } as unknown) as Response,
-			next
-		);
-		expect(send).toBeCalledTimes(1);
-		expect(send).toBeCalledWith(response);
-		expect(status).toBeCalledWith<[number]>(code);
-		expect(status).toBeCalledTimes(1);
-		expect(next).not.toBeCalled();
-	});
-};
+			ware(
+				err,
+				mockReq,
+				{ headersSent: false, status } as unknown as Response,
+				next
+			);
+			expect(send).toBeCalledTimes(1);
+			expect(send).toBeCalledWith(response);
+			expect(status).toBeCalledWith<[number]>(code);
+			expect(status).toBeCalledTimes(1);
+			expect(next).not.toBeCalled();
+		});
+	};
 
 export function callsNextWithSentHeaders(
 	ware: ErrorRequestHandler,
@@ -128,7 +122,7 @@ export function callsNextWithSentHeaders(
 		ware(
 			err,
 			mockReq,
-			({ headersSent: true, status } as unknown) as Response,
+			{ headersSent: true, status } as unknown as Response,
 			next
 		);
 		expect(send).not.toBeCalled();