Merge pull request #104 from PolymathNetwork/DA-297/mock-cdd

feat: 🎸 Add mock CDD endpoint

Author: monitz87

src/accounts/accounts.module.ts

@@ -11,5 +11,6 @@ import { SigningModule } from '~/signing/signing.module';
   imports: [PolymeshModule, SigningModule],
   controllers: [AccountsController],
   providers: [AccountsService],
+  exports: [AccountsService],
 })
 export class AccountsModule {}

src/accounts/dto/transaction-history-filters.dto.ts

@@ -17,7 +17,7 @@ export class TransactionHistoryFiltersDto {
     example: '1000000',
   })
   @IsOptional()
-  @IsBigNumber()
+  @IsBigNumber({ min: 0 })
   @ToBigNumber()
   readonly blockNumber?: BigNumber;
 

src/common/decorators/validation.ts

@@ -42,7 +42,12 @@ export function IsTicker(validationOptions?: ValidationOptions) {
   );
 }
 
-export function IsBigNumber(validationOptions?: ValidationOptions) {
+export function IsBigNumber(
+  numericValidations: { min?: number; max?: number } = {},
+  validationOptions?: ValidationOptions
+) {
+  const isDefined = (v: number | undefined): v is number => typeof v !== 'undefined';
+  const { min, max } = numericValidations;
   // eslint-disable-next-line @typescript-eslint/ban-types
   return function (object: Object, propertyName: string) {
     registerDecorator({
@@ -52,10 +57,33 @@ export function IsBigNumber(validationOptions?: ValidationOptions) {
       options: validationOptions,
       validator: {
         validate(value: unknown) {
-          return value instanceof BigNumber && !value.isNaN();
+          if (!(value instanceof BigNumber)) {
+            return false;
+          }
+          if (value.isNaN()) {
+            return false;
+          }
+          if (isDefined(min) && value.lt(min)) {
+            return false;
+          }
+          if (isDefined(max) && value.gt(max)) {
+            return false;
+          }
+
+          return true;
         },
         defaultMessage(args: ValidationArguments) {
-          return `${args.property} must be a number`;
+          let message = `${args.property} must be a number`;
+          const hasMin = isDefined(min);
+          const hasMax = isDefined(max);
+          if (hasMin && hasMax) {
+            message += ` that is between ${min} and ${max}`;
+          } else if (hasMin) {
+            message += ` that is at least ${min}`;
+          } else if (hasMax) {
+            message += ` that is at most ${max}`;
+          }
+          return message;
         },
       },
     });

src/corporate-actions/dto/tax-withholding.dto.ts

@@ -4,7 +4,7 @@ import { ApiProperty } from '@nestjs/swagger';
 import { BigNumber } from '@polymathnetwork/polymesh-sdk';
 
 import { ToBigNumber } from '~/common/decorators/transformation';
-import { IsBigNumber, IsDid } from '~/common/decorators/validation';
+import { IsBigNumber,IsDid } from '~/common/decorators/validation';
 
 export class TaxWithholdingDto {
   @ApiProperty({

src/identities/dto/create-mock-identity.dto.ts

@@ -0,0 +1,25 @@
+/* istanbul ignore file */
+
+import { ApiProperty } from '@nestjs/swagger';
+import { BigNumber } from '@polymathnetwork/polymesh-sdk';
+import { IsString } from 'class-validator';
+
+import { ToBigNumber } from '~/common/decorators/transformation';
+import { IsBigNumber } from '~/common/decorators/validation';
+
+export class CreateMockIdentityDto {
+  @ApiProperty({
+    description: 'Account address to create an Identity for',
+    example: '5GwwYnwCYcJ1Rkop35y7SDHAzbxrCkNUDD4YuCUJRPPXbvyV',
+  })
+  @IsString()
+  readonly address: string;
+
+  @ApiProperty({
+    description: 'Starting POLYX balance to initialize the Account with',
+    example: 100000,
+  })
+  @IsBigNumber({ min: 0 })
+  @ToBigNumber()
+  readonly initialPolyx: BigNumber;
+}

src/identities/identities.controller.spec.ts

@@ -15,6 +15,7 @@ import { ClaimsService } from '~/claims/claims.service';
 import { ResultsModel } from '~/common/models/results.model';
 import { IdentitiesController } from '~/identities/identities.controller';
 import { IdentitiesService } from '~/identities/identities.service';
+import * as identityUtil from '~/identities/identities.util';
 import { AccountModel } from '~/identities/models/account.model';
 import { IdentitySignerModel } from '~/identities/models/identity-signer.model';
 import { IdentityModel } from '~/identities/models/identity.model';
@@ -472,4 +473,24 @@ describe('IdentitiesController', () => {
       expect(mockTickerReservationsService.findAllByOwner).toHaveBeenCalledWith(did);
     });
   });
+
+  describe('mockCdd', () => {
+    it('should call the service and return the Identity', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const fakeIdentityModel = 'fakeIdentityModel' as any;
+      const createIdentityModelSpy = jest
+        .spyOn(identityUtil, 'createIdentityModel')
+        .mockResolvedValue(fakeIdentityModel);
+
+      const params = {
+        address: '5abc',
+        initialPolyx: new BigNumber(10),
+      };
+
+      const result = await controller.createMockCdd(params);
+      expect(result).toEqual(fakeIdentityModel);
+      expect(mockIdentitiesService.createMockCdd).toHaveBeenCalledWith(params);
+      createIdentityModelSpy.mockRestore();
+    });
+  });
 });

src/identities/identities.controller.ts

@@ -37,6 +37,7 @@ import { DidDto, IncludeExpiredFilterDto } from '~/common/dto/params.dto';
 import { PaginatedResultsModel } from '~/common/models/paginated-results.model';
 import { ResultsModel } from '~/common/models/results.model';
 import { AddSecondaryAccountParamsDto } from '~/identities/dto/add-secondary-account-params.dto';
+import { CreateMockIdentityDto } from '~/identities/dto/create-mock-identity.dto';
 import { IdentitiesService } from '~/identities/identities.service';
 import { createIdentityModel } from '~/identities/identities.util';
 import { IdentityModel } from '~/identities/models/identity.model';
@@ -447,4 +448,23 @@ export class IdentitiesController {
     const results = await this.tickerReservationsService.findAllByOwner(did);
     return new ResultsModel({ results });
   }
+
+  @ApiOperation({
+    summary: 'Creates a fake Identity for an Account and sets its POLYX balance (DEV ONLY)',
+    description:
+      'This endpoint creates a Identity for an Account and sets its POLYX balance. Will only work with development chains. Alice must exist, be able to call `testUtils.mockCddRegisterDid` and have `sudo` permission',
+  })
+  @ApiOkResponse({ description: 'The details of the newly created Identity' })
+  @ApiBadRequestResponse({
+    description:
+      'This instance of the REST API is pointing to a chain that lacks development features. A proper CDD provider must be used instead',
+  })
+  @ApiInternalServerErrorResponse({
+    description: 'Failed to execute an extrinsic, or something unexpected',
+  })
+  @Post('/mock-cdd')
+  public async createMockCdd(@Body() params: CreateMockIdentityDto): Promise<IdentityModel> {
+    const identity = await this.identitiesService.createMockCdd(params);
+    return createIdentityModel(identity);
+  }
 }

src/identities/identities.module.ts

@@ -2,6 +2,7 @@
 
 import { forwardRef, Module } from '@nestjs/common';
 
+import { AccountsModule } from '~/accounts/accounts.module';
 import { AssetsModule } from '~/assets/assets.module';
 import { AuthorizationsModule } from '~/authorizations/authorizations.module';
 import { ClaimsModule } from '~/claims/claims.module';
@@ -23,6 +24,7 @@ import { TickerReservationsModule } from '~/ticker-reservations/ticker-reservati
     forwardRef(() => SettlementsModule),
     forwardRef(() => AuthorizationsModule),
     forwardRef(() => PortfoliosModule),
+    AccountsModule,
     ClaimsModule,
     TickerReservationsModule,
   ],

