@guardian-network/policy-variables 0.3.2

package/dist/types/types.d.ts

@@ -0,0 +1,42 @@
+import { OnchainVariablesDescription, PrimitiveEncodeParamTypes } from '@guardian-network/shared';
+export type AllowedVariablesType = PrimitiveEncodeParamTypes;
+export type VarDescription = {
+    name: string;
+    type: string;
+    uniqueName: string;
+    index: number;
+    injection?: string;
+};
+export type VarValue = {
+    index: number;
+    value: AllowedVariablesType;
+};
+export type SuppliedVariables = {
+    nodeId: NodeId;
+    values: AllowedVariablesType[];
+};
+export type Variable = {
+    typename: string;
+    name: string;
+};
+type Injection = {
+    value: string;
+    index: number;
+};
+export type TypedRawOnchainVariablesDescription = {
+    nodeId: NodeId;
+    nodeIndex: number;
+    artifactAddress: string;
+    descriptions: Array<Variable>;
+    injections: Array<Injection>;
+};
+export type NodeVariablesDescription = OnchainVariablesDescription | TypedRawOnchainVariablesDescription;
+export type NodeVariablesConfig = {
+    nodeId: NodeId;
+    variables: VarDescription[];
+};
+export type VarName = string;
+export type VarIndex = number;
+export type NodeId = string;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,0BAA0B,CAAC;AAUlC,MAAM,MAAM,oBAAoB,GAAG,yBAAyB,CAAC;AAG7D,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,oBAAoB,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,oBAAoB,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC9B,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAChC,2BAA2B,GAC3B,mCAAmC,CAAC;AAIxC,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,cAAc,EAAE,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAC7B,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC9B,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC"}

package/dist/types/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":""}

package/dist/utils/format-variables.helper.d.ts

@@ -0,0 +1,4 @@
+import { NodeVariablesConfig, NodeVariablesDescription, TypedRawOnchainVariablesDescription } from '../types';
+export declare const translateVarsDescriptionToConfig: (nodesVarsList: NodeVariablesDescription[]) => NodeVariablesConfig[];
+export declare const rawOnchainVariablesDescriptionToOffchainView: (nodeVars: NodeVariablesDescription) => TypedRawOnchainVariablesDescription;
+//# sourceMappingURL=format-variables.helper.d.ts.map

package/dist/utils/format-variables.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-variables.helper.d.ts","sourceRoot":"","sources":["../../src/utils/format-variables.helper.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,mCAAmC,EAEpC,MAAM,UAAU,CAAC;AAElB,eAAO,MAAM,gCAAgC,kBAC5B,wBAAwB,EAAE,KACxC,mBAAmB,EA0CrB,CAAC;AAEF,eAAO,MAAM,4CAA4C,aAC7C,wBAAwB,KACjC,mCAkBF,CAAC"}

package/dist/utils/format-variables.helper.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawOnchainVariablesDescriptionToOffchainView = exports.translateVarsDescriptionToConfig = void 0;
+const errors_1 = require("../errors");
+const translateVarsDescriptionToConfig = (nodesVarsList) => {
+    const nodesVarsConfig = [];
+    for (let nodeVars of nodesVarsList.map(exports.rawOnchainVariablesDescriptionToOffchainView)) {
+        nodesVarsConfig.push({
+            nodeId: nodeVars.nodeId,
+            variables: [],
+        });
+        for (const [index, variable] of nodeVars.descriptions.entries()) {
+            const variableConfig = {
+                name: variable.name,
+                type: variable.typename,
+                uniqueName: buildUniqueVariablesName(variable, nodeVars),
+                index,
+            };
+            nodesVarsConfig[nodesVarsConfig.length - 1].variables.push(variableConfig);
+        }
+        for (const injection of nodeVars.injections) {
+            const injectableVar = nodesVarsConfig[nodesVarsConfig.length - 1].variables.find((el) => el.index == Number(injection.index));
+            if (!!injectableVar) {
+                injectableVar.injection = injection.value;
+            }
+            else
+                throw errors_1.ErrorFactory.injectionFormatting(injection.value, injection.index);
+        }
+    }
+    return [...nodesVarsConfig];
+};
+exports.translateVarsDescriptionToConfig = translateVarsDescriptionToConfig;
+const rawOnchainVariablesDescriptionToOffchainView = (nodeVars) => {
+    const { nodeId, descriptions, injections, artifactAddress, nodeIndex } = nodeVars;
+    const result = {
+        nodeId,
+        nodeIndex: Number(nodeIndex),
+        artifactAddress,
+        descriptions: descriptions.map(({ typename, name }) => ({
+            typename,
+            name,
+        })),
+        injections: injections.map(({ value, index }) => ({
+            value,
+            index: Number(index),
+        })),
+    };
+    return result;
+};
+exports.rawOnchainVariablesDescriptionToOffchainView = rawOnchainVariablesDescriptionToOffchainView;
+const buildUniqueVariablesName = (variable, varDescription) => {
+    return `${variable.name}_${variable.typename}_${varDescription.artifactAddress}_${varDescription.nodeIndex}`;
+};
+//# sourceMappingURL=format-variables.helper.js.map

