feat: make event listener use an action repository so action definitions are extensible on machine construction and referenceable in machine definition

Author: FedericoAmura

packages/event-listener/src/index.ts

@@ -1,3 +1,4 @@
+export * from './lib/actions';
 export * from './lib/listeners';
 export * from './lib/states';
 export * from './lib/state-machine';

packages/event-listener/src/lib/actions/index.ts

@@ -1,5 +1,18 @@
+import { LitActionAction } from './lit-action';
+import { LogContextAction } from './log-context';
+import { MintPkpAction } from './mint-pkp';
+import { TransactionAction } from './transaction';
+import { ActionConstructor } from '../types';
+
 export * from './action';
 export * from './lit-action';
 export * from './log-context';
 export * from './mint-pkp';
 export * from './transaction';
+
+export const ACTION_REPOSITORY: Record<string, ActionConstructor> = {
+  context: LogContextAction,
+  litAction: LitActionAction,
+  transaction: TransactionAction,
+  usePkp: MintPkpAction,
+};

packages/event-listener/src/lib/state-machine.ts

@@ -9,13 +9,7 @@ import { LitContracts } from '@lit-protocol/contracts-sdk';
 import { LitNodeClient } from '@lit-protocol/lit-node-client';
 import { logger } from '@lit-protocol/logger';
 
-import {
-  Action,
-  LitActionAction,
-  LogContextAction,
-  MintPkpAction,
-  TransactionAction,
-} from './actions';
+import { Action, ACTION_REPOSITORY } from './actions';
 import { MachineContext } from './context/machine-context';
 import {
   ContractEventData,
@@ -27,6 +21,7 @@ import {
 import { State, StateParams } from './states';
 import { CheckFn, Transition } from './transitions';
 import {
+  ActionConstructor,
   ActionDefinition,
   BaseStateMachineParams,
   ContextOrLiteral,
@@ -60,6 +55,7 @@ export class StateMachine {
 
   public id: string;
   public status: MachineStatus = 'stopped';
+  private readonly actionsRepository: Record<string, ActionConstructor>;
   private states = new Map<string, State>();
   private transitions = new Map<string, Map<string, Transition>>();
   private currentState?: State;
@@ -74,6 +70,10 @@ export class StateMachine {
       ...params.context,
     });
 
+    this.actionsRepository = {
+      ...ACTION_REPOSITORY,
+      ...params.actionRepository,
+    };
     this.litNodeClient = params.litNodeClient;
     this.litContracts = params.litContracts;
     this.privateKey = params.privateKey;
@@ -125,6 +125,10 @@ export class StateMachine {
       litContracts: litContractsInstance,
       privateKey,
       onError,
+      actionRepository: {
+        ...ACTION_REPOSITORY,
+        ...machineConfig.actionRepository,
+      },
     });
 
     const stateTransitions = [] as TransitionDefinition[];
@@ -571,66 +575,18 @@ export class StateMachine {
   ): voidAsyncFunction {
     const actions = [] as Action[];
 
-    actionDefinitions.forEach((action) => {
-      switch (action.key) {
-        case 'context':
-          if (typeof action.log?.path === 'string') {
-            actions.push(
-              new LogContextAction({
-                debug: this.debug,
-                stateMachine: this,
-                path: action.log.path,
-              })
-            );
-          }
-          break;
-        case 'litAction':
-          actions.push(
-            new LitActionAction({
-              debug: this.debug,
-              stateMachine: this,
-              ...action,
-            })
-          );
-          break;
-        case 'transaction':
-          actions.push(
-            new TransactionAction({
-              debug: this.debug,
-              stateMachine: this,
-              ...action,
-            })
-          );
-          break;
-        case 'usePkp':
-          if ('pkp' in action) {
-            this.context.set(
-              'activePkp',
-              this.resolveContextPathOrLiteral(action.pkp)
-            );
-          } else if ('mint' in action) {
-            const mintPkpAction = new MintPkpAction({
-              debug: this.debug,
-              stateMachine: this,
-            });
-            actions.push(mintPkpAction);
-          }
-          if (this.debug) {
-            const activePkp = this.context.get('activePkp');
-            logger.info(`Machine configured to use pkp ${activePkp}`);
-          }
-          break;
-        default:
-          throw new AutomationError(
-            {
-              info: {
-                action,
-              },
-            },
-            `Unknown action. Check error info.`
-          );
+    for (const action of actionDefinitions) {
+      const ActionCtor = this.actionsRepository[action.key];
+      if (!ActionCtor) {
+        throw new AutomationError(
+          { info: { action } },
+          `Action key "${action.key}" not found in action repository`
+        );
       }
-    });
+      actions.push(
+        new ActionCtor({ debug: this.debug, stateMachine: this, ...action })
+      );
+    }
 
     return async () => {
       await Promise.all(actions.map((action) => action.run())).catch((err) => {

packages/event-listener/src/lib/types.ts

@@ -3,6 +3,7 @@ import { ethers } from 'ethers';
 import { LitContracts } from '@lit-protocol/contracts-sdk';
 import { LitNodeClient } from '@lit-protocol/lit-node-client';
 
+import { Action, ActionParams } from './actions/action';
 import { BaseTransitionParams } from './transitions';
 
 export type Address = `0x${string}`;
@@ -35,6 +36,12 @@ export interface UpdatesContext {
 }
 
 // Action Types
+export type ActionConstructor = new (params: any) => Action;
+
+export interface RawActionDefinition extends ActionParams {
+  key: string;
+}
+
 export interface LitActionActionDefinition {
   key: 'litAction';
   code?: ContextOrLiteral<string>;
@@ -96,6 +103,7 @@ export interface UseCapacityNFTActionDefinition {
 }
 
 export type ActionDefinition =
+  | RawActionDefinition
   | ContextActionDefinition
   | LitActionActionDefinition
   | MintCapacityNFTActionDefinition
@@ -176,6 +184,7 @@ export interface TransitionParams
 
 // Machine Types
 export interface BaseStateMachineParams {
+  actionRepository?: Record<string, ActionConstructor>;
   context?: Record<string, unknown>;
   debug?: boolean;
   litContracts: LitContracts;