src/identities/identities.service.spec.ts

@@ -11,6 +11,7 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { BigNumber } from '@polymathnetwork/polymesh-sdk';
 import { ErrorCode, TxTags } from '@polymathnetwork/polymesh-sdk/types';
 
+import { AccountsService } from '~/accounts/accounts.service';
 import { TransactionType } from '~/common/types';
 import { IdentitiesService } from '~/identities/identities.service';
 import { mockPolymeshLoggerProvider } from '~/logger/mock-polymesh-logger';
@@ -19,7 +20,7 @@ import { PolymeshModule } from '~/polymesh/polymesh.module';
 import { PolymeshService } from '~/polymesh/polymesh.service';
 import { mockSigningProvider } from '~/signing/signing.mock';
 import { MockIdentity, MockPolymesh, MockTransactionQueue } from '~/test-utils/mocks';
-import { MockSigningService } from '~/test-utils/service-mocks';
+import { MockAccountsService, MockSigningService } from '~/test-utils/service-mocks';
 import { ErrorCase } from '~/test-utils/types';
 
 jest.mock('@polymathnetwork/polymesh-sdk/utils', () => ({
@@ -28,20 +29,37 @@ jest.mock('@polymathnetwork/polymesh-sdk/utils', () => ({
   isPolymeshTransaction: mockIsPolymeshTransaction,
 }));
 
+jest.mock('@polkadot/keyring', () => ({
+  ...jest.requireActual('@polkadot/keyring'),
+  Keyring: jest.fn().mockImplementation(() => {
+    return {
+      addFromUri: jest.fn(),
+    };
+  }),
+}));
+
 describe('IdentitiesService', () => {
   let service: IdentitiesService;
   let polymeshService: PolymeshService;
   let mockPolymeshApi: MockPolymesh;
   let mockSigningService: MockSigningService;
+  const mockAccountsService = new MockAccountsService();
 
   beforeEach(async () => {
     mockPolymeshApi = new MockPolymesh();
     mockSigningService = mockSigningProvider.useValue;
 
     const module: TestingModule = await Test.createTestingModule({
       imports: [PolymeshModule],
-      providers: [IdentitiesService, mockPolymeshLoggerProvider, mockSigningProvider],
+      providers: [
+        IdentitiesService,
+        AccountsService,
+        mockPolymeshLoggerProvider,
+        mockSigningProvider,
+      ],
     })
+      .overrideProvider(AccountsService)
+      .useValue(mockAccountsService)
       .overrideProvider(POLYMESH_API)
       .useValue(mockPolymeshApi)
       .compile();
@@ -218,4 +236,16 @@ describe('IdentitiesService', () => {
       });
     });
   });
+
+  describe('createMockCdd', () => {
+    it('should return a promise', async () => {
+      const params = {
+        address: 'address',
+        initialPolyx: new BigNumber(10),
+      };
+      mockPolymeshApi.network.getSs58Format.mockReturnValue(new BigNumber(42));
+      const result = service.createMockCdd(params);
+      expect(result).toBeInstanceOf(Promise);
+    });
+  });
 });

src/identities/identities.service.ts

@@ -1,4 +1,11 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  Injectable,
+  InternalServerErrorException,
+  NotFoundException,
+} from '@nestjs/common';
+import { Keyring } from '@polkadot/keyring';
+import { KeyringPair } from '@polkadot/keyring/types';
 import {
   Asset,
   AuthorizationRequest,
@@ -7,18 +14,23 @@ import {
 } from '@polymathnetwork/polymesh-sdk/types';
 import { isPolymeshError } from '@polymathnetwork/polymesh-sdk/utils';
 
+import { AccountsService } from '~/accounts/accounts.service';
 import { processQueue, QueueResult } from '~/common/utils';
 import { AddSecondaryAccountParamsDto } from '~/identities/dto/add-secondary-account-params.dto';
+import { CreateMockIdentityDto } from '~/identities/dto/create-mock-identity.dto';
 import { PolymeshLogger } from '~/logger/polymesh-logger.service';
 import { PolymeshService } from '~/polymesh/polymesh.service';
 import { SigningService } from '~/signing/signing.service';
 
 @Injectable()
 export class IdentitiesService {
+  private alicePair: KeyringPair;
+
   constructor(
     private readonly polymeshService: PolymeshService,
     private readonly logger: PolymeshLogger,
-    private readonly signingService: SigningService
+    private readonly signingService: SigningService,
+    private readonly accountsService: AccountsService
   ) {
     logger.setContext(IdentitiesService.name);
   }
@@ -65,4 +77,46 @@ export class IdentitiesService {
     const { inviteAccount } = this.polymeshService.polymeshApi.accountManagement;
     return processQueue(inviteAccount, params, { signingAccount: address });
   }
+
+  /**
+   * @note intended for development chains only (i.e. Alice exists and can call `testUtils.createMockCddClaim`)
+   */
+  public async createMockCdd({ address, initialPolyx }: CreateMockIdentityDto): Promise<Identity> {
+    const {
+      _polkadotApi: {
+        tx: { testUtils, balances, sudo },
+      },
+      network,
+    } = this.polymeshService.polymeshApi;
+
+    if (!testUtils) {
+      throw new BadRequestException(
+        'The chain does not have the `testUtils` pallet enabled. This endpoint is intended for development use only'
+      );
+    }
+
+    const targetAccount = await this.accountsService.findOne(address);
+
+    if (!this.alicePair) {
+      const ss58Format = network.getSs58Format().toNumber();
+      const keyring = new Keyring({ type: 'sr25519', ss58Format });
+      this.alicePair = keyring.addFromUri('//Alice');
+    }
+
+    await this.polymeshService.execTransaction(
+      this.alicePair,
+      testUtils.mockCddRegisterDid,
+      address
+    );
+    const setBalance = balances.setBalance(address, initialPolyx.shiftedBy(6).toNumber(), 0);
+    await this.polymeshService.execTransaction(this.alicePair, sudo.sudo, setBalance);
+
+    const id = await targetAccount.getIdentity();
+
+    if (!id) {
+      throw new InternalServerErrorException('The Identity was not created');
+    }
+
+    return id;
+  }
 }