Model exact conversion trigger variants

package.json

@@ -51,11 +51,10 @@
     "test:coverage": "jest --coverage --passWithNoTests",
     "test:declarations": "ts-node --project tsconfig.tests.json scripts/check-declarations.ts && tsc -p tsconfig.declaration-tests.json --noEmit && npm run -s test:exact-public-config",
     "test:exact-public-config": "tsc -p tsconfig.exact-public-config-tests.json --noEmit",
-    "test:exact-source": "tsc -p tsconfig.exact-source.json --noEmit",
     "test:integration": "npm run -s typecheck && jest -c jest.integration.config.js --passWithNoTests",
     "test:integration:ci": "npm run -s typecheck && jest -c jest.integration.config.js --runInBand",
     "test:watch": "jest --watch",
-    "typecheck": "tsc -p tsconfig.tests.json --noEmit && npm run -s test:exact-source"
+    "typecheck": "tsc -p tsconfig.tests.json --noEmit"
   },
   "config": {
     "localnet_quickstart_ref": "5c90cf4d0eb934712fd8c269b56e6272b605ccad"

src/functions/OpenCapTable/convertibleIssuance/createConvertibleIssuance.ts

@@ -1,10 +1,7 @@
 import { type Fairmint } from '@fairmint/open-captable-protocol-daml-js';
 import { OcpErrorCodes, OcpParseError, OcpValidationError } from '../../../errors';
-import type {
-  ConversionTriggerFieldShape,
-  ConvertibleConversionTrigger,
-  OcfConvertibleIssuance,
-} from '../../../types/native';
+import type { ConvertibleConversionTrigger, OcfConvertibleIssuance } from '../../../types/native';
+import { assertUniqueConversionTriggerIds, parseConversionTriggerFields } from '../../../utils/conversionTriggers';
 import {
   dateStringToDAMLTime,
   isRecord,
@@ -57,18 +54,6 @@ const CONVERSION_RIGHT_FIELDS = [
   'converts_to_future_round',
   'converts_to_stock_class_id',
 ] as const;
-const TRIGGER_FIELDS = [
-  'type',
-  'trigger_id',
-  'conversion_right',
-  'nickname',
-  'trigger_description',
-  'trigger_date',
-  'trigger_condition',
-  'start_date',
-  'end_date',
-] as const;
-
 function requiredMissing(field: string, expectedType: string, receivedValue: unknown): OcpValidationError {
   return new OcpValidationError(field, `${field} is required`, {
     code: OcpErrorCodes.REQUIRED_FIELD_MISSING,
@@ -239,16 +224,20 @@ function triggerToDaml(
 ): Fairmint.OpenCapTable.OCF.ConvertibleIssuance.OcfConvertibleConversionTrigger {
   const source = `convertibleIssuance.conversion_triggers.${index}`;
   const trigger = requireRecord(value, source);
-  const nativeType = requireString(trigger.type, `${source}.type`) as ConvertibleConversionTrigger['type'];
-  assertExactObjectFields(trigger, TRIGGER_FIELDS, source);
-  const type = triggerTypeToDaml(nativeType, `${source}.type`);
-  const triggerFields = triggerFieldsToDaml(trigger as unknown as ConversionTriggerFieldShape, source);
+  const parsed = parseConversionTriggerFields(
+    {
+      ...trigger,
+      trigger_id: requireString(trigger.trigger_id, `${source}.trigger_id`),
+    },
+    source
+  );
+  const triggerFields = triggerFieldsToDaml(parsed, source);
   return {
-    type_: type,
-    trigger_id: requireString(trigger.trigger_id, `${source}.trigger_id`),
-    conversion_right: conversionRightToDaml(trigger.conversion_right, `${source}.conversion_right`),
-    nickname: optionalTextToDaml(trigger.nickname, `${source}.nickname`),
-    trigger_description: optionalTextToDaml(trigger.trigger_description, `${source}.trigger_description`),
+    type_: triggerTypeToDaml(parsed.type, `${source}.type`),
+    trigger_id: parsed.trigger_id,
+    conversion_right: conversionRightToDaml(parsed.conversion_right, `${source}.conversion_right`),
+    nickname: optionalTextToDaml(parsed.nickname, `${source}.nickname`),
+    trigger_description: optionalTextToDaml(parsed.trigger_description, `${source}.trigger_description`),
     ...triggerFields,
   };
 }
@@ -276,6 +265,12 @@ export function convertibleIssuanceDataToDaml(
     });
   }
   const triggers = requireNonEmptyArray(issuance.conversion_triggers, 'convertibleIssuance.conversion_triggers');
+  const damlTriggers = triggers.map(triggerToDaml);
+  assertUniqueConversionTriggerIds(
+    damlTriggers,
+    'convertibleIssuance.conversion_triggers',
+    OcpErrorCodes.INVALID_FORMAT
+  );
   return {
     id: requireString(issuance.id, 'convertibleIssuance.id'),
     date: requiredDateToDaml(issuance.date, 'convertibleIssuance.date'),
@@ -297,7 +292,7 @@ export function convertibleIssuanceDataToDaml(
     ),
     investment_amount: requiredMonetaryToDaml(issuance.investment_amount, 'convertibleIssuance.investment_amount'),
     convertible_type: convertibleTypeToDaml(issuance.convertible_type),
-    conversion_triggers: triggers.map(triggerToDaml),
+    conversion_triggers: damlTriggers,
     pro_rata: canonicalOptionalNumericToDaml(issuance.pro_rata, 'convertibleIssuance.pro_rata'),
     seniority: seniorityToDaml(issuance.seniority),
     comments: commentsToDaml(issuance.comments, 'convertibleIssuance.comments'),

src/functions/OpenCapTable/convertibleIssuance/getConvertibleIssuanceAsOcf.ts

@@ -8,6 +8,11 @@ import type {
   ConvertibleType,
   OcfConvertibleIssuance,
 } from '../../../types/native';
+import {
+  assertDamlConversionTriggerFieldNames,
+  assertUniqueConversionTriggerIds,
+  parseConversionTriggerFields,
+} from '../../../utils/conversionTriggers';
 import {
   damlTimeToDateString,
   isRecord,
@@ -153,20 +158,23 @@ function conversionRightFromDaml(value: unknown, field: string): ConvertibleConv
 }
 
 function conversionTriggerFromDaml(value: unknown, index: number): ConvertibleConversionTrigger {
-  const field = `convertibleIssuance.conversion_triggers.${index}`;
-  const trigger = requireRecord(value, field);
-  const nickname = optionalString(trigger.nickname, `${field}.nickname`);
-  const description = optionalString(trigger.trigger_description, `${field}.trigger_description`);
-  const typePath = `${field}.type_`;
+  const source = `convertibleIssuance.conversion_triggers.${index}`;
+  const trigger = requireRecord(value, source);
+  assertDamlConversionTriggerFieldNames(trigger, source);
+  const typePath = `${source}.type_`;
   const type = mapDamlTriggerTypeToOcf(requireString(trigger.type_, typePath), typePath);
-  const triggerFields = triggerFieldsFromDaml(trigger, type, field);
-  return {
-    ...triggerFields,
-    trigger_id: requireString(trigger.trigger_id, `${field}.trigger_id`),
-    conversion_right: conversionRightFromDaml(trigger.conversion_right, `${field}.conversion_right`),
-    ...(nickname ? { nickname } : {}),
-    ...(description ? { trigger_description: description } : {}),
-  };
+  const triggerFields = triggerFieldsFromDaml(trigger, type, source);
+  return parseConversionTriggerFields(
+    {
+      trigger_id: requireString(trigger.trigger_id, `${source}.trigger_id`),
+      conversion_right: conversionRightFromDaml(trigger.conversion_right, `${source}.conversion_right`),
+      nickname: trigger.nickname,
+      trigger_description: trigger.trigger_description,
+      ...triggerFields,
+    },
+    source,
+    { nullIsAbsent: true, unexpectedFieldCode: OcpErrorCodes.SCHEMA_MISMATCH }
+  );
 }
 
 function securityLawExemptionsFromDaml(value: unknown): Array<{ description: string; jurisdiction: string }> {
@@ -201,6 +209,11 @@ export function damlConvertibleIssuanceDataToNative(value: unknown): OcfConverti
     conversionTriggerFromDaml(firstConversionTrigger, 0),
     ...remainingConversionTriggers.map((trigger, index) => conversionTriggerFromDaml(trigger, index + 1)),
   ];
+  assertUniqueConversionTriggerIds(
+    nativeConversionTriggers,
+    'convertibleIssuance.conversion_triggers',
+    OcpErrorCodes.SCHEMA_MISMATCH
+  );
   const seniority = parseDamlSafeInteger(data.seniority, 'convertibleIssuance.seniority');
   const boardApprovalDate = optionalDamlTimeToDateString(
     data.board_approval_date,

src/functions/OpenCapTable/shared/triggerFields.ts

@@ -4,6 +4,7 @@ import type {
   ConversionTriggerFieldShapeFor,
   ConversionTriggerType,
 } from '../../../types/native';
+import { assertConversionTriggerRangeOrder } from '../../../utils/conversionTriggers';
 import { damlTimeToDateString, dateStringToDAMLTime } from '../../../utils/typeConversions';
 
 export type OcfTriggerDiscriminator = ConversionTriggerType;
@@ -145,11 +146,14 @@ export function triggerFieldsToDaml(input: ConversionTriggerFieldShape, basePath
       };
     case 'ELECTIVE_IN_RANGE':
       rejectInputFields(input, ['trigger_date', 'trigger_condition'], input.type, basePath);
+      const startDate = requiredDateToDaml(input.start_date, basePath, 'start_date');
+      const endDate = requiredDateToDaml(input.end_date, basePath, 'end_date');
+      assertConversionTriggerRangeOrder(startDate, endDate, basePath, OcpErrorCodes.INVALID_FORMAT);
       return {
         trigger_date: null,
         trigger_condition: null,
-        start_date: requiredDateToDaml(input.start_date, basePath, 'start_date'),
-        end_date: requiredDateToDaml(input.end_date, basePath, 'end_date'),
+        start_date: startDate,
+        end_date: endDate,
       };
     case 'AUTOMATIC_ON_CONDITION':
     case 'ELECTIVE_ON_CONDITION':
@@ -187,10 +191,13 @@ export function triggerFieldsFromDaml(
       };
     case 'ELECTIVE_IN_RANGE':
       rejectDamlFields(input, ['trigger_date', 'trigger_condition'], type, basePath);
+      const startDate = requiredDateFromDaml(input.start_date, basePath, 'start_date');
+      const endDate = requiredDateFromDaml(input.end_date, basePath, 'end_date');
+      assertConversionTriggerRangeOrder(startDate, endDate, basePath, OcpErrorCodes.SCHEMA_MISMATCH);
       return {
         type,
-        start_date: requiredDateFromDaml(input.start_date, basePath, 'start_date'),
-        end_date: requiredDateFromDaml(input.end_date, basePath, 'end_date'),
+        start_date: startDate,
+        end_date: endDate,
       };
     case 'AUTOMATIC_ON_CONDITION':
     case 'ELECTIVE_ON_CONDITION':

src/functions/OpenCapTable/warrantIssuance/createWarrantIssuance.ts

@@ -1,12 +1,14 @@
 import { type Fairmint } from '@fairmint/open-captable-protocol-daml-js';
 import { OcpErrorCodes, OcpParseError, OcpValidationError } from '../../../errors';
 import type {
+  ConversionTriggerFor,
   ConvertibleConversionMechanism,
   PersistedOcfWarrantIssuance,
   PersistedStockClassRatioConversionMechanism,
   PersistedWarrantConversionMechanism,
   PersistedWarrantExerciseTrigger,
 } from '../../../types/native';
+import { assertUniqueConversionTriggerIds, parseConversionTriggerFields } from '../../../utils/conversionTriggers';
 import {
   dateStringToDAMLTime,
   isRecord,
@@ -72,17 +74,6 @@ const CONVERSION_RIGHT_FIELDS = [
   'converts_to_future_round',
   'converts_to_stock_class_id',
 ] as const;
-const TRIGGER_FIELDS = [
-  'type',
-  'trigger_id',
-  'conversion_right',
-  'nickname',
-  'trigger_description',
-  'trigger_date',
-  'trigger_condition',
-  'start_date',
-  'end_date',
-] as const;
 
 function requiredMissing(field: string, expectedType: string, receivedValue: unknown): OcpValidationError {
   return new OcpValidationError(field, `${field} is required`, {
@@ -257,14 +248,13 @@ function requireStockClassTarget(value: unknown, field: string): string {
 }
 
 function storageTrigger(
-  trigger: Record<string, unknown>,
-  triggerType: PersistedWarrantExerciseTrigger['type'],
+  trigger: ConversionTriggerFor<unknown>,
   convertsToStockClassId: string,
   source: string
 ): Fairmint.OpenCapTable.Types.Conversion.OcfConversionTrigger {
-  const triggerFields = triggerFieldsToDaml(trigger as unknown as PersistedWarrantExerciseTrigger, source);
+  const triggerFields = triggerFieldsToDaml(trigger, source);
   return {
-    type_: triggerTypeToDaml(triggerType, `${source}.type`),
+    type_: triggerTypeToDaml(trigger.type, `${source}.type`),
     trigger_id: requireString(trigger.trigger_id, `${source}.trigger_id`),
     nickname: optionalTextToDaml(trigger.nickname, `${source}.nickname`),
     trigger_description: optionalTextToDaml(trigger.trigger_description, `${source}.trigger_description`),
@@ -285,8 +275,7 @@ function storageTrigger(
 }
 
 function stockClassRightToDaml(
-  trigger: Record<string, unknown>,
-  triggerType: PersistedWarrantExerciseTrigger['type'],
+  trigger: ConversionTriggerFor<unknown>,
   right: Record<string, unknown>,
   source: string,
   triggerSource: string
@@ -304,7 +293,7 @@ function stockClassRightToDaml(
     value: {
       type_: 'STOCK_CLASS_CONVERSION_RIGHT',
       conversion_mechanism: mechanism.conversion_mechanism,
-      conversion_trigger: storageTrigger(trigger, triggerType, convertsToStockClassId, triggerSource),
+      conversion_trigger: storageTrigger(trigger, convertsToStockClassId, triggerSource),
       converts_to_stock_class_id: convertsToStockClassId,
       ratio: mechanism.ratio,
       conversion_price: mechanism.conversion_price,
@@ -326,8 +315,7 @@ function stockClassRightToDaml(
 }
 
 function conversionRightToDaml(
-  trigger: Record<string, unknown>,
-  triggerType: PersistedWarrantExerciseTrigger['type'],
+  trigger: ConversionTriggerFor<unknown>,
   source: string,
   triggerSource: string
 ): Fairmint.OpenCapTable.Types.Conversion.OcfAnyConversionRight {
@@ -374,7 +362,7 @@ function conversionRightToDaml(
         },
       };
     case 'STOCK_CLASS_CONVERSION_RIGHT':
-      return stockClassRightToDaml(trigger, triggerType, right, source, triggerSource);
+      return stockClassRightToDaml(trigger, right, source, triggerSource);
     default:
       throw new OcpParseError(`Unknown warrant conversion right type: ${rightType}`, {
         source: `${source}.type`,
@@ -386,16 +374,14 @@ function conversionRightToDaml(
 function triggerToDaml(value: unknown, index: number): Fairmint.OpenCapTable.Types.Conversion.OcfConversionTrigger {
   const source = `warrantIssuance.exercise_triggers.${index}`;
   const trigger = requireRecord(value, source);
-  const nativeType = requireString(trigger.type, `${source}.type`) as PersistedWarrantExerciseTrigger['type'];
-  assertExactObjectFields(trigger, TRIGGER_FIELDS, source);
-  const type = triggerTypeToDaml(nativeType, `${source}.type`);
-  const triggerFields = triggerFieldsToDaml(trigger as unknown as PersistedWarrantExerciseTrigger, source);
+  const parsed = parseConversionTriggerFields(trigger, source);
+  const triggerFields = triggerFieldsToDaml(parsed, source);
   return {
-    type_: type,
-    trigger_id: requireString(trigger.trigger_id, `${source}.trigger_id`),
-    conversion_right: conversionRightToDaml(trigger, nativeType, `${source}.conversion_right`, source),
-    nickname: optionalTextToDaml(trigger.nickname, `${source}.nickname`),
-    trigger_description: optionalTextToDaml(trigger.trigger_description, `${source}.trigger_description`),
+    type_: triggerTypeToDaml(parsed.type, `${source}.type`),
+    trigger_id: parsed.trigger_id,
+    conversion_right: conversionRightToDaml(parsed, `${source}.conversion_right`, source),
+    nickname: optionalTextToDaml(parsed.nickname, `${source}.nickname`),
+    trigger_description: optionalTextToDaml(parsed.trigger_description, `${source}.trigger_description`),
     ...triggerFields,
   };
 }
@@ -419,6 +405,8 @@ export function warrantIssuanceDataToDaml(
       ? quantitySourceToDaml('UNSPECIFIED')
       : quantitySourceToDaml(issuance.quantity_source);
   const triggers = requireArray(issuance.exercise_triggers, 'warrantIssuance.exercise_triggers');
+  const damlTriggers = triggers.map(triggerToDaml);
+  assertUniqueConversionTriggerIds(damlTriggers, 'warrantIssuance.exercise_triggers', OcpErrorCodes.INVALID_FORMAT);
   const vestings = optionalArray(issuance.vestings, 'warrantIssuance.vestings');
 
   return {
@@ -444,7 +432,7 @@ export function warrantIssuanceDataToDaml(
     quantity_source: quantitySource,
     exercise_price: optionalMonetaryToDaml(issuance.exercise_price, 'warrantIssuance.exercise_price'),
     purchase_price: requiredMonetaryToDaml(issuance.purchase_price, 'warrantIssuance.purchase_price'),
-    exercise_triggers: triggers.map(triggerToDaml),
+    exercise_triggers: damlTriggers,
     warrant_expiration_date: optionalDateStringToDAMLTime(
       issuance.warrant_expiration_date,
       'warrantIssuance.warrant_expiration_date'