@guardian-network/policy-intermediate-representation 0.3.2

package/src/ir-notation/helpers/validation/typing.validation.ts

@@ -0,0 +1,89 @@
+import {
+  MinArbitraryDataArtifactFactory,
+  MinTypedValue,
+  NodeTreeInitData as ParsingResult,
+} from '@guardian-network/shared';
+import { ContractRunner } from 'ethers';
+import { ErrorFactory } from '../../errors';
+import { DSLTypesToIRTypes } from '../formatters';
+
+type InitExecArgumentsConfig = {
+  execArguments: Array<MinTypedValue>;
+  initArguments: Array<MinTypedValue>;
+};
+
+export const dslTypesToOnchainTypesParamsValidation =
+  (provider: ContractRunner) =>
+  async (
+    artifactAddress: string,
+    initExecArgumentsConfig: InitExecArgumentsConfig,
+  ) => {
+    const instance = MinArbitraryDataArtifactFactory.connect(
+      artifactAddress,
+      provider,
+    );
+
+    const { argsNames, argsTypes } = await instance.getExecDescriptor();
+
+    const { argsNames: initArgsNames, argsTypes: initArgsTypes } =
+      await instance.getInitDescriptor();
+
+    for (let i = 0; i < initArgsNames.length; i++) {
+      const mirroredDslParameter = initExecArgumentsConfig.initArguments[i];
+      const parsedType = DSLTypesToIRTypes(mirroredDslParameter.type);
+      if (initArgsTypes[i] !== parsedType) {
+        throw ErrorFactory.initTypesNotMacth(
+          mirroredDslParameter.value,
+          initArgsNames[i],
+          initArgsTypes[i],
+          parsedType,
+        );
+      }
+    }
+
+    for (let i = 0; i < argsNames.length; i++) {
+      const mirroredDslParameter = initExecArgumentsConfig.execArguments[i];
+      const parsedType = DSLTypesToIRTypes(mirroredDslParameter.type);
+      if (argsTypes[i] !== parsedType) {
+        throw ErrorFactory.execTypesNotMacth(
+          mirroredDslParameter.value,
+          argsNames[i],
+          argsTypes[i],
+          parsedType,
+        );
+      }
+    }
+  };
+
+export const onchainSubstitutionToReturnTypesValidation =
+  (provider: ContractRunner) => async (output: ParsingResult[]) => {
+    for (const instance of output) {
+      const currentInstance = MinArbitraryDataArtifactFactory.connect(
+        <string>instance.artifactAddress,
+        provider,
+      );
+
+      for (const refNode of instance.substitutedExecArgs) {
+        const refDeclaration = output.find(
+          (el) => el.id == refNode.supplierNodeId,
+        )!;
+        const refArtifactInstance = MinArbitraryDataArtifactFactory.connect(
+          <string>refDeclaration?.artifactAddress,
+          provider,
+        );
+
+        const { returnType } = await refArtifactInstance.getExecDescriptor();
+        const { argsTypes, argsNames } =
+          await currentInstance.getExecDescriptor();
+
+        if (!(argsTypes[Number(refNode.index)] == returnType))
+          throw ErrorFactory.substitutionTypesNotMatch(
+            <string>instance.id,
+            argsNames[Number(refNode.index)],
+            argsTypes[Number(refNode.index)],
+            <string>refNode.supplierNodeId,
+            returnType,
+          );
+      }
+    }
+  };

package/src/ir-notation/parser/index.ts

@@ -0,0 +1,10 @@
+export {
+  ParserWithValidation,
+  SimplifiedParser,
+  StaticParser,
+} from './parser-contracts';
+export {
+  parseIRByDSLTypesWithInterceptor,
+  parseIRByOnchainTypesWithInterceptor,
+} from './parser.unvalidated';
+export { getIRParser, getIRParserUnvalidate } from './parser.validated';

package/src/ir-notation/parser/parser-contracts/ParserWithValidation.ts

