feat: assets endpoints

src/chains-config/defaultControllers.ts

@@ -8,10 +8,12 @@ export const defaultControllers: ControllerConfig = {
 	controllers: {
 		Blocks: true,
 		BlocksExtrinsics: true,
+		AccountsAssets: true,
 		AccountsStakingPayouts: true,
 		AccountsBalanceInfo: true,
 		AccountsStakingInfo: true,
 		AccountsVestingInfo: true,
+		Assets: true,
 		NodeNetwork: true,
 		NodeVersion: true,
 		NodeTransactionPool: true,

src/chains-config/dockMainnetControllers.ts

@@ -8,10 +8,12 @@ export const dockMainnetControllers: ControllerConfig = {
 	controllers: {
 		Blocks: true,
 		BlocksExtrinsics: true,
+		AccountsAssets: false,
 		AccountsStakingPayouts: false,
 		AccountsBalanceInfo: true,
 		AccountsStakingInfo: false,
 		AccountsVestingInfo: false,
+		Assets: false,
 		NodeNetwork: true,
 		NodeVersion: true,
 		NodeTransactionPool: true,

src/chains-config/dockTestnetControllers.ts

@@ -7,10 +7,12 @@ export const dockTestnetControllers: ControllerConfig = {
 	controllers: {
 		Blocks: true,
 		BlocksExtrinsics: true,
+		AccountsAssets: false,
 		AccountsStakingPayouts: false,
 		AccountsBalanceInfo: true,
 		AccountsStakingInfo: false,
 		AccountsVestingInfo: false,
+		Assets: false,
 		NodeNetwork: true,
 		NodeVersion: true,
 		NodeTransactionPool: true,

src/chains-config/kulupuControllers.ts

@@ -4,10 +4,12 @@ export const kulupuControllers: ControllerConfig = {
 	controllers: {
 		Blocks: true,
 		BlocksExtrinsics: true,
+		AccountsAssets: false,
 		AccountsStakingPayouts: false,
 		AccountsBalanceInfo: true,
 		AccountsStakingInfo: false,
 		AccountsVestingInfo: false,
+		Assets: false,
 		NodeNetwork: true,
 		NodeVersion: true,
 		NodeTransactionPool: true,

src/chains-config/kusamaControllers.ts

@@ -8,10 +8,12 @@ export const kusamaControllers: ControllerConfig = {
 	controllers: {
 		Blocks: true,
 		BlocksExtrinsics: true,
+		AccountsAssets: true,
 		AccountsStakingPayouts: true,
 		AccountsBalanceInfo: true,
 		AccountsStakingInfo: true,
 		AccountsVestingInfo: true,
+		Assets: true,
 		NodeNetwork: true,
 		NodeVersion: true,
 		NodeTransactionPool: true,

src/chains-config/mandalaControllers.ts

@@ -7,10 +7,12 @@ export const mandalaControllers: ControllerConfig = {
 	controllers: {
 		Blocks: true,
 		BlocksExtrinsics: true,
+		AccountsAssets: false,
 		AccountsStakingPayouts: true,
 		AccountsBalanceInfo: true,
 		AccountsStakingInfo: true,
 		AccountsVestingInfo: true,
+		Assets: false,
 		NodeNetwork: true,
 		NodeVersion: true,
 		NodeTransactionPool: true,

src/chains-config/polkadotControllers.ts

@@ -8,10 +8,12 @@ export const polkadotControllers: ControllerConfig = {
 	controllers: {
 		Blocks: true,
 		BlocksExtrinsics: true,
+		AccountsAssets: true,
 		AccountsStakingPayouts: true,
 		AccountsBalanceInfo: true,
 		AccountsStakingInfo: true,
 		AccountsVestingInfo: true,
+		Assets: true,
 		NodeNetwork: true,
 		NodeVersion: true,
 		NodeTransactionPool: true,

src/chains-config/westendControllers.ts

@@ -8,10 +8,12 @@ export const westendControllers: ControllerConfig = {
 	controllers: {
 		Blocks: true,
 		BlocksExtrinsics: true,
+		AccountsAssets: true,
 		AccountsStakingPayouts: true,
 		AccountsBalanceInfo: true,
 		AccountsStakingInfo: true,
 		AccountsVestingInfo: true,
+		Assets: true,
 		NodeNetwork: true,
 		NodeVersion: true,
 		NodeTransactionPool: true,

src/controllers/AbstractController.ts

@@ -164,6 +164,26 @@ export default abstract class AbstractController<T extends AbstractService> {
 		return num;
 	}
 
+	protected parseQueryParamArrayOrThrow(
+		n: string,
+		errorMessage: string
+	): number[] {
+		const isValidParam = /[^,]+/.test(n);
+
+		if (!isValidParam) {
+			throw new BadRequest(errorMessage);
+		}
+
+		return n
+			.split(',')
+			.map((str) =>
+				this.parseNumberOrThrow(
+					str,
+					`Incorrect AssetId format: ${str} is not a positive integer.`
+				)
+			);
+	}
+
 	protected verifyAndCastOr(
 		name: string,
 		str: unknown,

src/controllers/accounts/AccountsAssetsController.ts

@@ -0,0 +1,65 @@
+import { ApiPromise } from '@polkadot/api';
+import { RequestHandler } from 'express';
+import { BadRequest } from 'http-errors';
+
+import { validateAddress } from '../../middleware';
+import { AccountsAssetsService } from '../../services/accounts';
+import AbstractController from '../AbstractController';
+
+export default class AccountsAssetsController extends AbstractController<AccountsAssetsService> {
+	constructor(api: ApiPromise) {
+		super(api, '/accounts/:address/', new AccountsAssetsService(api));
+	}
+
+	protected initRoutes(): void {
+		this.router.use(this.path, validateAddress);
+
+		this.safeMountAsyncGetHandlers([
+			['asset-balances', this.getAssetBalances],
+			['asset-approvals', this.getAssetApprovals],
+		]);
+	}
+
+	private getAssetBalances: RequestHandler = async (
+		{ params: { address }, query: { at, assets } },
+		res
+	): Promise<void> => {
+		const hash = await this.getHashFromAt(at);
+
+		let assetsArray: number[] = [];
+		if (typeof assets === 'string') {
+			assetsArray = this.parseQueryParamArrayOrThrow(
+				assets,
+				'assets query parameter is not in the correct format.'
+			);
+		}
+
+		AccountsAssetsController.sanitizedSend(
+			res,
+			await this.service.fetchAssetBalances(hash, address, assetsArray)
+		);
+	};
+
+	private getAssetApprovals: RequestHandler = async (
+		{ params: { address }, query: { at, delegate, assetId } },
+		res
+	): Promise<void> => {
+		const hash = await this.getHashFromAt(at);
+
+		if (typeof delegate !== 'string' || typeof assetId !== 'string') {
+			throw new BadRequest(
+				'Must include a delegate accountId as a query param'
+			);
+		}
+
+		const id = this.parseNumberOrThrow(
+			assetId,
+			'`assetId` provided is not a number.'
+		);
+
+		AccountsAssetsController.sanitizedSend(
+			res,
+			await this.service.fetchAssetApproval(hash, address, id, delegate)
+		);
+	};
+}

src/controllers/accounts/index.ts

@@ -1,3 +1,4 @@
+export { default as AccountsAssets } from './AccountsAssetsController';
 export { default as AccountsBalanceInfo } from './AccountsBalanceInfoController';
 export { default as AccountsStakingInfo } from './AccountsStakingInfoController';
 export { default as AccountsStakingPayouts } from './AccountsStakingPayoutsController';

src/controllers/assets/AssetsController.ts

@@ -0,0 +1,38 @@
+import { ApiPromise } from '@polkadot/api';
+import { RequestHandler } from 'express';
+
+import { AssetsService } from '../../services';
+import AbstractController from '../AbstractController';
+
+export default class AssetsController extends AbstractController<AssetsService> {
+	constructor(api: ApiPromise) {
+		super(api, '/assets', new AssetsService(api));
+		this.initRoutes();
+	}
+
+	protected initRoutes(): void {
+		this.safeMountAsyncGetHandlers([
+			['/:assetsId/assetInfo', this.getAssetById],
+		]);
+	}
+
+	private getAssetById: RequestHandler = async (
+		{ params: { assetId }, query: { at } },
+		res
+	): Promise<void> => {
+		const hash = await this.getHashFromAt(at);
+		/**
+		 * Verify our param `assetId` is an integer represented as a string, and return
+		 * it as an integer
+		 */
+		const index = this.parseNumberOrThrow(
+			assetId,
+			'`assetId` path param is not a number'
+		);
+
+		AssetsController.sanitizedSend(
+			res,
+			this.service.fetchAssetById(hash, index)
+		);
+	};
+}

src/controllers/assets/index.ts

@@ -0,0 +1 @@
+export { default as Assets } from './AssetsController';

src/controllers/index.ts

@@ -1,9 +1,11 @@
 import {
+	AccountsAssets,
 	AccountsBalanceInfo,
 	AccountsStakingInfo,
 	AccountsStakingPayouts,
 	AccountsVestingInfo,
 } from './accounts';
+import { Assets } from './assets';
 import { Blocks, BlocksExtrinsics } from './blocks';
 import { NodeNetwork, NodeTransactionPool, NodeVersion } from './node';
 import { PalletsStakingProgress, PalletsStorage } from './pallets';
@@ -22,10 +24,12 @@ import {
 export const controllers = {
 	Blocks,
 	BlocksExtrinsics,
+	AccountsAssets,
 	AccountsBalanceInfo,
 	AccountsStakingInfo,
 	AccountsVestingInfo,
 	AccountsStakingPayouts,
+	Assets,
 	PalletsStakingProgress,
 	PalletsStorage,
 	NodeNetwork,

src/services/accounts/AccountsAssetsService.spec.ts

@@ -0,0 +1,107 @@
+import { sanitizeNumbers } from '../../sanitize/sanitizeNumbers';
+import { blockHash789629, mockApi } from '../test-helpers/mock';
+import { AccountsAssetsService } from './AccountsAssetsService';
+
+const accountsAssetsService = new AccountsAssetsService(mockApi);
+
+describe('AccountsAssetsService', () => {
+	const at = {
+		hash: '0x7b713de604a99857f6c25eacc115a4f28d2611a23d9ddff99ab0e4f1c17a8578',
+		height: '789629',
+	};
+
+	describe('AccountsAssetsService.fetchAssetBalances', () => {
+		it('Should return the correct response with the assets param', async () => {
+			const expectedResponse = {
+				at,
+				assets: [
+					{
+						assetId: '10',
+						balance: '10000000',
+						isFrozen: false,
+						isSufficient: true,
+					},
+					{
+						assetId: '20',
+						balance: '20000000',
+						isFrozen: true,
+						isSufficient: true,
+					},
+				],
+			};
+
+			const response = await accountsAssetsService.fetchAssetBalances(
+				blockHash789629,
+				'0xffff',
+				[10, 20]
+			);
+
+			expect(sanitizeNumbers(response)).toStrictEqual(expectedResponse);
+		});
+
+		it('Should return the correct response without the assets param', async () => {
+			const expectedResponse = {
+				at,
+				assets: [
+					{
+						assetId: '10',
+						balance: '10000000',
+						isFrozen: false,
+						isSufficient: true,
+					},
+					{
+						assetId: '20',
+						balance: '20000000',
+						isFrozen: true,
+						isSufficient: true,
+					},
+					{
+						assetId: '30',
+						balance: '20000000',
+						isFrozen: false,
+						isSufficient: false,
+					},
+					{
+						assetId: '30',
+						balance: '20000000',
+						isFrozen: false,
+						isSufficient: false,
+					},
+					{
+						assetId: '30',
+						balance: '20000000',
+						isFrozen: false,
+						isSufficient: false,
+					},
+				],
+			};
+
+			const response = await accountsAssetsService.fetchAssetBalances(
+				blockHash789629,
+				'0xffff',
+				[]
+			);
+
+			expect(sanitizeNumbers(response)).toStrictEqual(expectedResponse);
+		});
+	});
+
+	describe('AccountsAssetsService.fetchAssetApproval', () => {
+		it('Should return the correct response', async () => {
+			const expectedResponse = {
+				at,
+				amount: '10000000',
+				deposit: '2000000',
+			};
+
+			const response = await accountsAssetsService.fetchAssetApproval(
+				blockHash789629,
+				'',
+				10,
+				''
+			);
+
+			expect(sanitizeNumbers(response)).toStrictEqual(expectedResponse);
+		});
+	});
+});