package/dist/utils/format-variables.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-variables.helper.js","sourceRoot":"","sources":["../../src/utils/format-variables.helper.ts"],"names":[],"mappings":";;;AAAA,sCAAyC;AAQlC,MAAM,gCAAgC,GAAG,CAC9C,aAAyC,EAClB,EAAE;IACzB,MAAM,eAAe,GAA0B,EAAE,CAAC;IAElD,KAAK,IAAI,QAAQ,IAAI,aAAa,CAAC,GAAG,CACpC,oDAA4C,CAC7C,EAAE,CAAC;QACF,eAAe,CAAC,IAAI,CAAC;YACnB,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,SAAS,EAAE,EAAE;SACd,CAAC,CAAC;QAGH,KAAK,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;YAChE,MAAM,cAAc,GAAG;gBACrB,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,IAAI,EAAE,QAAQ,CAAC,QAAQ;gBACvB,UAAU,EAAE,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,CAAC;gBACxD,KAAK;aACN,CAAC;YAEF,eAAe,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CACxD,cAAc,CACf,CAAC;QACJ,CAAC;QAGD,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;YAC5C,MAAM,aAAa,GAAG,eAAe,CACnC,eAAe,CAAC,MAAM,GAAG,CAAC,CAC3B,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;YAE9D,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;gBACpB,aAAa,CAAC,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC;YAC5C,CAAC;;gBACC,MAAM,qBAAY,CAAC,mBAAmB,CACpC,SAAS,CAAC,KAAK,EACf,SAAS,CAAC,KAAK,CAChB,CAAC;QACN,CAAC;IACH,CAAC;IAED,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC;AAC9B,CAAC,CAAC;AA5CW,QAAA,gCAAgC,oCA4C3C;AAEK,MAAM,4CAA4C,GAAG,CAC1D,QAAkC,EACG,EAAE;IACvC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,SAAS,EAAE,GACpE,QAAQ,CAAC;IAEX,MAAM,MAAM,GAAG;QACb,MAAM;QACN,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC;QAC5B,eAAe;QACf,YAAY,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;YACtD,QAAQ;YACR,IAAI;SACL,CAAC,CAAC;QACH,UAAU,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;YAChD,KAAK;YACL,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC;SACrB,CAAC,CAAC;KACJ,CAAC;IACF,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AApBW,QAAA,4CAA4C,gDAoBvD;AAGF,MAAM,wBAAwB,GAAG,CAC/B,QAAkB,EAClB,cAAwC,EACxC,EAAE;IACF,OAAO,GAAG,QAAQ,CAAC,IAAI,IAAI,QAAQ,CAAC,QAAQ,IAAI,cAAc,CAAC,eAAe,IAAI,cAAc,CAAC,SAAS,EAAE,CAAC;AAC/G,CAAC,CAAC"}

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './format-variables.helper';
+export * from './validations.helper';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./format-variables.helper"), exports);
+__exportStar(require("./validations.helper"), exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4DAA0C;AAC1C,uDAAqC"}

package/dist/utils/validations.helper.d.ts

@@ -0,0 +1,4 @@
+import { AllowedVariablesType, NodeVariablesConfig, SuppliedVariables, VarDescription } from '../types';
+export declare const validateVarValueTypeWithErr: (varValue: AllowedVariablesType, expectedTypeAsString: string) => void;
+export declare const validateAllVariablesSupplied: (varsConfig: NodeVariablesConfig[], knownVariables: SuppliedVariables[], isVariableInjectable?: (varDescription: VarDescription) => boolean) => void;
+//# sourceMappingURL=validations.helper.d.ts.map

package/dist/utils/validations.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validations.helper.d.ts","sourceRoot":"","sources":["../../src/utils/validations.helper.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACf,MAAM,UAAU,CAAC;AAElB,eAAO,MAAM,2BAA2B,aAC5B,oBAAoB,wBACR,MAAM,SAU7B,CAAC;AAqDF,eAAO,MAAM,4BAA4B,eAC3B,mBAAmB,EAAE,kBACjB,iBAAiB,EAAE,yBAEb,CACpB,cAAc,EAAE,cAAc,KAC3B,OAAO,SA8Bb,CAAC"}

package/dist/utils/validations.helper.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAllVariablesSupplied = exports.validateVarValueTypeWithErr = void 0;
+const shared_1 = require("@guardian-network/shared");
+const errors_1 = require("../errors");
+const validateVarValueTypeWithErr = (varValue, expectedTypeAsString) => {
+    const isValid = validateVarValueType(varValue, expectedTypeAsString);
+    if (!isValid) {
+        throw errors_1.ErrorFactory.variableTypeNotMet(varValue.toString(), expectedTypeAsString);
+    }
+};
+exports.validateVarValueTypeWithErr = validateVarValueTypeWithErr;
+const validateVarValueType = (varValue, expectedTypeString) => {
+    let verified = false;
+    const vatiableSolidityType = expectedTypeString;
+    switch (vatiableSolidityType) {
+        case 'string':
+            verified ||= typeof varValue == 'string';
+            break;
+        case 'uint256':
+            verified ||= typeof varValue == 'number';
+            break;
+        case 'bool':
+            verified ||= typeof varValue == 'boolean';
+            break;
+        case 'address':
+            try {
+                (0, shared_1.verifyAddress)(varValue);
+                verified = true;
+            }
+            catch (_) {
+                verified = false;
+            }
+            break;
+        case 'bytes':
+            try {
+                (0, shared_1.verifyBytes)(varValue);
+                verified = true;
+            }
+            catch (_) {
+                verified = false;
+            }
+            break;
+        default:
+            throw errors_1.ErrorFactory.providedVariableWithNotKnownType(varValue.toString(), vatiableSolidityType);
+    }
+    return verified;
+};
+const defaultExtraCondition = (_) => false;
+const validateAllVariablesSupplied = (varsConfig, knownVariables, isVariableInjectable = defaultExtraCondition) => {
+    for (let i = 0; i < varsConfig.length; i++) {
+        const suppliedVars = knownVariables[i];
+        const expectedVarsConfig = varsConfig[i];
+        for (let j = 0; j < expectedVarsConfig.variables.length; j++) {
+            const variable = expectedVarsConfig.variables[j];
+            const isInjection = isVariableInjectable(variable);
+            const isVariableSupplied = suppliedVars.values[j] !== undefined;
+            if (!isVariableSupplied && !isInjection) {
+                throw errors_1.ErrorFactory.variableNotFilled(variable.uniqueName, variable.injection);
+            }
+            if (isVariableSupplied) {
+                const value = suppliedVars.values[j];
+                const expectedType = variable.type;
+                (0, exports.validateVarValueTypeWithErr)(value, expectedType);
+            }
+        }
+    }
+};
+exports.validateAllVariablesSupplied = validateAllVariablesSupplied;
+//# sourceMappingURL=validations.helper.js.map

package/dist/utils/validations.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validations.helper.js","sourceRoot":"","sources":["../../src/utils/validations.helper.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@guardian-network/policy-variables",
+  "author": "vpriadko@lacero.io",
+  "description": "Variables scrapping and encoding for policies infrastructure",
+  "version": "0.3.2",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18.20.4"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "keywords": [],
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.13.0",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
+    "@types/chai": "4.3.3",
+    "@types/chai-as-promised": "^8.0.1",
+    "@types/mocha": "^10.0.9",
+    "@types/node": "^22.8.0",
+    "@typescript-eslint/eslint-plugin": "^8.61.1",
+    "chai": "^4.5.0",
+    "chai-as-promised": "^8.0.1",
+    "copyfiles": "^2.4.1",
+    "eslint": "^9.11.1",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.6.3",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-mocha": "^10.5.0",
+    "eslint-plugin-n": "^17.10.3",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-promise": "^7.1.0",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "globals": "^15.11.0",
+    "mocha": "^10.8.2",
+    "nyc": "^18.0.0",
+    "prettier": "^3.3.3",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "rimraf": "^6.0.1"
+  },
+  "dependencies": {
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.2",
+    "@guardian-network/shared": "0.3.2"
+  },
+  "scripts": {
+    "build": "pnpm format:all:fix && tsc -p tsconfig-prod.json && pnpm copy-dts",
+    "check": "pnpm lint:ts && pnpm check:ts",
+    "check:ts": "tsc -p tsconfig-prod.json --noEmit",
+    "check:ts:dev": "tsc -p tsconfig.json --noEmit",
+    "clean": "pnpm remove:dist",
+    "copy-dts": "copyfiles -u 1 \"src/**/*.d.ts\" dist",
+    "format:all:fix": "pnpm format:ts:fix",
+    "format:ts:fix": "prettier -w -c \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint:ts": "eslint",
+    "lint:ts:fix": "eslint --fix",
+    "publish-package": "pnpm publish --no-git-checks",
+    "remove:dist": "npx rimraf dist",
+    "test": "mocha",
+    "tests:coverage:ts": "nyc pnpm test",
+    "version": "pnpm version"
+  }
+}