@@ -0,0 +1,99 @@
+import {
+  LacLangCompilerOptions as CompilerConfiguration,
+  InstanceConfig,
+  TranspilerOutput,
+} from '@guardian-network/shared';
+import { ContractRunner } from 'ethers';
+import { TypingsValidator } from '../parser.validated';
+import { ValidationMiddlware } from '../types';
+import { SimplifiedParser } from './SimplifiedParser';
+import { DSLConfigArgsTypesSource, createOrInferTypesSource } from './tools';
+import { GetTypesValues } from './types';
+
+export class ParserWithValidation extends SimplifiedParser {
+  static fromOnchainSource = (
+    intermediatePresentation: string,
+    provider: ContractRunner,
+  ): ParserWithValidation => {
+    const middleware = TypingsValidator(provider);
+
+    const getTypesSource = createOrInferTypesSource(provider);
+
+    return this.create(intermediatePresentation, getTypesSource, middleware);
+  };
+
+  static fromDSLBasedConfig = (
+    intermediatePresentation: string,
+    artifactConfigsList: Array<InstanceConfig>,
+    provider?: ContractRunner,
+  ) => {
+    let middleware: ValidationMiddlware | undefined;
+    if (!!provider) {
+      middleware = TypingsValidator(provider);
+    }
+
+    const getTypesSource = DSLConfigArgsTypesSource.build(artifactConfigsList);
+
+    return this.create(
+      intermediatePresentation,
+      getTypesSource.getTypes,
+      middleware,
+    );
+  };
+
+  static fromCompilerConfiguration = (
+    config: CompilerConfiguration,
+    {
+      ir: intermediatePresentation,
+      typings: artifactConfigsList,
+    }: Pick<TranspilerOutput, 'ir' | 'typings'>,
+  ): ParserWithValidation => {
+    const {
+      checkTypesAgainstDslDeclarations,
+      checkTypesAgainstOnchainDescriptors,
+      provider,
+    } = config;
+    const isProvider = !!provider;
+
+    if (!!checkTypesAgainstDslDeclarations) {
+      return this.fromDSLBasedConfig(
+        intermediatePresentation,
+        artifactConfigsList,
+        provider,
+      );
+    }
+
+    if (!!checkTypesAgainstOnchainDescriptors) {
+      if (!isProvider) throw new Error(`Parser: provider not supplied`);
+
+      return this.fromOnchainSource(intermediatePresentation, provider);
+    }
+
+    return this.fromDSLBasedConfig(
+      intermediatePresentation,
+      artifactConfigsList,
+    );
+  };
+
+  static create = (
+    intermediatePresentation: string,
+    getTypesSource: GetTypesValues,
+    middleware?: ValidationMiddlware,
+  ): ParserWithValidation => {
+    return new ParserWithValidation(
+      getTypesSource,
+      intermediatePresentation,
+      middleware,
+    );
+  };
+
+  // note: This expects String of intermediate-representation of artifacts and their relations.
+  // The string value is validated in ParserBase, Extractor
+  constructor(
+    getTypesSource: GetTypesValues,
+    intermediatePresentation: string,
+    private middleware?: ValidationMiddlware,
+  ) {
+    super(getTypesSource, intermediatePresentation);
+  }
+}

package/src/ir-notation/parser/parser-contracts/SimplifiedParser.ts

@@ -0,0 +1,41 @@
+import { ContractRunner } from 'ethers';
+import { ParsingResult } from '../types';
+import { ParserBase } from './base/ParserBase';
+import { createOrInferTypesSource, toUnprocessedArtifactsList } from './tools';
+import { GetTypesValues, IArgsTypesSource } from './types';
+
+export class SimplifiedParser {
+  static build = (
+    intermediatePresentation: string,
+    providerOrSource: ContractRunner | IArgsTypesSource,
+  ): SimplifiedParser => {
+    const getTypesSource = createOrInferTypesSource(providerOrSource);
+
+    return new SimplifiedParser(getTypesSource, intermediatePresentation);
+  };
+
+  // note: This expects String of intermediate-representation of artifacts and their relations.
+  // The string value is validated in ParserBase, Extractor
+  constructor(
+    protected getTypesSource: GetTypesValues,
+    protected intermediatePresentation: string,
+  ) {}
+
+  protected get unprocessedArtifacts(): Array<string> {
+    return toUnprocessedArtifactsList(this.intermediatePresentation);
+  }
+
+  // note:
+  // a. When processed it basically returns a List of 'NodeInitDataStruct' matching
+  // the interface requirements of onchain artifacts declaration
+  // b. Each List entry includes the values of [constants-data], [substitutions-data], [init-data], [runtime-supplied-params-indices]
+  // and other related data of Artifact.
+  process = async (): Promise<Array<ParsingResult>> => {
+    const processPromises = this.unprocessedArtifacts.map((v, i) =>
+      ParserBase.processSingleWithId(v, i, this.getTypesSource),
+    );
+
+    const processedArtifacts = await Promise.all(processPromises);
+    return processedArtifacts;
+  };
+}

