feat: meta-pn

packages/advanced-logic/src/advanced-logic.ts

@@ -26,6 +26,7 @@ import AnyToNearTestnet from './extensions/payment-network/near/any-to-near-test
 import NativeToken from './extensions/payment-network/native-token';
 import AnyToNative from './extensions/payment-network/any-to-native';
 import Erc20TransferableReceivablePaymentNetwork from './extensions/payment-network/erc20/transferable-receivable';
+import MetaPaymentNetwork from './extensions/payment-network/meta';
 
 /**
  * Module to manage Advanced logic extensions
@@ -49,6 +50,7 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
     anyToEthProxy: AnyToEthProxy;
     anyToNativeToken: AnyToNative[];
     erc20TransferableReceivable: Erc20TransferableReceivablePaymentNetwork;
+    metaPn: MetaPaymentNetwork;
   };
 
   private currencyManager: CurrencyTypes.ICurrencyManager;
@@ -71,6 +73,7 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
       nativeToken: [new NearNative(currencyManager), new NearTestnetNative(currencyManager)],
       anyToNativeToken: [new AnyToNear(currencyManager), new AnyToNearTestnet(currencyManager)],
       erc20TransferableReceivable: new Erc20TransferableReceivablePaymentNetwork(currencyManager),
+      metaPn: new MetaPaymentNetwork(currencyManager),
     };
   }
 
@@ -131,6 +134,7 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
         this.getAnyToNativeTokenExtensionForNetwork(network),
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_TRANSFERABLE_RECEIVABLE]:
         this.extensions.erc20TransferableReceivable,
+      [ExtensionTypes.PAYMENT_NETWORK_ID.META]: this.extensions.metaPn,
     }[id];
 
     if (!extension) {
@@ -158,7 +162,9 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
 
   public getAnyToNativeTokenExtensionForNetwork(
     network?: CurrencyTypes.ChainName,
-  ): AnyToNative | undefined {
+  ):
+    | ExtensionTypes.IExtension<ExtensionTypes.PnAnyToAnyConversion.ICreationParameters>
+    | undefined {
     return network
       ? this.extensions.anyToNativeToken.find((anyToNativeTokenExtension) =>
           anyToNativeTokenExtension.supportedNetworks.includes(network),

packages/advanced-logic/src/extensions/abstract-extension.ts

@@ -1,6 +1,13 @@
 import { ExtensionTypes, IdentityTypes, RequestLogicTypes } from '@requestnetwork/types';
 import { deepCopy } from '@requestnetwork/utils';
 
+export interface ICreationContext {
+  extensionsState: RequestLogicTypes.IExtensionStates;
+  extensionAction: ExtensionTypes.IAction;
+  requestState: RequestLogicTypes.IRequest;
+  actionSigner: IdentityTypes.IIdentity;
+}
+
 /**
  * Abstract class to create extension
  */
@@ -60,7 +67,12 @@ export abstract class AbstractExtension<TCreationParameters> implements Extensio
         throw Error(`This extension has already been created`);
       }
 
-      copiedExtensionState[extensionAction.id] = this.applyCreation(extensionAction, timestamp);
+      copiedExtensionState[extensionAction.id] = this.applyCreation(extensionAction, timestamp, {
+        extensionsState,
+        extensionAction,
+        requestState,
+        actionSigner,
+      });
 
       return copiedExtensionState;
     }