package/src/VariablesPopulator.ts

@@ -0,0 +1,120 @@
+import {
+  VariablesStruct,
+  solidityEncodeSingleParam,
+} from '@guardian-network/shared';
+import { ErrorFactory } from './errors';
+import { StaticInjector } from './injection';
+import { Inserter } from './insertion';
+import {
+  AllowedVariablesType,
+  IAsyncMapGetter,
+  NodeVariablesConfig,
+  NodeVariablesDescription,
+  SuppliedVariables,
+  VarDescription,
+} from './types';
+import {
+  translateVarsDescriptionToConfig,
+  validateAllVariablesSupplied,
+  validateVarValueTypeWithErr,
+} from './utils';
+
+// note: fill each variable with respective data
+export class VariablesPopulator {
+  protected varsConfig: NodeVariablesConfig[];
+  private inserter: Inserter;
+  private suppliedVars: SuppliedVariables[];
+
+  constructor(varsDescriptions: Array<NodeVariablesDescription>) {
+    this.varsConfig = translateVarsDescriptionToConfig(varsDescriptions);
+
+    this.inserter = new Inserter(this.varsConfig);
+
+    this.suppliedVars = this.inserter.filledVars;
+    // console.log(this.filledVariables[0].values);
+  }
+
+  // note: varName has to be unique in comparison to other vars
+  insert = (varName: string, varValue: AllowedVariablesType) => {
+    const varDescription = this.getVarDescription(varName);
+    validateVarValueTypeWithErr(varValue, varDescription.type);
+
+    this.inserter.insert(varName, varValue);
+
+    this.suppliedVars = this.inserter.filledVars;
+  };
+
+  inject = async (attributes: IAsyncMapGetter<AllowedVariablesType>) => {
+    // note: this might be called as more times as required
+    this.suppliedVars = await StaticInjector.inject(
+      this.varsConfig,
+      this.suppliedVars,
+      attributes,
+    );
+  };
+
+  importState = (filledValues: SuppliedVariables[]) => {
+    this.inserter.import(filledValues);
+
+    this.suppliedVars = this.inserter.filledVars;
+
+    return this;
+  };
+
+  dumpState = (): Array<SuppliedVariables> => {
+    return this.suppliedVars;
+  };
+
+  // note: actually, not serialized, rather packed to be
+  // compatible with "PolicyHandler.evaluate"" method (defined onchaun using Solidity)
+  toSerializedVariables = (): Array<VariablesStruct> => {
+    // note: only completely supplied variables have to be serialized
+    this.validateAllFilled();
+
+    const solidityPackedVariablesList = this.suppliedVars.map(
+      ({ nodeId, values }) => ({
+        nodeId,
+        values: values.map((val) => solidityEncodeSingleParam(val)),
+      }),
+    );
+
+    return solidityPackedVariablesList;
+  };
+
+  getVarDescription(varName: string): VarDescription {
+    const variableDescription = this.getVarsDescription().find(
+      ({ uniqueName }) => uniqueName == varName,
+    );
+
+    // note: validate variable exists (and has a description)
+    if (!variableDescription) throw ErrorFactory.variableNotFound(varName);
+
+    return variableDescription;
+  }
+
+  getVarsDescription = (): VarDescription[] => {
+    // flattened list of each node variables
+    const variablesDescriptionList: VarDescription[] = this.varsConfig.flatMap(
+      ({ variables }) => variables,
+    );
+
+    return variablesDescriptionList;
+  };
+
+  validateAllFilledExceptInjections = (): void => {
+    const isVariableInjectable = (varDescription: VarDescription) => {
+      // note: undefined means not injection; defined means injection
+      return !!varDescription.injection;
+    };
+
+    validateAllVariablesSupplied(
+      this.varsConfig,
+      this.suppliedVars,
+      isVariableInjectable,
+    );
+  };
+
+  validateAllFilled = (): void => {
+    validateAllVariablesSupplied(this.varsConfig, this.suppliedVars);
+  };
+}

