@guardian-network/policy-intermediate-representation 0.3.2

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

@@ -0,0 +1,78 @@
+import { solidityEncode } from '@guardian-network/shared';
+import { getAddress, getBytes } from 'ethers';
+import { isSupportedSolidityType } from '../guards';
+import {
+  KnownTSType,
+  SolidityType,
+  SupportedSolidityTypesEnum,
+} from '../types';
+
+export class TypesNormalizer {
+  // note: can take multiple type/value pairs, then encode inputs to Solidity-bytes
+  static toSolidityEncodedValueFromString(
+    soldityTypes: string[], // taken from onchain declaration
+    valuesAsStringList: string[],
+  ): string {
+    // note: Convert each argument to its respective TS type
+    const convertedValues = this.toTsArrayFromStringArray(
+      soldityTypes,
+      valuesAsStringList,
+    );
+
+    // note: Encode the types and values using EthersV6-Solidity's encoding function
+    return solidityEncode(soldityTypes, convertedValues);
+  }
+
+  // note: Normalizes argument supplied as string (defined in this way in intermediate presentation) to the respective typescript type
+  static toTsValueFromString(
+    type: SolidityType,
+    valueAsString: string,
+  ): KnownTSType {
+    const getBool = (value: string): boolean => {
+      return value === 'true' ? true : false;
+    };
+
+    switch (type) {
+      case SupportedSolidityTypesEnum.Address:
+        return getAddress(valueAsString); // string to a valid Ethereum address
+      case SupportedSolidityTypesEnum.Bool:
+        return getBool(valueAsString); // 'true'/'false' to boolean
+      case SupportedSolidityTypesEnum.String:
+        return valueAsString.replace(/^"(.*)"$/, '$1'); // Removes quotes around a string if present
+      case SupportedSolidityTypesEnum.Bytes:
+        return getBytes(valueAsString); // string to bytes (expects a hex string)
+      case SupportedSolidityTypesEnum.Uint256:
+        return BigInt(valueAsString); // string to BigInt (for 'uint256' type)
+      default:
+        // Type is known for sure, because there is a guard in previous calls
+        throw new Error(
+          `Can not normalize. Provided Solidity type ${type} is known yet unsupported`,
+        );
+    }
+  }
+
+  // note: This takes raw values (defined as string in intermediate presentation), then converts them to respective typesript types.
+  // While converting it relies on solidity-types fetched from onchain declaration of Artifact.
+  static toTsArrayFromStringArray = (
+    soldityTypes: string[], // taken from onchain declaration
+    valuesAsStringList: string[],
+  ): Array<KnownTSType> => {
+    if (soldityTypes.length !== valuesAsStringList.length) {
+      throw new Error(
+        `Can not convert to Typescript value: Solidity-Types ${soldityTypes.length} and Values ${valuesAsStringList.length} arrays lengths not match`,
+      );
+    }
+
+    const typedValuesList = valuesAsStringList.map((value, index) => {
+      const solidityTypeName = soldityTypes[index];
+      if (isSupportedSolidityType(solidityTypeName)) {
+        // note: converts each argument to its respective type
+        return this.toTsValueFromString(solidityTypeName, value);
+      } else {
+        throw new Error(`Supplied unknown Solidity type ${solidityTypeName}`);
+      }
+    });
+
+    return typedValuesList;
+  };
+}

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

@@ -0,0 +1,5 @@
+export * from './ParamsExtractor';
+export * from './tools.helper';
+export { DSLConfigArgsTypesSource } from './types-source/DSLConfigArgsTypesSource';
+export { OnchainDescriptorArgsTypesSource } from './types-source/OnchainDescriptorArgsTypesSource';
+export * from './TypesNormalizer';

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

