feat: 🎸 initiate ca validation improvements

Author: sansan

src/api/procedures/__tests__/initiateCorporateAction.ts

@@ -15,7 +15,14 @@ import {
   Params,
   prepareInitiateCorporateAction,
 } from '~/api/procedures/initiateCorporateAction';
-import { Checkpoint, CheckpointSchedule, Context, CorporateAction, Procedure } from '~/internal';
+import {
+  Checkpoint,
+  CheckpointSchedule,
+  Context,
+  CorporateAction,
+  Identity,
+  Procedure,
+} from '~/internal';
 import { dsMockUtils, entityMockUtils, procedureMockUtils } from '~/testUtils/mocks';
 import { Mocked } from '~/testUtils/types';
 import {
@@ -45,7 +52,7 @@ describe('assertCheckpointValue', () => {
   });
 
   it('should throw an error if the provided Date is in the past', () => {
-    const checkpoint = new Date(new Date().getTime() - 1000 * 60 * 60 * 24);
+    const checkpoint = new Date(Date.now() - 1000 * 60 * 60 * 24);
 
     return expect(assertCheckpointValue(checkpoint)).rejects.toThrow(
       'Checkpoint must be in the future'
@@ -56,7 +63,7 @@ describe('assertCheckpointValue', () => {
     const mockCheckpoint = new Checkpoint({ id: new BigNumber(1), assetId: asset.id }, context);
     mockCheckpoint.createdAt = jest
       .fn()
-      .mockResolvedValue(new Date(new Date().getTime() - 1000 * 60 * 60 * 24));
+      .mockResolvedValue(new Date(Date.now() - 1000 * 60 * 60 * 24));
 
     return expect(assertCheckpointValue(mockCheckpoint)).rejects.toThrow(
       'Checkpoint must be in the future'
@@ -89,6 +96,9 @@ describe('initiateCorporateAction procedure', () => {
   let initiateCorporateActionTransaction: PolymeshTx<unknown[]>;
 
   let corporateActionParamsToMeshCorporateActionArgsSpy: jest.SpyInstance;
+  let stringToIdentityIdSpy: jest.SpyInstance;
+  let assetToMeshAssetIdSpy: jest.SpyInstance;
+  let signingIdentity: Identity;
 
   beforeAll(() => {
     entityMockUtils.initMocks();
@@ -97,10 +107,10 @@ describe('initiateCorporateAction procedure', () => {
 
     assetId = '0x12341234123412341234123412341234';
     asset = entityMockUtils.getFungibleAssetInstance({ assetId });
-    checkpoint = new Date(new Date().getTime() + 1000 * 60 * 60 * 24);
+    checkpoint = new Date(Date.now() + 1000 * 60 * 60 * 24);
     kind = CorporateActionKind.IssuerNotice;
 
-    declarationDate = new Date(new Date().getTime() - 1000 * 60 * 60 * 24);
+    declarationDate = new Date(Date.now() - 1000 * 60 * 60 * 24);
     description = 'someDescription';
     rawCorporateActionArgs = dsMockUtils.createMockInitiateCorporateActionArgs({
       assetId,
@@ -117,6 +127,10 @@ describe('initiateCorporateAction procedure', () => {
       utilsConversionModule,
       'corporateActionParamsToMeshCorporateActionArgs'
     );
+    stringToIdentityIdSpy = jest.spyOn(utilsConversionModule, 'stringToIdentityId');
+    assetToMeshAssetIdSpy = jest.spyOn(utilsConversionModule, 'assetToMeshAssetId');
+
+    signingIdentity = entityMockUtils.getIdentityInstance({ did: 'someDid' });
   });
 
   beforeEach(() => {
@@ -126,6 +140,20 @@ describe('initiateCorporateAction procedure', () => {
     );
 
     mockContext = dsMockUtils.getContextInstance();
+    mockContext.getSigningIdentity = jest.fn().mockResolvedValue(signingIdentity);
+
+    const rawAssetId = dsMockUtils.createMockAssetId(assetId);
+    const rawIdentityId = dsMockUtils.createMockIdentityId(signingIdentity.did);
+
+    when(assetToMeshAssetIdSpy).calledWith(asset, mockContext).mockReturnValue(rawAssetId);
+    when(stringToIdentityIdSpy)
+      .calledWith(signingIdentity.did, mockContext)
+      .mockReturnValue(rawIdentityId);
+
+    // Default: mock Full agent (asset owner scenario)
+    dsMockUtils.createQueryMock('externalAgents', 'groupOfAgent', {
+      returnValue: dsMockUtils.createMockOption(dsMockUtils.createMockAgentGroup('Full')),
+    });
 
     when(corporateActionParamsToMeshCorporateActionArgsSpy)
       .calledWith(
@@ -213,6 +241,81 @@ describe('initiateCorporateAction procedure', () => {
     });
   });
 
+  describe('tax withholdings validation', () => {
+    it('should validate tax withholdings and detect duplicates', async () => {
+      const proc = procedureMockUtils.getInstance<Params, CorporateAction>(mockContext);
+
+      // Set maxDidWhts to at least 2 to allow duplicate check to run before limit check
+      dsMockUtils.setConstMock('corporateAction', 'maxDidWhts', {
+        returnValue: dsMockUtils.createMockU32(new BigNumber(10)),
+      });
+
+      const identity1 = entityMockUtils.getIdentityInstance({ did: 'did1' });
+      const identity2 = entityMockUtils.getIdentityInstance({ did: 'did2' });
+
+      const asIdentitySpy = jest.spyOn(utilsInternalModule, 'asIdentity');
+      when(asIdentitySpy).calledWith(identity1, mockContext).mockReturnValue(identity1);
+      when(asIdentitySpy).calledWith(identity2, mockContext).mockReturnValue(identity2);
+
+      await expect(
+        prepareInitiateCorporateAction.call(proc, {
+          asset,
+          declarationDate,
+          description,
+          kind,
+          checkpoint,
+          taxWithholdings: [
+            { identity: identity1, percentage: new BigNumber(10) },
+            { identity: identity1, percentage: new BigNumber(20) }, // Duplicate
+          ],
+          targets: null,
+          defaultTaxWithholding: null,
+        })
+      ).rejects.toMatchObject({
+        message: 'Identity included more than once in the tax withholding list',
+        data: {
+          identity: identity1,
+        },
+      });
+
+      asIdentitySpy.mockRestore();
+    });
+
+    it('should validate tax withholdings limit', async () => {
+      const proc = procedureMockUtils.getInstance<Params, CorporateAction>(mockContext);
+
+      const identity1 = entityMockUtils.getIdentityInstance({ did: 'did1' });
+      const identity2 = entityMockUtils.getIdentityInstance({ did: 'did2' });
+
+      const asIdentitySpy = jest.spyOn(utilsInternalModule, 'asIdentity');
+      when(asIdentitySpy).calledWith(identity1, mockContext).mockReturnValue(identity1);
+      when(asIdentitySpy).calledWith(identity2, mockContext).mockReturnValue(identity2);
+
+      // Set maxDidWhts to 1, but provide 2 tax withholdings
+      dsMockUtils.setConstMock('corporateAction', 'maxDidWhts', {
+        returnValue: dsMockUtils.createMockU32(new BigNumber(1)),
+      });
+
+      await expect(
+        prepareInitiateCorporateAction.call(proc, {
+          asset,
+          declarationDate,
+          description,
+          kind,
+          checkpoint,
+          taxWithholdings: [
+            { identity: identity1, percentage: new BigNumber(10) },
+            { identity: identity2, percentage: new BigNumber(20) },
+          ],
+          targets: null,
+          defaultTaxWithholding: null,
+        })
+      ).rejects.toThrow(); // Should throw from assertCaTaxWithholdingsValid
+
+      asIdentitySpy.mockRestore();
+    });
+  });
+
   describe('initiateCorporateActionResolver', () => {
     let filterEventRecordsSpy: jest.SpyInstance;
     let getCorporateActionWithDescriptionSpy: jest.SpyInstance;

src/api/procedures/initiateCorporateAction.ts

@@ -1,5 +1,6 @@
 import { ISubmittableResult } from '@polkadot/types/types';
 
+import { assertCaTaxWithholdingsValid } from '~/api/procedures/utils';
 import {
   Checkpoint,
   CheckpointSchedule,
@@ -132,8 +133,10 @@ export async function prepareInitiateCorporateAction(
     defaultTaxWithholding,
   } = args;
 
+  // Validate declarationDate is in the past
   assertDeclarationDate(declarationDate);
 
+  // Validate checkpoint/recordDate
   let checkpointValue: Checkpoint | CheckpointSchedule | Date | null = null;
 
   if (checkpoint) {
@@ -142,6 +145,7 @@ export async function prepareInitiateCorporateAction(
     await assertCheckpointValue(checkpointValue);
   }
 
+  // Validate details length (max_details_length)
   const rawMaxDetailsLength = await query.corporateAction.maxDetailsLength();
   const maxDetailsLength = u32ToBigNumber(rawMaxDetailsLength);
 
@@ -156,6 +160,13 @@ export async function prepareInitiateCorporateAction(
     });
   }
 
+  // Validate targets limit (handled in targetsToTargetIdentities conversion)
+  // Validate withholding_tax: check limit and detect duplicates (chain throws error on duplicates)
+  if (taxWithholdings && taxWithholdings.length > 0) {
+    // Check limit and detect duplicates (assertCaTaxWithholdingsValid handles both)
+    assertCaTaxWithholdingsValid(taxWithholdings, context);
+  }
+
   const rawArgs = corporateActionParamsToMeshCorporateActionArgs(
     {
       asset,