package/src/ir-notation/parser/parser-contracts/StaticParser.ts

@@ -0,0 +1,25 @@
+import { ContractRunner } from 'ethers';
+import { ParsingResult } from '../types';
+import { ParserBase } from './base/ParserBase';
+import { createOrInferTypesSource, toUnprocessedArtifactsList } from './tools';
+import { IArgsTypesSource } from './types';
+
+export class StaticParser {
+  static process = async (
+    intermediatePresentation: string,
+    providerOrSource: ContractRunner | IArgsTypesSource,
+  ): Promise<Array<ParsingResult>> => {
+    const unprocessedArtifacts = toUnprocessedArtifactsList(
+      intermediatePresentation,
+    );
+
+    const getTypesSource = createOrInferTypesSource(providerOrSource);
+
+    const processPromises = unprocessedArtifacts.map((v, i) =>
+      ParserBase.processSingleWithId(v, i, getTypesSource),
+    );
+
+    const processedArtifacts = await Promise.all(processPromises);
+    return processedArtifacts;
+  };
+}

package/src/ir-notation/parser/parser-contracts/base/ParserBase.ts

@@ -0,0 +1,79 @@
+import { NodeId } from '@guardian-network/shared';
+import { ParsingResult } from '../../types';
+import { ParamsExtractor } from '../tools';
+import {
+  GetTypesValues,
+  NormalizedExecParameter,
+  SubstitutingParameter,
+} from '../types';
+
+export class ParserBase {
+  static processSingle = async (
+    unprocessedArtifact: string,
+    getTypesSource: GetTypesValues,
+    pos?: number,
+  ) => {
+    // note: wrapper is kinda temporaty solution;
+    // todo: re-design Parser class to support 'IGetArgsTypes' a bit smootherly
+    const getTypesSourceAtIndex = (param: string) => getTypesSource(param, pos);
+
+    const exctractionHandler = ParamsExtractor.build(
+      unprocessedArtifact,
+      getTypesSourceAtIndex,
+    );
+
+    const extractedData = await exctractionHandler.artifactData();
+
+    const {
+      artifactAddress,
+      argsCount,
+      execKnownParamsList,
+      execRuntimeVariablesIndices,
+      execRuntimeVariablesInjectionsWithIndices,
+      execSubstitutionParamsList,
+      initDataParamsSolidityPacked,
+      needsInitialization,
+    } = extractedData;
+
+    const processedArtifact: Omit<ParsingResult, 'id'> = {
+      artifactAddress,
+      constantExecArgs: execKnownParamsList,
+      variableExecArgs: execRuntimeVariablesIndices,
+      injections: execRuntimeVariablesInjectionsWithIndices,
+      argsCount,
+      substitutedExecArgs: execSubstitutionParamsList.map(toRegularParam),
+      initData: initDataParamsSolidityPacked,
+      needsInitialization,
+    };
+
+    return processedArtifact;
+  };
+
+  static processSingleWithId = async (
+    unprocessedArtifact: string,
+    salt: number,
+    getTypesSource: GetTypesValues,
+  ): Promise<ParsingResult> => {
+    const nodeId = NodeId.fromNotation(unprocessedArtifact, salt);
+    const processed = await this.processSingle(
+      unprocessedArtifact,
+      getTypesSource,
+      salt,
+    );
+
+    return {
+      id: nodeId,
+      ...processed,
+    };
+  };
+}
+
+const toRegularParam = ({
+  from,
+  atPos,
+}: SubstitutingParameter): NormalizedExecParameter => {
+  return {
+    supplierNodeId: from,
+    index: atPos,
+  };
+};

package/src/ir-notation/parser/parser-contracts/guards.ts

@@ -0,0 +1,17 @@
+import { ContractRunner } from 'ethers';
+import { SupportedSolidityTypesEnum } from './types';
+
+export const isSupportedSolidityType = (
+  value: string,
+): value is SupportedSolidityTypesEnum => {
+  const isType = Object.values(SupportedSolidityTypesEnum).includes(
+    value as any,
+  );
+  return isType;
+};
+
+export const isContractProviderType = (
+  value: Object,
+): value is ContractRunner => {
+  return 'provider' in value;
+};

package/src/ir-notation/parser/parser-contracts/index.ts

