feat: 🎸 venue filtering

Author: sansan

src/assets/assets.controller.spec.ts

@@ -19,6 +19,7 @@ import { AssetsService } from '~/assets/assets.service';
 import { AssetDocumentDto } from '~/assets/dto/asset-document.dto';
 import { SetTransferRestrictionsDto } from '~/assets/dto/transfer-restrictions/set-transfer-restrictions.dto';
 import { TransferRestrictionsValueModel } from '~/assets/models/transfer-restrictions-values.model';
+import { VenueFilteringDetailsModel } from '~/assets/models/venue-filtering-details.model';
 import { createAuthorizationRequestModel } from '~/authorizations/authorizations.util';
 import { PaginatedResultsModel } from '~/common/models/paginated-results.model';
 import { ProcessMode } from '~/common/types';
@@ -239,6 +240,70 @@ describe('AssetsController', () => {
     });
   });
 
+  describe('enableVenueFiltering', () => {
+    it('should enable venue filtering for the asset', async () => {
+      mockAssetsService.enableVenueFiltering.mockResolvedValue(txResult);
+      const body = { signer };
+
+      const result = await controller.enableVenueFiltering({ asset: assetId }, body);
+
+      expect(result).toEqual(processedTxResult);
+      expect(mockAssetsService.enableVenueFiltering).toHaveBeenCalledWith(assetId, body);
+    });
+  });
+
+  describe('disableVenueFiltering', () => {
+    it('should disable venue filtering for the asset', async () => {
+      mockAssetsService.disableVenueFiltering.mockResolvedValue(txResult);
+      const body = { signer };
+
+      const result = await controller.disableVenueFiltering({ asset: assetId }, body);
+
+      expect(result).toEqual(processedTxResult);
+      expect(mockAssetsService.disableVenueFiltering).toHaveBeenCalledWith(assetId, body);
+    });
+  });
+
+  describe('allowVenues', () => {
+    it('should allow venues for the asset', async () => {
+      mockAssetsService.allowVenues.mockResolvedValue(txResult);
+      const body = { signer, venues: [new BigNumber(1)] };
+
+      const result = await controller.allowVenues({ asset: assetId }, body);
+
+      expect(result).toEqual(processedTxResult);
+      expect(mockAssetsService.allowVenues).toHaveBeenCalledWith(assetId, body);
+    });
+  });
+
+  describe('disallowVenues', () => {
+    it('should disallow venues for the asset', async () => {
+      mockAssetsService.disallowVenues.mockResolvedValue(txResult);
+      const body = { signer, venues: [new BigNumber(2)] };
+
+      const result = await controller.disallowVenues({ asset: assetId }, body);
+
+      expect(result).toEqual(processedTxResult);
+      expect(mockAssetsService.disallowVenues).toHaveBeenCalledWith(assetId, body);
+    });
+  });
+
+  describe('getVenueFilteringDetails', () => {
+    it('should return the venue filtering details', async () => {
+      const details = {
+        isEnabled: true,
+        allowedVenues: [new BigNumber(1)],
+        disallowedVenues: [],
+      };
+      mockAssetsService.getVenueFilteringDetails.mockResolvedValue(details);
+
+      const result = await controller.getVenueFilteringDetails({ asset: assetId });
+
+      expect(result).toEqual(new VenueFilteringDetailsModel(details));
+      expect(mockAssetsService.getVenueFilteringDetails).toHaveBeenCalledWith(assetId);
+    });
+  });
+
   describe('createAsset', () => {
     it('should call the service and return the results', async () => {
       const input = {

src/assets/assets.controller.ts

@@ -23,13 +23,15 @@ import { RedeemTokensDto } from '~/assets/dto/redeem-tokens.dto';
 import { RequiredMediatorsDto } from '~/assets/dto/required-mediators.dto';
 import { SetAssetDocumentsDto } from '~/assets/dto/set-asset-documents.dto';
 import { SetTransferRestrictionsDto } from '~/assets/dto/transfer-restrictions/set-transfer-restrictions.dto';
+import { VenueIdsDto } from '~/assets/dto/venue-ids.dto';
 import { AgentOperationModel } from '~/assets/models/agent-operation.model';
 import { AssetDetailsModel } from '~/assets/models/asset-details.model';
 import { AssetDocumentModel } from '~/assets/models/asset-document.model';
 import { CreatedAssetModel } from '~/assets/models/created-asset.model';
 import { IdentityBalanceModel } from '~/assets/models/identity-balance.model';
 import { RequiredMediatorsModel } from '~/assets/models/required-mediators.model';
 import { TransferRestrictionsValueModel } from '~/assets/models/transfer-restrictions-values.model';
+import { VenueFilteringDetailsModel } from '~/assets/models/venue-filtering-details.model';
 import { authorizationRequestResolver } from '~/authorizations/authorizations.util';
 import { CreatedAuthorizationRequestModel } from '~/authorizations/models/created-authorization-request.model';
 import {
@@ -233,6 +235,121 @@ export class AssetsController {
     return handleServiceResult(result);
   }
 
+  @ApiOperation({
+    summary: 'Enable venue filtering for an Asset',
+    description:
+      'When enabled, only explicitly allowed venues can create instructions for the Asset',
+  })
+  @ApiParam({
+    name: 'asset',
+    description: 'The Asset (Ticker/Asset ID) whose venue filtering will be enabled',
+    type: 'string',
+  })
+  @ApiTransactionResponse({
+    description: 'Details of the transaction',
+    type: TransactionQueueModel,
+  })
+  @Post(':asset/venue-filtering/enable')
+  public async enableVenueFiltering(
+    @Param() { asset }: AssetParamsDto,
+    @Body() transactionBaseDto: TransactionBaseDto
+  ): Promise<TransactionResponseModel> {
+    const result = await this.assetsService.enableVenueFiltering(asset, transactionBaseDto);
+
+    return handleServiceResult(result);
+  }
+
+  @ApiOperation({
+    summary: 'Disable venue filtering for an Asset',
+    description: 'When disabled, any venue can create instructions for the Asset',
+  })
+  @ApiParam({
+    name: 'asset',
+    description: 'The Asset (Ticker/Asset ID) whose venue filtering will be disabled',
+    type: 'string',
+  })
+  @ApiTransactionResponse({
+    description: 'Details of the transaction',
+    type: TransactionQueueModel,
+  })
+  @Post(':asset/venue-filtering/disable')
+  public async disableVenueFiltering(
+    @Param() { asset }: AssetParamsDto,
+    @Body() transactionBaseDto: TransactionBaseDto
+  ): Promise<TransactionResponseModel> {
+    const result = await this.assetsService.disableVenueFiltering(asset, transactionBaseDto);
+
+    return handleServiceResult(result);
+  }
+
+  @ApiOperation({
+    summary: 'Allow specific venues to settle instructions for an Asset',
+  })
+  @ApiParam({
+    name: 'asset',
+    description: 'The Asset (Ticker/Asset ID) whose venue allowlist will be updated',
+    type: 'string',
+  })
+  @ApiTransactionResponse({
+    description: 'Details of the transaction',
+    type: TransactionQueueModel,
+  })
+  @Post(':asset/venue-filtering/allow')
+  public async allowVenues(
+    @Param() { asset }: AssetParamsDto,
+    @Body() venueIdsDto: VenueIdsDto
+  ): Promise<TransactionResponseModel> {
+    const result = await this.assetsService.allowVenues(asset, venueIdsDto);
+
+    return handleServiceResult(result);
+  }
+
+  @ApiOperation({
+    summary: 'Disallow specific venues from settling instructions for an Asset',
+  })
+  @ApiParam({
+    name: 'asset',
+    description: 'The Asset (Ticker/Asset ID) whose venue allowlist will be updated',
+    type: 'string',
+  })
+  @ApiTransactionResponse({
+    description: 'Details of the transaction',
+    type: TransactionQueueModel,
+  })
+  @Post(':asset/venue-filtering/disallow')
+  public async disallowVenues(
+    @Param() { asset }: AssetParamsDto,
+    @Body() venueIdsDto: VenueIdsDto
+  ): Promise<TransactionResponseModel> {
+    const result = await this.assetsService.disallowVenues(asset, venueIdsDto);
+
+    return handleServiceResult(result);
+  }
+
+  @ApiOperation({
+    summary: 'Get venue filtering details for an Asset',
+    description:
+      'Returns the current filtering status alongside the allowed and disallowed venue identifiers',
+  })
+  @ApiParam({
+    name: 'asset',
+    description:
+      'The Asset (Ticker/Asset ID) whose venue filtering configuration will be retrieved',
+    type: 'string',
+  })
+  @ApiOkResponse({
+    description: 'Venue filtering configuration for the Asset',
+    type: VenueFilteringDetailsModel,
+  })
+  @Get(':asset/venue-filtering')
+  public async getVenueFilteringDetails(
+    @Param() { asset }: AssetParamsDto
+  ): Promise<VenueFilteringDetailsModel> {
+    const details = await this.assetsService.getVenueFilteringDetails(asset);
+
+    return new VenueFilteringDetailsModel(details);
+  }
+
   @ApiOperation({
     summary: 'Issue more of an Asset',
     description: 'This endpoint issues more of a given Asset',

src/assets/assets.service.spec.ts

@@ -29,6 +29,7 @@ import {
   MockIdentity,
   MockPolymesh,
   MockTransaction,
+  MockVenue,
 } from '~/test-utils/mocks';
 import {
   MockIdentitiesService,
@@ -37,7 +38,7 @@ import {
 } from '~/test-utils/service-mocks';
 import * as transactionsUtilModule from '~/transactions/transactions.util';
 
-const { did, signer, assetId } = testValues;
+const { did, signer, assetId, ticker, txResult } = testValues;
 
 jest.mock('@polymeshassociation/polymesh-sdk/utils', () => ({
   ...jest.requireActual('@polymeshassociation/polymesh-sdk/utils'),
@@ -297,6 +298,107 @@ describe('AssetsService', () => {
     });
   });
 
+  describe('enableVenueFiltering', () => {
+    it('should submit a transaction enabling venue filtering', async () => {
+      const mockAsset = new MockAsset();
+      mockPolymeshApi.assets.getAsset.mockResolvedValue(mockAsset);
+      mockTransactionsService.submit.mockResolvedValue(txResult);
+
+      const body = { signer };
+
+      const result = await service.enableVenueFiltering(ticker, body);
+
+      expect(result).toBe(txResult);
+      expect(mockPolymeshApi.assets.getAsset).toHaveBeenCalledWith({ ticker });
+      expect(mockTransactionsService.submit).toHaveBeenCalledWith(
+        mockAsset.setVenueFiltering,
+        { enabled: true },
+        expect.objectContaining({ signer })
+      );
+    });
+  });
+
+  describe('disableVenueFiltering', () => {
+    it('should submit a transaction disabling venue filtering', async () => {
+      const mockAsset = new MockAsset();
+      mockPolymeshApi.assets.getAsset.mockResolvedValue(mockAsset);
+      mockTransactionsService.submit.mockResolvedValue(txResult);
+
+      const body = { signer };
+
+      const result = await service.disableVenueFiltering(assetId, body);
+
+      expect(result).toBe(txResult);
+      expect(mockPolymeshApi.assets.getAsset).toHaveBeenCalledWith({ assetId });
+      expect(mockTransactionsService.submit).toHaveBeenCalledWith(
+        mockAsset.setVenueFiltering,
+        { enabled: false },
+        expect.objectContaining({ signer })
+      );
+    });
+  });
+
+  describe('allowVenues', () => {
+    it('should submit a transaction allowing venues', async () => {
+      const mockAsset = new MockAsset();
+      const venues = [new BigNumber(1)];
+      mockPolymeshApi.assets.getAsset.mockResolvedValue(mockAsset);
+      mockTransactionsService.submit.mockResolvedValue(txResult);
+
+      const body = { signer, venues };
+
+      const result = await service.allowVenues(ticker, body);
+
+      expect(result).toBe(txResult);
+      expect(mockTransactionsService.submit).toHaveBeenCalledWith(
+        mockAsset.setVenueFiltering,
+        { allowedVenues: venues },
+        expect.objectContaining({ signer })
+      );
+    });
+  });
+
+  describe('disallowVenues', () => {
+    it('should submit a transaction disallowing venues', async () => {
+      const mockAsset = new MockAsset();
+      const venues = [new BigNumber(2)];
+      mockPolymeshApi.assets.getAsset.mockResolvedValue(mockAsset);
+      mockTransactionsService.submit.mockResolvedValue(txResult);
+
+      const body = { signer, venues };
+
+      const result = await service.disallowVenues(ticker, body);
+
+      expect(result).toBe(txResult);
+      expect(mockTransactionsService.submit).toHaveBeenCalledWith(
+        mockAsset.setVenueFiltering,
+        { disallowedVenues: venues },
+        expect.objectContaining({ signer })
+      );
+    });
+  });
+
+  describe('getVenueFilteringDetails', () => {
+    it('should return the venue filtering details', async () => {
+      const mockAsset = new MockAsset();
+      const allowedVenues = [new MockVenue(), new MockVenue()];
+      allowedVenues[0].id = new BigNumber(5);
+      allowedVenues[1].id = new BigNumber(7);
+
+      mockAsset.getVenueFilteringDetails.mockResolvedValue({ isEnabled: true, allowedVenues });
+      mockPolymeshApi.assets.getAsset.mockResolvedValue(mockAsset);
+
+      const result = await service.getVenueFilteringDetails(assetId);
+
+      expect(result).toEqual({
+        isEnabled: true,
+        allowedVenues: allowedVenues.map(({ id }) => id),
+        disallowedVenues: [],
+      });
+      expect(mockAsset.getVenueFilteringDetails).toHaveBeenCalled();
+    });
+  });
+
   describe('createAsset', () => {
     const createBody = {
       signer,
@@ -357,7 +459,6 @@ describe('AssetsService', () => {
   });
 
   describe('transferOwnership', () => {
-    const ticker = 'TICKER';
     const body = {
       signer,
       target: '0x1000',