package/src/errors/ErrorFactory.ts

@@ -0,0 +1,53 @@
+import {
+  InjectionFormattingError,
+  NodeVariablesAreUndefinedErr,
+  VariableNodeNotFoundError,
+  VariableNotFilledError,
+  VariableNotFoundError,
+  VariableTypeNotKnownError,
+  VariableTypeNotMetError,
+} from './validation-errors';
+
+export class ErrorFactory {
+  static variableTypeNotMet = (
+    ...params: Parameters<typeof VariableTypeNotMetError.create>
+  ) => {
+    return VariableTypeNotMetError.create(...params);
+  };
+
+  static variableNotFound = (
+    ...params: Parameters<typeof VariableNotFoundError.create>
+  ) => {
+    return VariableNotFoundError.create(...params);
+  };
+
+  static injectionFormatting = (
+    ...params: Parameters<typeof InjectionFormattingError.create>
+  ) => {
+    return InjectionFormattingError.create(...params);
+  };
+
+  static nodeVariablesAreUndefined = (
+    ...params: Parameters<typeof NodeVariablesAreUndefinedErr.create>
+  ) => {
+    return NodeVariablesAreUndefinedErr.create(...params);
+  };
+
+  static variableNodeNotFound = (
+    ...params: Parameters<typeof VariableNodeNotFoundError.create>
+  ) => {
+    return VariableNodeNotFoundError.create(...params);
+  };
+
+  static providedVariableWithNotKnownType = (
+    ...params: Parameters<typeof VariableTypeNotKnownError.create>
+  ) => {
+    return VariableTypeNotKnownError.create(...params);
+  };
+
+  static variableNotFilled = (
+    ...params: Parameters<typeof VariableNotFilledError.create>
+  ) => {
+    return VariableNotFilledError.create(...params);
+  };
+}