@@ -0,0 +1,33 @@
+import { ContractRunner } from 'ethers';
+import { isContractProviderType } from '../guards';
+import { GetTypesValues, IArgsTypesSource } from '../types';
+import { OnchainDescriptorArgsTypesSource } from './types-source/OnchainDescriptorArgsTypesSource';
+
+// note: this extracts raw artifacts (list: Array<string>) – as they declared in intermeditate presentation
+export const toUnprocessedArtifactsList = (
+  intermediatePresentation: string,
+): Array<string> => {
+  // note: no extra whitespaces + split input (by lines count) into individual artifact strings
+  const list = intermediatePresentation
+    .trim() // remove surrounding whitespaces in declaration (intermediate-presentation)
+    .split(/\r?\n/) // split by each line
+    .map((v) => v.trim()); // remove surrounding whitespaces in each artifact
+
+  // note: list has no validations, because validations are applied in respective methods for each list entry
+  return list;
+};
+
+export const createOrInferTypesSource = (
+  providerOrSource: ContractRunner | IArgsTypesSource,
+): GetTypesValues => {
+  let getTypesSource: GetTypesValues;
+
+  if (isContractProviderType(providerOrSource)) {
+    getTypesSource = new OnchainDescriptorArgsTypesSource(providerOrSource)
+      .getTypes;
+  } else {
+    getTypesSource = providerOrSource.getTypes;
+  }
+
+  return getTypesSource;
+};

package/src/ir-notation/parser/parser-contracts/tools/types-source/DSLConfigArgsTypesSource.ts

@@ -0,0 +1,52 @@
+import { InstanceConfig } from '@guardian-network/shared';
+import { DSLTypesToIRTypes } from '../../../../helpers';
+import { ExecInitArtifactTypes, IArgsTypesSource } from '../../types';
+
+export class DSLConfigArgsTypesSource implements IArgsTypesSource {
+  static build = (
+    ipArtifactInstanceConfigList: InstanceConfig[],
+  ): DSLConfigArgsTypesSource => {
+    return new DSLConfigArgsTypesSource(ipArtifactInstanceConfigList);
+  };
+
+  constructor(private configList: InstanceConfig[]) {}
+
+  private getArtifactConfiguration = (
+    instanceAddress: string,
+    pos?: number,
+  ): InstanceConfig => {
+    const isPosProvided = typeof pos !== 'undefined';
+    if (!isPosProvided) {
+      throw new Error('Config index in index list is not provided');
+    }
+
+    const config = this.configList.find(
+      (value, index) =>
+        value.artifactAddress === instanceAddress && index == pos,
+    );
+
+    if (!config) {
+      throw new Error(
+        `The artifact config of ${instanceAddress} is not found within config list at pos ${pos}`,
+      );
+    }
+    return config;
+  };
+
+  getTypes = async (
+    instanceAddress: string,
+    posAtConfigList?: number,
+  ): Promise<ExecInitArtifactTypes> => {
+    const { initArguments: initArgsRaw, execArguments: execArgsRaw } =
+      this.getArtifactConfiguration(instanceAddress, posAtConfigList);
+
+    const initParamsTypes = initArgsRaw
+      .map((v) => v.type)
+      .map(DSLTypesToIRTypes);
+    const execParamsTypes = execArgsRaw
+      .map((v) => v.type)
+      .map(DSLTypesToIRTypes);
+
+    return { initParamsTypes, execParamsTypes };
+  };
+}

package/src/ir-notation/parser/parser-contracts/tools/types-source/OnchainDescriptorArgsTypesSource.ts