@@ -0,0 +1,7 @@
+export { ParserWithValidation } from './ParserWithValidation';
+export { SimplifiedParser } from './SimplifiedParser';
+export { StaticParser } from './StaticParser';
+export {
+  DSLConfigArgsTypesSource,
+  OnchainDescriptorArgsTypesSource,
+} from './tools';

package/src/ir-notation/parser/parser-contracts/tools/ParamsExtractor.ts

@@ -0,0 +1,251 @@
+import { getAddress } from 'ethers';
+import {
+  ArtifactData,
+  GetTypesValues,
+  IParamsExtractor,
+  Parameter,
+  RawArtifactComponents,
+  SubstitutingParameter,
+} from '../types';
+import { TypesNormalizer } from './TypesNormalizer';
+
+// handles the extraction of artifact components (taken from input string taken AS A LINE from intermediate presentation)
+// then it retrieves [known-params], [runtime-supplied], or [substituted] values, etc.
+export class ParamsExtractor implements IParamsExtractor {
+  static build = (
+    artifactDeclarationUnprocessed: string,
+    descriptors: GetTypesValues,
+  ): ParamsExtractor => {
+    return new ParamsExtractor(artifactDeclarationUnprocessed, descriptors);
+  };
+
+  constructor(
+    private artifactDeclarationUnprocessed: string,
+    private descriptors: GetTypesValues,
+  ) {}
+
+  private get artifact() {
+    return this.artifactDeclarationUnprocessed;
+  }
+
+  private get retrieveInstanceDescriptors() {
+    return this.descriptors;
+  }
+
+  artifactData = async (
+    artifact: string = this.artifact, // can accept artifact declaration runtime to extract
+  ): Promise<ArtifactData> => {
+    const {
+      addressClause: artifactAddress,
+      initClause,
+      paramsClause,
+    } = this.toComponents(artifact);
+
+    const { execParamsTypes, initParamsTypes } =
+      await this.retrieveInstanceDescriptors(artifactAddress);
+
+    // note: all exec params; not splitted yet to [known-params], [runtime-supplied], or [substituted]
+    const execParamsList = this.getAllArgumentsWithIndices(paramsClause);
+
+    // note: the ones should be replaced by evaluation-result of linked Artifact
+    const execSubstitutionParamsList =
+      this.getSubstitutionsWithIndices(execParamsList);
+
+    // note: this actually is constant-values needed runtime and known when artifact is declared but prior to its deployment
+    const execKnownParamsList = this.getKnownParamsWithIndices(
+      execParamsList,
+      execParamsTypes,
+    );
+
+    // note: when applied onchain, this facilitates what position provided arguments belong in general exec-params list of graph node
+    const execRuntimeVariablesIndices: Array<number> =
+      this.getRuntimeVariablesIndices(execParamsList);
+
+    // note: index here is a position of an injection in an array of variables, NOT in an array of execParams
+    const execRuntimeVariablesInjectionsWithIndices: Array<Parameter> =
+      this.getInjectionsWithIndices(execParamsList);
+
+    let initDataParams: string[] = [];
+    if (initClause) {
+      // note: if artifact is statefull, then it may require init-params
+      initDataParams = this.getAllArguments(initClause);
+    }
+
+    const initDataParamsSolidityPacked =
+      TypesNormalizer.toSolidityEncodedValueFromString(
+        initParamsTypes,
+        initDataParams,
+      );
+
+    return {
+      artifactAddress,
+      execKnownParamsList,
+      execSubstitutionParamsList,
+      execRuntimeVariablesIndices,
+      execRuntimeVariablesInjectionsWithIndices,
+      needsInitialization: initClause !== null,
+      argsCount: execParamsList.length,
+      initDataParamsSolidityPacked,
+    };
+  };
+
+  // note: raw components from 'this.artifact'
+  private toComponents(
+    artifact: string = this.artifact,
+  ): RawArtifactComponents {
+    const artifactMatcher = /\{([^}]+)\}\s*\(([^)]*)\)(?:\s*<([^>]*)>)?/;
+    const matched = artifact.match(artifactMatcher);
+
+    if (!!matched) {
+      // todo: const [, instanceAddress, execParamsInfo, initDataParams] = match;
+      const [, addressClause, paramsClause, initClause] = matched;
+
+      // todo: add more validations
+      return {
+        addressClause: getAddress(addressClause),
+        initClause: initClause ?? null,
+        paramsClause,
+      };
+    }
+
+    // note: throw error if the format of the supplied string is incorrect
+    throw new Error(
+      'Artifact intermediate presentation does not match the expected format.',
+    );
+  }
+
+  // exec-params and init-params from param clause usually taken first from 'this.rawComponents'
+  private getAllArguments(clause: string): string[] {
+    // note: return empty array if the input is an empty string
+    if (clause.trim() === '') {
+      return [];
+    }
+
+    // note: split the input string by commas and trim each value
+    const extractedParams = clause.split(',').map((value) => value.trim());
+    return extractedParams;
+  }
+
+  private getAllArgumentsWithIndices = (clause: string): Array<Parameter> => {
+    const extracted = this.getAllArguments(clause);
+
+    const extractedWithIndex = extracted.map((v, i) => ({
+      value: v,
+      index: i,
+    }));
+    return extractedWithIndex;
+  };
+
+  private getRuntimeVariables = (
+    paramsList: Array<Parameter>,
+  ): Array<Parameter> => {
+    // filter out parameters that are variables
+    const isVariableFilter = (v: string): boolean => {
+      const regex = /^var/;
+      return regex.test(v);
+    };
+
+    const runtimeVariables = paramsList.filter(({ value }) =>
+      isVariableFilter(value),
+    );
+
+    return runtimeVariables;
+  };
+
+  private getRuntimeVariablesIndices = (
+    paramsList: Array<Parameter>,
+  ): Array<number> => {
+    // return runtime-variable indices
+    const variableIndices = this.getRuntimeVariables(paramsList).map(
+      ({ index }) => index,
+    );
+    return variableIndices;
+  };
+
+  // note: this keeps original indeces from general list of params
+  private getInjectionsWithIndices = (
+    paramsList: Array<Parameter>,
+  ): Array<Parameter> => {
+    const extractInjection = (input: string): string => {
+      const matched = input.match(/\$"([^"]*)"$/);
+      if (!!matched) return matched[1];
+
+      return '';
+    };
+
+    const injectionMapper = (
+      v: Parameter,
+      indexOfValueInVariablesList: number,
+    ) => {
+      const extracted = extractInjection(v.value);
+      if (!!extracted && extracted !== '') {
+        return {
+          value: v.value,
+          index: indexOfValueInVariablesList,
+        };
+      }
+
+      return undefined;
+    };
+
+    const injectionsListUnsafe =
+      this.getRuntimeVariables(paramsList).map(injectionMapper);
+
+    const injectionsList = injectionsListUnsafe.filter((v) => !!v);
+    return injectionsList;
+  };
+
+  private getSubstitutionsWithIndices = (
+    paramsList: Array<Parameter>,
+  ): Array<SubstitutingParameter> => {
+    // filter out parameters that are substitutions (runtime-supplied parameters)
+    const isSubstitutionFilter = (v: string): boolean => {
+      return v.startsWith('|', 0) && v.endsWith('|');
+    };
+
+    const substitutions = paramsList
+      .filter(({ value }) => isSubstitutionFilter(value))
+      .map(({ value: filteredValue, index }) => ({
+        from: filteredValue.replace(/\|/g, ''), // cleaning up the substitution value
+        atPos: index, // return substitutions indices
+      }));
+
+    return substitutions;
+  };
+
+  private getKnownParamsWithIndices = (
+    paramsList: Array<Parameter>,
+    argsTypes: string[],
+  ): Array<Parameter> => {
+    // filter out non-constant values (var or substituion), thereby only constant is found
+    const isConstantFilter = (value: string): boolean => {
+      const regex = /^(?!var)(?!\|.*\|$).*/;
+      return regex.test(value);
+    };
+
+    // filters constants and preservs their indeces among other entries in 'parameters-list'
+    const knownParamsFiltered: Array<Parameter> = paramsList.filter(
+      ({ value }) => isConstantFilter(value),
+    );
+
+    if (knownParamsFiltered.length > argsTypes.length) {
+      throw new Error(`Extraction error. Provided onchain types list length (${argsTypes.length})
+        is less than extracted constants list length (${knownParamsFiltered.length})`);
+    }
+
+    const knownParamsWithIndices = knownParamsFiltered.map(
+      ({ value: filteredValue, index }) => {
+        const encodedConstantWithIndex: Parameter = {
+          value: TypesNormalizer.toSolidityEncodedValueFromString(
+            [argsTypes[index]],
+            [filteredValue],
+          ),
+          index,
+        };
+        return encodedConstantWithIndex;
+      },
+    );
+
+    return knownParamsWithIndices;
+  };
+}