@@ -99,6 +111,8 @@ export abstract class AbstractExtension<TCreationParameters> implements Extensio
     extensionAction: ExtensionTypes.IAction,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _timestamp: number,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    context?: ICreationContext,
   ): ExtensionTypes.IState {
     if (!extensionAction.version) {
       throw Error('version is required at creation');

packages/advanced-logic/src/extensions/payment-network/meta.ts

@@ -0,0 +1,239 @@
+import {
+  CurrencyTypes,
+  ExtensionTypes,
+  IdentityTypes,
+  RequestLogicTypes,
+} from '@requestnetwork/types';
+import { ICreationContext } from '../abstract-extension';
+import AnyToErc20ProxyPaymentNetwork from './any-to-erc20-proxy';
+import AnyToEthProxyPaymentNetwork from './any-to-eth-proxy';
+import { deepCopy } from '@requestnetwork/utils';
+import DeclarativePaymentNetwork from './declarative';
+
+const CURRENT_VERSION = '0.1.0';
+
+export default class MetaPaymentNetwork<
+  TCreationParameters extends
+    ExtensionTypes.PnMeta.ICreationParameters = ExtensionTypes.PnMeta.ICreationParameters,
+> extends DeclarativePaymentNetwork<TCreationParameters> {
+  public constructor(
+    protected currencyManager: CurrencyTypes.ICurrencyManager,
+    public extensionId: ExtensionTypes.PAYMENT_NETWORK_ID = ExtensionTypes.PAYMENT_NETWORK_ID.META,
+    public currentVersion: string = CURRENT_VERSION,
+  ) {
+    super(extensionId, currentVersion);
+    this.actions = {
+      ...this.actions,
+      [ExtensionTypes.PnMeta.ACTION.APPLY_ACTION_TO_PN]:
+        this.applyApplyActionToExtension.bind(this),
+    };
+  }
+
+  /**
+   * Creates the extensionsData to create the meta extension payment detection
+   *
+   * @param creationParameters extensions parameters to create
+   *
+   * @returns IExtensionCreationAction the extensionsData to be stored in the request
+   */
+  public createCreationAction(
+    creationParameters: TCreationParameters,
+  ): ExtensionTypes.IAction<TCreationParameters> {
+    Object.entries(creationParameters).forEach(([pnId, creationParameters]) => {
+      const pn = this.getExtension(pnId);
+      const subPnIdentifiers: string[] = [];
+
+      // Perform validation on sub-pn creation parameters
+      for (const param of creationParameters) {
+        pn.createCreationAction(param);
+        if (subPnIdentifiers.includes(param.salt)) {
+          throw new Error('Duplicate payment network identifier (salt)');
+        }
+        subPnIdentifiers.push(param.salt);
+      }
+    });
+
+    return super.createCreationAction(creationParameters);
+  }
+
+  /**
+   * Creates the extensionsData to perform an action on a sub-pn
+   *
+   * @param parameters parameters to create the action to perform
+   *
+   * @returns IAction the extensionsData to be stored in the request
+   */
+  public createApplyActionToPn(
+    parameters: ExtensionTypes.PnMeta.IApplyActionToPn,
+  ): ExtensionTypes.IAction {
+    return {
+      action: ExtensionTypes.PnMeta.ACTION.APPLY_ACTION_TO_PN,
+      id: this.extensionId,
+      parameters: {
+        pnIdentifier: parameters.pnIdentifier,
+        action: parameters.action,
+        parameters: parameters.parameters,
+      },
+    };
+  }
+
+  /**
+   * Applies a creation extension action
+   *
+   * @param extensionAction action to apply
+   * @param timestamp action timestamp
+   *
+   * @returns state of the extension created
+   */
+  protected applyCreation(
+    extensionAction: ExtensionTypes.IAction,
+    timestamp: number,
+    context?: ICreationContext,
+  ): ExtensionTypes.IState {
+    if (!context) {
+      throw new Error('Context is required');
+    }
+    const values: Record<string, ExtensionTypes.IState> = {};
+    Object.entries(extensionAction.parameters).forEach(([pnId, parameters]) => {
+      const pn = this.getExtension(pnId);
+
+      (parameters as any[]).forEach((params) => {
+        values[params.salt] = pn.applyActionToExtension(
+          {},
+          {
+            action: 'create',
+            id: pnId as ExtensionTypes.PAYMENT_NETWORK_ID,
+            parameters: params,
+            version: pn.currentVersion,
+          },
+          context.requestState,
+          context.actionSigner,
+          timestamp,
+        )[pnId];
+      });
+    });
+
+    return {
+      ...super.applyCreation(extensionAction, timestamp),
+      events: [
+        {
+          name: 'create',
+          parameters: {
+            ...extensionAction.parameters,
+          },
+          timestamp,
+        },
+      ],
+      values,
+    };
+  }
+
+  /** Applies an action on a sub-payment network
+   *
+   * @param extensionsState previous state of the extensions
+   * @param extensionAction action to apply
+   * @param requestState request state read-only
+   * @param actionSigner identity of the signer
+   * @param timestamp timestamp of the action
+   *
+   * @returns state of the extension created
+   */
+  protected applyApplyActionToExtension(
+    extensionState: ExtensionTypes.IState,
+    extensionAction: ExtensionTypes.IAction,
+    requestState: RequestLogicTypes.IRequest,
+    actionSigner: IdentityTypes.IIdentity,
+    timestamp: number,
+  ): ExtensionTypes.IState {
+    const copiedExtensionState: ExtensionTypes.IState<any> = deepCopy(extensionState);
+    const { pnIdentifier, action, parameters } = extensionAction.parameters;
+    const extensionToActOn: ExtensionTypes.IState = copiedExtensionState.values[pnIdentifier];
+
+    const pn = this.getExtension(extensionToActOn.id);
+
+    const subExtensionState = {
+      [extensionToActOn.id]: extensionToActOn,
+    };
+
+    copiedExtensionState.values[pnIdentifier] = pn.applyActionToExtension(
+      subExtensionState,
+      {
+        id: extensionToActOn.id,
+        action,
+        parameters,
+      },
+      requestState,
+      actionSigner,
+      timestamp,
+    )[extensionToActOn.id];
+
+    // update events
+    copiedExtensionState.events.push({
+      name: ExtensionTypes.PnMeta.ACTION.APPLY_ACTION_TO_PN,
+      parameters: {
+        pnIdentifier,
+        action,
+        parameters,
+      },
+      timestamp,
+      from: actionSigner,
+    });
+    return copiedExtensionState;
+  }
+
+  /**
+   * Validate the extension action regarding the currency and network
+   * It must throw in case of error
+   */
+  protected validate(
+    request: RequestLogicTypes.IRequest,
+    extensionAction: ExtensionTypes.IAction,
+  ): void {
+    const pnIdentifiers: string[] = [];
+    if (extensionAction.action === ExtensionTypes.PnMeta.ACTION.CREATE) {
+      Object.entries(extensionAction.parameters).forEach(([pnId, parameters]: [string, any]) => {
+        // Checks that the PN is supported
+        this.getExtension(pnId);
+
+        if (parameters.action) {
+          throw new Error('Invalid action');
+        }
+
+        for (const param of parameters) {
+          if (pnIdentifiers.includes(param.salt)) {
+            throw new Error('Duplicate payment network identifier');
+          }
+          pnIdentifiers.push(param.salt);
+        }
+      });
+    } else if (extensionAction.action === ExtensionTypes.PnMeta.ACTION.APPLY_ACTION_TO_PN) {
+      const { pnIdentifier } = extensionAction.parameters;
+
+      const subPnState: ExtensionTypes.IState =
+        request.extensions[ExtensionTypes.PAYMENT_NETWORK_ID.META]?.values?.[pnIdentifier];
+      if (!subPnState) {
+        throw new Error(`No payment network with identifier ${pnIdentifier}`);
+      }
+
+      // Checks that the PN is supported
+      this.getExtension(subPnState.id);
+    }
+  }
+
+  private getExtension(pnId: string): ExtensionTypes.IExtension {
+    switch (pnId) {
+      case ExtensionTypes.PAYMENT_NETWORK_ID.ANY_DECLARATIVE: {
+        return new DeclarativePaymentNetwork();
+      }
+      case ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_ERC20_PROXY: {
+        return new AnyToErc20ProxyPaymentNetwork(this.currencyManager);
+      }
+      case ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_ETH_PROXY: {
+        return new AnyToEthProxyPaymentNetwork(this.currencyManager);
+      }
+      default: {
+        throw new Error(`Invalid PN: ${pnId}`);
+      }
+    }
+  }
+}

packages/advanced-logic/test/extensions/payment-network/any-to-erc20-proxy.test.ts

@@ -353,7 +353,7 @@ describe('extensions/payment-network/erc20/any-to-erc20-fee-proxy-contract', ()
             TestData.otherIdRaw.identity,
             TestData.arbitraryTimestamp,
           ),
-        ).toEqual(DataConversionERC20FeeCreate.extensionFullState);
+        ).toEqual(DataConversionERC20FeeCreate.extensionFullState());
       });
 
       it('can applyActionToExtensions of creation when address is checksumed', () => {
@@ -372,7 +372,7 @@ describe('extensions/payment-network/erc20/any-to-erc20-fee-proxy-contract', ()
             TestData.otherIdRaw.identity,
             TestData.arbitraryTimestamp,
           ),
-        ).toEqual(DataConversionERC20FeeCreate.extensionFullState);
+        ).toEqual(DataConversionERC20FeeCreate.extensionFullState());
       });
 
       it('cannot applyActionToExtensions of creation with a previous state', () => {