@@ -0,0 +1,76 @@
+import {
+  IMinArbitraryDataArtifact,
+  MinArbitraryDataArtifactFactory,
+} from '@guardian-network/shared';
+import { ContractRunner } from 'ethers';
+import {
+  ExecInitArtifactTypes,
+  ExecInitArtifactTypesAndNames,
+  IArgsTypesAndNamesSource,
+  IArgsTypesSource,
+} from '../../types';
+
+export class OnchainDescriptorArgsTypesSource
+  implements IArgsTypesAndNamesSource, IArgsTypesSource
+{
+  private artifactInstance!: IMinArbitraryDataArtifact;
+
+  constructor(private provider: ContractRunner) {}
+
+  protected connectInstance = (artifactAddress: string) => {
+    this.artifactInstance = MinArbitraryDataArtifactFactory.connect(
+      artifactAddress,
+      this.provider,
+    );
+
+    return this;
+  };
+
+  private getTypesValues = async (instanceAddress: string) => {
+    this.connectInstance(instanceAddress);
+
+    const execDescriptorValue = await this.artifactInstance.getExecDescriptor();
+
+    const initDescriptorValue = await this.artifactInstance.getInitDescriptor();
+
+    return { execDescriptorValue, initDescriptorValue };
+  };
+
+  getTypes = async (
+    instanceAddress: string,
+  ): Promise<ExecInitArtifactTypes> => {
+    const {
+      execDescriptorValue: { argsTypes: execParamsTypes },
+      initDescriptorValue: { argsTypes: initParamsTypes },
+    } = await this.getTypesValues(instanceAddress);
+
+    // note: this requires spread to omit wrappers
+    return {
+      initParamsTypes: [...initParamsTypes],
+      execParamsTypes: [...execParamsTypes],
+    };
+  };
+
+  getTypesAndNames = async (
+    instanceAddress: string,
+  ): Promise<ExecInitArtifactTypesAndNames> => {
+    const {
+      execDescriptorValue: {
+        argsTypes: execParamsTypes,
+        argsNames: execParamsNames,
+      },
+      initDescriptorValue: {
+        argsTypes: initParamsTypes,
+        argsNames: initParamsNames,
+      },
+    } = await this.getTypesValues(instanceAddress);
+
+    // note: this requires spread to omit wrappers
+    return {
+      initParamsTypes: [...initParamsTypes],
+      initParamsNames: [...initParamsNames],
+      execParamsTypes: [...execParamsTypes],
+      execParamsNames: [...execParamsNames],
+    };
+  };
+}

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

@@ -0,0 +1,78 @@
+export type GetTypesValues = (
+  artifactAddress: string,
+  posAtConfigList?: number,
+) => Promise<ExecInitArtifactTypes>;
+
+export interface IArgsTypesSource {
+  getTypes: GetTypesValues;
+}
+
+export interface IArgsTypesAndNamesSource {
+  getTypesAndNames(
+    instanceAddress: string,
+  ): Promise<ExecInitArtifactTypesAndNames>;
+}
+
+export interface IParamsExtractor {
+  artifactData: (rawArtifact?: string) => Promise<ArtifactData>;
+}
+
+export type ArtifactData = {
+  artifactAddress: string;
+  argsCount: number;
+  execRuntimeVariablesIndices: number[];
+  execRuntimeVariablesInjectionsWithIndices: Parameter[];
+  execSubstitutionParamsList: SubstitutingParameter[];
+  execKnownParamsList: Parameter[];
+  initDataParamsSolidityPacked: string;
+  needsInitialization: boolean;
+};
+
+export type ExecInitArtifactTypes = {
+  execParamsTypes: string[];
+  initParamsTypes: string[];
+};
+
+export type ExecInitArtifactTypesAndNames = ExecInitArtifactTypes & {
+  execParamsNames: string[];
+  initParamsNames: string[];
+};
+
+export type KnownTSType = string | bigint | boolean | Uint8Array;
+
+export type SolidityType = `${SupportedSolidityTypesEnum}`;
+
+export enum SupportedSolidityTypesEnum {
+  Uint256 = 'uint256',
+  String = 'string',
+  Bool = 'bool',
+  Bytes = 'bytes',
+  Address = 'address',
+}
+
+type AddressComponent = {
+  addressClause: string;
+};
+
+type UnprocessedInitDataAndExecParams = {
+  initClause: string | null;
+  paramsClause: string;
+};
+
+export type RawArtifactComponents = AddressComponent &
+  UnprocessedInitDataAndExecParams;
+
+export type NormalizedExecParameter = {
+  supplierNodeId: string;
+  index: number;
+};
+
+export type SubstitutingParameter = {
+  from: string; // external node-id to expect data from in run-time
+  atPos: number; // index in general params list of this node-id
+};
+
+export type Parameter = {
+  value: string;
+  index: number;
+};

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