package/src/errors/index.ts

@@ -0,0 +1 @@
+export * from './ErrorFactory';

package/src/errors/validation-errors.ts

@@ -0,0 +1,57 @@
+import { BaseError } from '@guardian-network/shared';
+
+export class CannotLookupVariableValueError extends BaseError {
+  static create = (varName: string, injectionName: string) => {
+    const errorMessage = `No injection or default value for ${varName} (attribute ${injectionName}) is provided`;
+    return this.build(errorMessage);
+  };
+}
+
+export class VariableNotFoundError extends BaseError {
+  static create = (varName: string) => {
+    const errorMessage = `Cannot find variable ${varName} among known policy variables`;
+    return this.build(errorMessage);
+  };
+}
+
+export class VariableTypeNotMetError extends BaseError {
+  static create = (varValue: string, expectedType: string) => {
+    const errorMessage = `Variable of value ${varValue} is not one of allowed Solidity types ${expectedType}`;
+    return this.build(errorMessage);
+  };
+}
+
+export class VariableNodeNotFoundError extends BaseError {
+  static create = (varName: string) => {
+    const errorMessage = `Not found node id for variable ${varName}`;
+    return this.build(errorMessage);
+  };
+}
+
+export class NodeVariablesAreUndefinedErr extends BaseError {
+  static create = (targetNode: string) => {
+    const errorMessage = `Variables record is missing for node id: ${targetNode}`;
+    return this.build(errorMessage);
+  };
+}
+
+export class InjectionFormattingError extends BaseError {
+  static create = (injectionValue: string, injectionIndex: number) => {
+    const errorMessage = `Failed formatting variables description onchain output. Problems with injection ${injectionValue}:${injectionIndex}`;
+    return this.build(errorMessage);
+  };
+}
+
+export class VariableNotFilledError extends BaseError {
+  static create = (varName: string, injection?: string) => {
+    const errorMessage = `Variable ${varName} ${injection ? `(injection: ${injection})` : ''} was not filled`;
+    return this.build(errorMessage);
+  };
+}
+
+export class VariableTypeNotKnownError extends BaseError {
+  static create = (varValue: string, expectedType: string) => {
+    const errorMessage = `Variable of value ${varValue} type is not allowed Solidity type ${expectedType}`;
+    return this.build(errorMessage);
+  };
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export {
+  AllowedVariablesType,
+  SuppliedVariables,
+  TypedRawOnchainVariablesDescription,
+} from './types';
+export { rawOnchainVariablesDescriptionToOffchainView } from './utils';
+export { VariablesPopulator } from './VariablesPopulator';

package/src/injection/StaticInjector.ts

@@ -0,0 +1,57 @@
+import {
+  AllowedVariablesType,
+  IAsyncMapGetter,
+  NodeVariablesConfig,
+  SuppliedVariables,
+} from '../types';
+import { validateVarValueTypeWithErr } from '../utils';
+
+// note: inject variables values
+export class StaticInjector {
+  static inject = async <T extends AllowedVariablesType>(
+    varsConfig: NodeVariablesConfig[],
+    knownVariables: SuppliedVariables[],
+    attributesSource: IAsyncMapGetter<T>,
+  ): Promise<Array<SuppliedVariables>> => {
+    const knownVariablesClone = structuredClone(knownVariables);
+
+    for (let mayBeSuppliedVariable of knownVariablesClone) {
+      // why var-config is unaware of supplied-var-node-id???
+      const variableConfig = varsConfig.find(
+        (v) => v.nodeId == mayBeSuppliedVariable.nodeId,
+      );
+
+      // note: only for known config with variables.lengt > 0
+      if (!variableConfig || variableConfig.variables.length === 0) {
+        continue;
+      }
+
+      for (let [index, varDescription] of variableConfig.variables.entries()) {
+        // note: skipping when not injectable variable
+        if (!varDescription.injection) {
+          continue;
+        }
+
+        // note: look up attributes to fill injected variable
+        const attribute = await attributesSource.get(varDescription.injection);
+        // const defaultValue = mayBeSuppliedVariable.values[index];
+        const expectedType = varDescription.type;
+
+        if (attribute !== undefined) {
+          validateVarValueTypeWithErr(attribute, expectedType);
+          mayBeSuppliedVariable.values[index] = attribute;
+
+          // note: ??redundancy. this is validated while insert
+        }
+        // note: Redundancy? this is validated in VariablesPopulator.validateAllFilled()
+        //  else
+        //   throw ErrorFactory.cannotLookupVariableValue(
+        //     varDescription.uniqueName,
+        //     varDescription.injection,
+        //   );
+      }
+    }
+
+    return knownVariablesClone;
+  };
+}

package/src/injection/index.ts

@@ -0,0 +1 @@
+export { StaticInjector } from './StaticInjector';