@@ -0,0 +1,200 @@
+import {
+  InstanceConfig,
+  NodeId,
+  SupportedSolidityType,
+  TranspilerOutput,
+} from '@guardian-network/shared';
+import { ContractRunner } from 'ethers/providers';
+import {
+  bytesEncodeArgs,
+  DSLTypesToIRTypes,
+  extractArguments,
+  extractComponents,
+  extractInjection,
+  indexConstants,
+  isConstant,
+  strIsSubst,
+  strIsVar,
+} from '../helpers';
+import { OnchainDescriptorArgsTypesSource } from './parser-contracts/tools';
+import { ParsingResult, ValidationMiddlware } from './types';
+
+type Parameter = {
+  value: string;
+  index: number;
+};
+
+type KnownParamsAndInitData = {
+  knownExecParams: Parameter[];
+  initDataEncoded: string;
+};
+
+type RetrieveExecAndInitData = (
+  parameters: Array<Parameter>,
+  initArgs: string[],
+  instanceConfig: InstanceConfig,
+  artifactAddress: string,
+  provider?: ContractRunner,
+) => KnownParamsAndInitData | Promise<KnownParamsAndInitData>;
+
+const getKnownExecDataAndInitDataFromDslTypes = (
+  parameters: Array<Parameter>,
+  initArgs: string[],
+  instanceConfig: InstanceConfig,
+  /* artifactAddress: string,
+  provider?: ContractRunner, */
+): KnownParamsAndInitData => {
+  const execConstTypes = instanceConfig.execArguments
+    .filter((el) => el.constant)
+    .map((el) => el.type);
+
+  const knownExecParams = indexConstants(
+    parameters.filter((arg) => isConstant(arg.value)),
+    execConstTypes.map(DSLTypesToIRTypes),
+  );
+
+  const initTypes = instanceConfig.initArguments.map((el) => el.type);
+  const initDataEncoded = bytesEncodeArgs(
+    initArgs,
+    initTypes.map(DSLTypesToIRTypes),
+  );
+
+  return {
+    knownExecParams,
+    initDataEncoded,
+  };
+};
+
+const getKnownExecDataAndInitDataFromOnchainTypes = async (
+  parameters: Array<Parameter>,
+  initArgs: string[],
+  instanceConfig: InstanceConfig,
+  artifactAddress: string,
+  provider?: ContractRunner,
+): Promise<KnownParamsAndInitData> => {
+  const onchain = new OnchainDescriptorArgsTypesSource(provider!);
+
+  const { execParamsTypes, initParamsTypes } =
+    await onchain.getTypes(artifactAddress);
+
+  const knownExecParams = indexConstants(
+    parameters.filter((arg) => isConstant(arg.value)),
+    <SupportedSolidityType[]>execParamsTypes,
+  );
+  const initDataEncoded = bytesEncodeArgs(
+    initArgs,
+    <SupportedSolidityType[]>initParamsTypes,
+  );
+
+  return {
+    knownExecParams,
+    initDataEncoded,
+  };
+};
+
+// note: types dsl-inferred-first
+export const parseIRByDSLTypesWithInterceptor = async (
+  { ir, typings }: TranspilerOutput,
+  middleware?: ValidationMiddlware,
+) => {
+  return parse(
+    { ir, typings },
+    getKnownExecDataAndInitDataFromDslTypes,
+    middleware,
+  );
+};
+
+// note: types onchain-inferred-first
+export const parseIRByOnchainTypesWithInterceptor = async (
+  { ir, typings }: TranspilerOutput,
+  provider: ContractRunner,
+  middleware?: ValidationMiddlware,
+) => {
+  return parse(
+    { ir, typings },
+    getKnownExecDataAndInitDataFromOnchainTypes,
+    middleware,
+    provider,
+  );
+};
+
+const parse = async (
+  transpileOutput: Pick<TranspilerOutput, 'ir' | 'typings'>,
+  exectAndInitData: RetrieveExecAndInitData,
+  middleware?: ValidationMiddlware,
+  provider?: ContractRunner,
+) => {
+  const res: ParsingResult[] = [];
+
+  const artifacts = transpileOutput.ir.trim().split(/\r?\n/);
+  for (let [index, artifact] of artifacts.entries()) {
+    artifact = artifact.trim();
+    const { addressClause, paramsClause, initClause } =
+      extractComponents(artifact);
+
+    const artifactAddress = addressClause;
+    const parameters = extractArguments(paramsClause).map((value, index) => ({
+      value,
+      index,
+    }));
+
+    const initArgs = extractArguments(initClause);
+
+    const variables = parameters
+      .filter((val) => strIsVar(val.value))
+      .map((val) => val.index);
+    const substitutions = parameters
+      .filter((val) => strIsSubst(val.value))
+      .map((val) => ({
+        supplierNodeId: val.value.replace(/\|/g, ''),
+        index: val.index,
+      }));
+
+    const currentInstanceConfig = transpileOutput.typings[index];
+
+    if (middleware) {
+      await middleware.innerValidations(artifactAddress, currentInstanceConfig);
+    }
+
+    const { knownExecParams: partialExecData, initDataEncoded: initData } =
+      await exectAndInitData(
+        parameters,
+        initArgs,
+        currentInstanceConfig,
+        artifactAddress,
+        provider,
+      );
+
+    const injections = parameters
+      .filter((val) => strIsVar(val.value))
+      .map((el, index) => {
+        const injection = extractInjection(el.value);
+
+        if (injection && injection != '') {
+          return {
+            value: el.value,
+            index,
+          };
+        }
+      })
+      .filter((el) => !!el);
+
+    res.push({
+      id: NodeId.fromNotation(artifact, index),
+      artifactAddress,
+      constantExecArgs: partialExecData,
+      variableExecArgs: variables,
+      injections,
+      argsCount: parameters.length,
+      substitutedExecArgs: substitutions,
+      initData,
+      needsInitialization: initArgs.length != 0,
+    });
+  }
+
+  if (middleware) {
+    await middleware.outerValidations(res);
+  }
+
+  return res;
+};

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

@@ -0,0 +1,67 @@
+import { TranspilerOutput } from '@guardian-network/shared';
+import { ContractRunner } from 'ethers';
+import {
+  dslTypesToOnchainTypesParamsValidation,
+  onchainSubstitutionToReturnTypesValidation,
+} from '../helpers';
+import { ParserWithValidation } from './parser-contracts';
+
+export const TypingsValidator = (provider: ContractRunner) => ({
+  innerValidations: dslTypesToOnchainTypesParamsValidation(provider),
+  outerValidations: onchainSubstitutionToReturnTypesValidation(provider),
+});
+
+export const getIRParser = (
+  input: TranspilerOutput,
+  provider: ContractRunner,
+) => {
+  // const middlerware = TypingsValidator(provider);
+
+  return {
+    validated: {
+      DSL_TYPING: async () => {
+        const parser = ParserWithValidation.fromDSLBasedConfig(
+          input.ir,
+          input.typings,
+          provider,
+        );
+        const parsed = await parser.process();
+        return parsed;
+        // const parsed = await parseIRByDSLTypesWithInterceptor(
+        //   input,
+        //   TypingsValidator(provider),
+        // );
+        // return parsed;
+      },
+      ONCHAIN_TYPING: async () => {
+        const parser = ParserWithValidation.fromOnchainSource(
+          input.ir,
+          provider,
+        );
+        const parsed = await parser.process();
+        return parsed;
+        // const parsed = await parseIRByOnchainTypesWithInterceptor(
+        //   input,
+        //   provider!,
+        //   TypingsValidator(provider!),
+        // )
+        // return parsed;
+      },
+    },
+  };
+};
+
+export const getIRParserUnvalidate = (input: TranspilerOutput) => {
+  const unvalidateParser = async () => {
+    const parser = ParserWithValidation.fromDSLBasedConfig(
+      input.ir,
+      input.typings,
+    );
+    const parsed = await parser.process();
+    return parsed;
+    // const parsed = await parseIRByDSLTypesWithInterceptor(input);
+    // return parsed;
+  };
+
+  return unvalidateParser;
+};

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

@@ -0,0 +1,28 @@
+import {
+  DSLType,
+  InstanceConfig,
+  NodeTreeInitData,
+  SupportedSolidityType,
+} from '@guardian-network/shared';
+
+export type ParsingResult = NodeTreeInitData;
+
+export type DslTypeToSolidityType = Record<DSLType, SupportedSolidityType>;
+
+export const DSLTypesMapping: DslTypeToSolidityType = {
+  // SAFE KEYS
+  // UNSAFE VALUES
+  number: 'uint256',
+  address: 'address',
+  bool: 'bool',
+  string: 'string',
+  bytes: 'bytes',
+};
+
+export type ValidationMiddlware = {
+  innerValidations: (
+    artifactAddress: string,
+    currentInstanceConfig: InstanceConfig,
+  ) => Promise<void>;
+  outerValidations: (output: NodeTreeInitData[]) => Promise<void>;
+};