diff --git a/docker/build.sh b/docker/build.sh
index 8d0efb891b3109a1c48d8937ebd53d0484b104ee..35a8087bdc62a197089fcf61358e1b6658084a66 100644
--- a/docker/build.sh
+++ b/docker/build.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-set -e
+set -ex
 
 pushd .
 
@@ -8,7 +8,7 @@ PROJECT_ROOT=$(git rev-parse --show-toplevel)
 cd $PROJECT_ROOT
 
 # Find the current version from Cargo.toml
-VERSION=$(grep "version" ./package.json | egrep -o "([0-9\.]+)")
+VERSION=$(node -p -e "require('./package.json').version")
 GITUSER=7signals
 GITREPO=sensio-explorer
 PROFILE=${PROFILE:-release}
@@ -21,6 +21,11 @@ echo "Image is ready"
 docker images | grep ${GITREPO}
 
 echo -e "\nIf you just built version ${VERSION}, you may want to update your tag:"
-echo " $ docker tag ${GITUSER}/${GITREPO}:$VERSION ${GITUSER}/${GITREPO}:${VERSION}"
+docker tag ${GITUSER}/${GITREPO} ${GITUSER}/${GITREPO}:${VERSION}
+# docker tag ${GITUSER}/${GITREPO}:${VERSION} ${GITUSER}/${GITREPO}:latest
+
+echo -e "\nWhy not push the image:"
+docker push ${GITUSER}/${GITREPO}:${VERSION}
+# docker push ${GITUSER}/${GITREPO}:latest
 
 popd
diff --git a/package.json b/package.json
index 1c825320e895072a8235ced80d572f66cff4f3ac..cf0d7c34e5dbdf5f9cbb1ddc6df775da45ffd138 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "sensio-explorer",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "private": true,
   "author": "Daniel Maricic <daniel@woss.io>",
   "license": "Apache-2.0",
@@ -12,7 +12,9 @@
     "@polkadot/ui-keyring": "^0.49.1",
     "@polkadot/util": "^2.6.2",
     "@polkadot/util-crypto": "^2.6.2",
+    "assert": "^2.0.0",
     "big.js": "^5.2.2",
+    "cbor": "^5.0.2",
     "cids": "^0.8.0",
     "exifreader": "^3.9.0",
     "history": "^4.10.1",
diff --git a/public/favicon.ico b/public/favicon.ico
index 81234a15ef3a404de768e5a904435127ea3166a0..7dee43d07994017b9828894c9991a607a516cf24 100644
Binary files a/public/favicon.ico and b/public/favicon.ico differ
diff --git a/src/App.js b/src/App.js
index 68a3a390df7c14ba6967529d7426b97e83989ee3..490bfeacceebc01db76213cbc15ca9fb974984f8 100644
--- a/src/App.js
+++ b/src/App.js
@@ -14,6 +14,7 @@ import AccountSelector from "./AccountSelector";
 import BlockNumber from "./BlockNumber";
 import Events from "./Events";
 import SensioModule from "./sensio";
+import PhashInfo from "./sensio/poe/pHashes/PhashInfo";
 import CreateProof from "./sensio/poe/proofs/CreateProof";
 import ProofsInfo from "./sensio/poe/proofs/ProofsInfo";
 import ProofsList from "./sensio/poe/proofs/ProofsList";
@@ -62,6 +63,7 @@ function Main() {
               <Statistic.Group size="mini">
                 <RulesInfo />
                 <ProofsInfo />
+                <PhashInfo />
                 <BlockNumber />
                 <BlockNumber finalized />
               </Statistic.Group>
diff --git a/src/config/common.json b/src/config/common.json
index acabf72559eb53a910b2c93d9a40333cee80a42b..fd441057ee6ec6f7b542ec23f4fe23bc390df77e 100644
--- a/src/config/common.json
+++ b/src/config/common.json
@@ -4,47 +4,87 @@
   "CUSTOM_TYPES": {
     "Address": "AccountId",
     "LookupSource": "AccountId",
+    "PoeId": "Vec<u8>",
+    "CreatorId": "Vec<u8>",
+    "DefaultsHashing": {
+      "algo": "Vec<u8>",
+      "bits": "i32",
+      "skip": "bool"
+    },
+    "DefaultsEncoding": {
+      "algo": "Vec<u8>",
+      "prefix": "bool"
+    },
+    "DefaultsCid": {
+      "version": "i32",
+      "base": "Vec<u8>",
+      "codec": "Vec<u8>"
+    },
     "DefaultValues": {
-      "hashAlgo": "Vec<u8>",
-      "hashBits": "u32",
-      "encodingAlgo": "Vec<u8>",
-      "encodingPrefix": "Vec<u8>"
+      "hashing": "DefaultsHashing",
+      "encoding": "DefaultsEncoding",
+      "cid": "DefaultsCid"
     },
     "ForWhat": {
       "_enum": ["Generic", "Photo", "Camera", "Lens", "SmartPhone"]
     },
+    "OperationInfo": {
+      "op": "Operation",
+      "accountId": "AccountId",
+      "blockNumber": "BlockNumber"
+    },
     "Operation": {
+      "id": "PoeId",
+      "data": "OperationData"
+    },
+    "OperationData": {
       "op": "Vec<u8>",
-      "name": "Vec<u8>",
       "desc": "Vec<u8>",
-      "hashAlgo": "Vec<u8>",
-      "hashBits": "u32",
-      "encodeAlgo": "Vec<u8>",
-      "prefix": "Vec<u8>",
+      "hashing": "DefaultsHashing",
+      "encoding": "DefaultsEncoding",
       "ops": "Vec<Operation>"
     },
     "Rule": {
-      "version": "u32",
+      "id": "PoeId",
+      "data": "RuleData"
+    },
+    "RuleData": {
+      "version": "i32",
       "name": "Vec<u8>",
       "desc": "Vec<u8>",
-      "creator": "Vec<u8>",
+      "creator": "CreatorId",
       "forWhat": "ForWhat",
-      "parent": "Vec<u8>",
-      "ops": "Vec<Operation>",
-      "buildParams": "Operation"
+      "parent": "PoeId",
+      "ops": "Vec<Operation>"
     },
-    "Proof": {
-      "proofId": "Vec<u8>",
-      "body": "Vec<u8>",
-      "createdAt": "u64",
-      "prev": "Vec<u8>",
-      "ruleId": "Vec<u8>",
-      "forWhat": "ForWhat"
+    "ProofParams": {
+      "k": "Vec<u8>",
+      "v": "Vec<u8>"
     },
     "ProofInfo": {
       "proof": "Proof",
       "accountId": "AccountId",
       "blockNumber": "BlockNumber"
+    },
+    "Proof": {
+      "id": "PoeId",
+      "data": "ProofData"
+    },
+    "ProofData": {
+      "ruleId": "PoeId",
+      "prev": "PoeId",
+      "creator": "CreatorId",
+      "forWhat": "ForWhat",
+      "params": "Vec<ProofParams>"
+    },
+    "RuleInfo": {
+      "rule": "Rule",
+      "accountId": "AccountId",
+      "blockNumber": "BlockNumber"
+    },
+    "PhashInfo": {
+      "pHash": "Vec<u8>",
+      "proofId": "PoeId"
     }
   }
 }
diff --git a/src/config/production.json b/src/config/production.json
index af15d9d6d547d8afd05c434fccea867ba9d979bd..70fa0c0a18c80a6cd9478dba2664a78848840257 100644
--- a/src/config/production.json
+++ b/src/config/production.json
@@ -1,3 +1,3 @@
 {
-  "PROVIDER_SOCKET": "ws://127.0.0.1:9944"
+  "PROVIDER_SOCKET": "ws://explorer.sensio.network:9944"
 }
diff --git a/src/sensio/poe/README.md b/src/sensio/poe/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..68cfd9a968a187c7590725724cda081b7896e9ab
--- /dev/null
+++ b/src/sensio/poe/README.md
@@ -0,0 +1,18 @@
+# Proof-of-Existence Pallet
+
+The ultimate goal of this pallet is to create verifiable proof for any kind of data. If you can turn data into the `Buffer` you can probably create the PoE.
+
+Idea is simple, provide set of rules, apply them on the data, take the output and create the proof.
+
+This sound like any hashing function, in essence it is with the difference that in applying just the hashing function on the data we end up with the single value without any descriptors about the data, in some cases we don't even know which hash is used if not specified or implemented as multihash, but applying the rule which contains the list of operations where each operation produces `single` hash then combining that into structured way for humans, then creating content address we enable interoperability between any producer of the proof. Theoretically the proof can be generated using the any kind of language and stored anywhere, it can be verified if 3 conditions are met:
+
+1. Rule must be valid and verifiable and retrieved from the SensioNetwork
+2. Rule must be applied exactly as it is
+3. Proof ID must be broadcasted and available
+4. The data can be private and never leave the users domain of control (Optional, it can be public, encrypted ....)
+
+The `Proof` generation depends on the `Rule` definition and its operations.
+
+Follow the numbers in the navigation, they will help you get the PoE.
+
+To learn more about Sensio why not check out our [wiki](https://wiki.sensio.dev) and join our [discord server](https://discordapp.com/invite/WHe4EuY)
diff --git a/src/sensio/poe/helpers.js b/src/sensio/poe/helpers.js
index 7bb9ac694f796610410395a2320b8adf6a54ad7f..dec381afb152e74b9f71a4f49789781993f5069f 100644
--- a/src/sensio/poe/helpers.js
+++ b/src/sensio/poe/helpers.js
@@ -1,8 +1,20 @@
-import { hexToString, stringToHex } from "@polkadot/util";
+import { hexToString } from "@polkadot/util";
 import CID from "cids";
 import * as imghash from "imghash";
 import mh from "multihashing-async";
 import { cameraRule, lensRule, photoRule } from "./rules/defaultRules";
+/**
+ * @return {Promise<[{
+      pHash: string,
+      proofId: string
+    }]>}
+ * @param {ApiPromise} api 
+ */
+export async function getPhashes(api) {
+  const c = await api.query.poe.pHashes.entries();
+  return formatCodecResponseToObject(c);
+}
+
 /**
  * @return {Promise<[{
       rule: Object,
@@ -14,16 +26,15 @@ import { cameraRule, lensRule, photoRule } from "./rules/defaultRules";
  */
 export async function getRules(api) {
   const c = await api.query.poe.rules.entries();
-  return c.map(([key, val]) => {
-    const [ruleId, payload, accountId, blockNumber] = val;
-    // must hexToString to get the decoded value
-    return {
-      rule: payload,
-      ruleId: ruleId.toString(),
-      accountId: accountId.toString(),
-      blockNumber: blockNumber.toNumber(),
-    };
-  });
+  return formatCodecResponseToObject(c);
+}
+
+/**
+ * @param {ApiPromise} api
+ */
+export async function getOperations(api) {
+  const c = await api.query.poe.operations.entries();
+  return formatCodecResponseToObject(c);
 }
 
 /**
@@ -32,78 +43,138 @@ export async function getRules(api) {
  */
 export async function getProofs(api) {
   const c = await api.query.poe.proofs.entries();
+  return formatCodecResponseToObject(c);
+}
+
+function formatCodecResponseToObject(c) {
   return c.map(([key, val]) => {
-    const r = {};
+    const r = { storageKey: key.toString() };
     val.forEach((s, k) => {
-      r[k] = s;
+      r[k] = k.includes("Id") ? s.toString() : s;
     });
     return r;
   });
 }
 
-export function objectToString(o) {
+export function pack(o) {
   const r = JSON.stringify(o);
+  // calculateSize(r);
   return r;
 }
 
-/**
- * Create Rule payload and rule ID
- *
- * TODO refactor this to use unified way of creating the hashes and encoding using the network defaults
- * @param rule
- */
-export async function createRulePayload(api, rule) {
-  const buf = Buffer.from(objectToString(rule));
-  const hash = await calculateHash(buf);
-  const cid = createCID(hash);
-  const payload = api.createType("Rule", rule);
-  const ret = { ruleId: stringToHex(cid.toString()), payload };
-  return ret;
-}
-
 /**
  * Create Rules
  * @param api
  * @param signer
  */
-export async function createDefaultRules(api, signer) {
+export async function createDefaultRules(api, signer, ops) {
   // console.log(api.query.poe);
   // const Rule = api.createType('Rule', rule);
   // console.log(Rule);
 
-  return Promise.all(
-    [photoRule, lensRule, cameraRule].map(
-      async (r) => await createRulePayload(api, r)
-    )
-  )
-    .then((r) => {
-      return saveRuleToNetwork(api, r[0], signer)
-        .then(() => saveRuleToNetwork(api, r[1], signer))
-        .then(() => saveRuleToNetwork(api, r[2], signer));
-      // .then(() => {
-      //   console.log("All rules are saved");
-      //   return true;
-      // })
-      // .catch(console.error);
-    })
-    .catch(console.error);
+  const rules = [photoRule, lensRule, cameraRule].map((r) => {
+    const rule = Object.assign({}, r);
+    rule.ops = rule.ops.map((o) => {
+      const found = ops.find(
+        ({
+          op: {
+            data: { op },
+          },
+        }) => o === hexToString(op.toString())
+      );
+      if (!found) {
+        throw new Error(`Couldn't find the operation ${o}`);
+      }
+
+      // return found.op;
+      const { op } = found;
+      return op;
+
+      // const r = {
+      //   id: hexToString(op.id.toString()),
+      //   data: {
+      //     op: hexToString(op.data.op.toString()),
+      //     desc: hexToString(op.data.desc.toString()),
+      //     hashing: {
+      //       algo: hexToString(op.data.hashing.algo.toString()),
+      //       bits: op.data.hashing.bits.toNumber(),
+      //       skip: op.data.hashing.skip,
+      //     },
+      //     encoding: {
+      //       algo: hexToString(op.data.encoding.algo.toString()),
+      //       prefix: true,
+      //     },
+      //     ops: [],
+      //   },
+      // };
+
+      // return r;
+    });
+
+    return rule;
+  });
+
+  const txs = rules.map((r) => api.tx.poe.createRule(r));
+
+  return new Promise((resolve, reject) => {
+    api.tx.utility
+      .batch(txs)
+      .signAndSend(signer, {}, ({ events = [], status, isError }) => {
+        console.log(`\tTransaction status: ${status.type}`);
+        console.log(`\tEvents: ${events}`);
+
+        if (status.isFinalized) {
+          console.log("\tFinalized block hash", status.asFinalized.toHex());
+          resolve(true);
+        } else if (isError) {
+          console.error(status);
+          reject("Error happened, check console log");
+        }
+      });
+  });
 
   // const createdRule = await api.tx.poe.createRule(ruleId, rule).signAndSend(signer);
   // console.log('CreatedRule ', createdRule.toHex());
 }
+/**
+ * Create Default Ops
+ * @param api
+ * @param signer
+ */
+export async function createDefaultOps(api, signer) {
+  const ops = api.consts.poe.defaultOperations;
+  const txs = ops.map((op) => api.tx.poe.createOperation(op));
+  return new Promise((resolve, reject) => {
+    api.tx.utility
+      .batch(txs)
+      .signAndSend(signer, {}, ({ events = [], status, isError }) => {
+        console.log(`\tTransaction status: ${status.type}`);
+        console.log(`\tEvents: ${events}`);
+
+        if (status.isFinalized) {
+          console.log("\tFinalized block hash", status.asFinalized.toHex());
+          resolve(true);
+        } else if (isError) {
+          console.error(status);
+          reject("Error happened, check console log");
+        }
+      });
+  });
+}
 
 /**
  * Create Rule Transaction
  * @param api
- * @param param1
+ * @param payload
  * @param signer
  */
-export async function saveRuleToNetwork(api, { payload, ruleId }, signer, cb) {
-  // eslint-disable-next-line no-async-promise-executor
+export async function saveRuleToNetwork(api, payload, signer, cb) {
+  // const { nonce } = await api.query.system.account(signer.address);
+  // console.log("Nonce: ", nonce.toString());
   return new Promise((resolve, reject) => {
-    console.log(`\nCreating TX for the ruleId: ${ruleId}`);
+    console.log(`\nCreating Rule...`);
     return api.tx.poe
-      .createRule(ruleId, payload)
+      .createRule(payload)
       .signAndSend(signer, {}, ({ events = [], status, isError }) => {
         console.log(`\tTransaction status:${status.type}`);
 
@@ -159,6 +230,87 @@ export async function saveRuleToNetwork(api, { payload, ruleId }, signer, cb) {
   });
 }
 
+/**
+ * Save Phash
+ * @param api {ApiPromise}
+ * @param params {PhashInfo}
+ * @param signer {KeyPair}
+ * @param cb {Function}
+ */
+export async function savePhashToNetwork(api, payload, signer, cb) {
+  const { nonce } = await api.query.system.account(signer.address);
+  return new Promise((resolve, reject) => {
+    console.log(`\nSaving Phash to the network`);
+    if (cb) cb([null, { message: `Saving the proof to the network` }]);
+    return api.tx.poe
+      .savePhash(payload)
+      .signAndSend(signer, { nonce }, ({ events = [], status, isError }) => {
+        console.log(`\tTransaction status: ${status.type}`);
+        if (cb) cb([null, { message: `Transaction status: ${status.type}` }]);
+
+        if (status.isInBlock) {
+          console.log("\tIncluded at block hash", status.asInBlock.toHex());
+          if (cb)
+            cb([
+              null,
+              {
+                message: `Included at block hash: ${status.asInBlock.toHex()}`,
+              },
+            ]);
+          console.log("\tEvents:", events.length);
+
+          events.forEach(({ event, phase }) => {
+            const { data, method, section } = event;
+            const [error] = data;
+
+            // console.log('\t', phase.toString(), `: ${section}.${method}`, data.toString());
+            // console.log('\t', phase.toString(), `: ${section}.${method}`);
+
+            if (error.isModule) {
+              const {
+                documentation,
+                name,
+                section,
+              } = api.registry.findMetaError(error.asModule);
+              console.error("\t", documentation.toString(), name, section);
+              console.error("\tRejecting ...");
+              if (cb) cb([null, { message: documentation.toString() }]);
+
+              // reject here would make all the other promises to fail
+              reject(documentation.toString());
+
+              // resolve(true);
+            } else {
+              console.log(
+                "\t",
+                phase.toString(),
+                `: ${section}.${method}`,
+                data.toString()
+              );
+              if (cb) cb([null, { message: "Waiting for finalization" }]);
+              resolve(true);
+            }
+          });
+        } else if (status.isFinalized) {
+          console.log("\tFinalized block hash", status.asFinalized.toHex());
+          if (cb) cb([null, { message: "Finalized", success: true }]);
+          resolve(true);
+        } else if (isError) {
+          console.error(status);
+          if (cb) cb([status, null]);
+          reject(status);
+        }
+
+        // console.log(
+        //   `Rule created for ${ForWhat[r.forWhat]}\n hash: ${createdRuleSimple.toHex()}\n cid: ${hexToString(ruleId)}`,
+        // );
+      })
+      .catch((e) => {
+        console.error(e);
+        reject(e);
+      });
+  });
+}
 /**
  * Create Proof Transaction
  * @param api {ApiPromise}
@@ -176,9 +328,8 @@ export async function saveRuleToNetwork(api, { payload, ruleId }, signer, cb) {
 export async function saveProofToNetwork(api, proof, signer, cb) {
   // eslint-disable-next-line no-async-promise-executor
   return new Promise((resolve, reject) => {
-    console.log(
-      `\nCreating TX for the proofId: ${hexToString(proof.proofId.toString())}`
-    );
+    console.log(`\nCreating the proof ...`);
+    let proofId = "";
     if (cb) cb([null, { message: `Saving the proof to the network` }]);
     return api.tx.poe
       .createProof(proof)
@@ -225,14 +376,27 @@ export async function saveProofToNetwork(api, proof, signer, cb) {
                 `: ${section}.${method}`,
                 data.toString()
               );
-              if (cb) cb([null, { message: "Waiting for finalization" }]);
-              resolve(true);
+              if (method === "ProofCreated") {
+                proofId = data[1];
+              }
+
+              if (cb) {
+                cb([
+                  null,
+                  {
+                    message: "Waiting for finalization",
+                    success: true,
+                    proofId,
+                  },
+                ]);
+              }
             }
           });
         } else if (status.isFinalized) {
           console.log("\tFinalized block hash", status.asFinalized.toHex());
-          if (cb) cb([null, { message: "Finalized", success: true }]);
-          resolve(true);
+          if (cb)
+            cb([null, { message: "Finalized", finalized: true, proofId }]);
+          resolve({ finalized: true, proofId });
         } else if (isError) {
           console.error(status);
           if (cb) cb([status, null]);
@@ -283,8 +447,8 @@ export async function calculateHash(data, algo = "blake2b", length = 256) {
  * @param {Buffer} data
  * @param {*} codec
  */
-export function createCID(data, codec = "raw") {
-  return new CID(1, codec, data);
+export function createCID(data, codec = "raw", baseName = "base32") {
+  return new CID(1, codec, data, baseName);
 }
 
 /**
@@ -304,3 +468,29 @@ export const elapsedTime = (start) => {
   const elapsed = Date.now() - start;
   return elapsed;
 };
+
+var toType = function (obj) {
+  return {}.toString
+    .call(obj)
+    .match(/\s([a-zA-Z]+)/)[1]
+    .toLowerCase();
+};
+
+/**
+ * Uses JSON.stringify then creates the buffer and gets byteLength
+ * @param {any} a
+ */
+export function calculateSize(a) {
+  let len;
+  if (Buffer.isBuffer(a)) {
+    len = a.byteLength;
+  } else {
+    len = Buffer.from(JSON.stringify(a)).byteLength;
+  }
+
+  console.log(
+    `Param is of type ${toType(a).toUpperCase()} with length ${parseFloat(
+      len / 1024
+    ).toFixed(2)}kb`
+  );
+}
diff --git a/src/sensio/poe/index.js b/src/sensio/poe/index.js
index 6eae538d3a70f8f10d33cd4e415406c68421fbf6..dd3a9e540c13093993afdb1ecd6dc1fd840c3528 100644
--- a/src/sensio/poe/index.js
+++ b/src/sensio/poe/index.js
@@ -1,7 +1,10 @@
 import React from "react";
-import { Grid, List } from "semantic-ui-react";
+import { Grid } from "semantic-ui-react";
+import CreateRuleChooser from "./rules/CreateRuleChooser";
 
 export default function PoEModule(props) {
+  const { accountPair } = props;
+
   return (
     <Grid>
       <Grid.Row color={"purple"}>
@@ -9,62 +12,33 @@ export default function PoEModule(props) {
       </Grid.Row>
       <Grid.Row>
         <Grid.Column>
-          The ultimate goal of this pallet is to create verifiable proof for any
-          kind of data. If you can turn data into the <code>Buffer</code> you
-          can probably create the PoE. Idea is simple, provide set of rules,
-          apply them on the data, take the output and create the proof. This
-          sound like any hashing function, in essence it is with the difference
-          that in applying just the hashing function on the data we end up with
-          the single value without any descriptors about the data, in some cases
-          we don't even know which hash is used if not specified or implemented
-          as multihash, but applying the rule which contains the list of
-          operations where each operation produces <code>single</code> hash then
-          combining that into structured way for humans, then creating content
-          address we enable interoperability between any producer of the proof.
-          Theoretically the proof can be generated using the any kind of
-          language and stored anywhere, it can be verified if 3 conditions are
-          met: The <code>Proof</code> generation depends on the{" "}
-          <code>Rule</code> definition and its operations.
-          <List as="ol">
-            <List.Item as="li">
-              Rule must be valid and verifiable and retrieved from the
-              SensioNetwork
-            </List.Item>
-            <List.Item as="li">Rule must be applied exactly as it is</List.Item>
-            <List.Item as="li">
-              Proof ID must be broadcasted and available
-            </List.Item>
-            <List.Item as="li">
-              The data can be private and never leave the users domain of
-              control (Optional, it can be public, encrypted ....)
-            </List.Item>
-          </List>
-          Follow the numbers in the navigation, they will help you get the PoE.
-          Also you might want to switch the Account from Alice to Bob then
-          create new proofs and see what will happen.
-          <br></br>
-          <br></br>
-          To learn more about Sensio why not check out our{" "}
-          <a
-            target="_blank"
-            rel="noopener noreferrer"
-            href="https://wiki.sensio.dev"
-          >
-            wiki.
-          </a>
-          <br></br>
-          Our{" "}
-          <a
-            target="_blank"
-            rel="noopener noreferrer"
-            href="https://discordapp.com/invite/WHe4EuY"
-          >
-            discord server is the best place to get in contact with us and ask
-            questions.
-          </a>
-          <br></br>
-          <br></br>
-          Have fun and stay safe 🖖
+          <div>
+            <span>
+              <p>Hi and welcome to Sensio Network Explorer</p>
+              <p>Please check following links for more info:</p>
+              <ul>
+                <li>
+                  <a href="https://wiki.sensio.dev/#/tutorials?id=intro-to-sensio-network-rules-and-proofs">
+                    Tutorial
+                  </a>
+                </li>
+                <li>
+                  <a href="https://wiki.sensio.dev">Wiki</a>
+                </li>
+                <li>
+                  <a href="https://discordapp.com/invite/WHe4EuY">
+                    Discord server
+                  </a>{" "}
+                  to get in touch
+                </li>
+              </ul>
+            </span>
+          </div>
+        </Grid.Column>
+      </Grid.Row>
+      <Grid.Row>
+        <Grid.Column>
+          <CreateRuleChooser accountPair={accountPair} />
         </Grid.Column>
       </Grid.Row>
     </Grid>
diff --git a/src/sensio/poe/operations/genericHash/config.js b/src/sensio/poe/operations/genericHash/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..538642ab894ecc945b42bd1b6cf13e6b0c3385a4
--- /dev/null
+++ b/src/sensio/poe/operations/genericHash/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacebjktneyfak7elakh5jekmd4gapilx3wzxedbg3t7uef2en6wxsjg',
+  data: {
+    op:'generic_hash',
+    desc: 'Generic blake2b 256 hashing op. Any kind of data',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/genericHash/index.js b/src/sensio/poe/operations/genericHash/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..54316b3d1b2842a49554ece42902dd3cb6091667
--- /dev/null
+++ b/src/sensio/poe/operations/genericHash/index.js
@@ -0,0 +1,19 @@
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute genericHash
+ * @param {{file: Buffer, rawPixels: Buffer: data: Buffer}} params
+ * @return string
+ */
+export default async function genericHash({ data }) {
+  let ret = "";
+  ret = createCID(
+    await calculateHash(
+      data,
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/index.js b/src/sensio/poe/operations/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8faef6940229716273d8913fc6f9381aee1683d6
--- /dev/null
+++ b/src/sensio/poe/operations/index.js
@@ -0,0 +1,15 @@
+export * from "./genericHash";
+export * from "./metaCopyright";
+export * from "./metaCreateDate";
+export * from "./metadataHash";
+export * from "./metaDateTimeOriginal";
+export * from "./metaDocumentId";
+export * from "./metaLensInfo";
+export * from "./metaLensModel";
+export * from "./metaLensSerialNumber";
+export * from "./metaMake";
+export * from "./metaModel";
+export * from "./metaOriginalDocumentId";
+export * from "./metaSerialNumber";
+export * from "./perceptualHash";
+export * from "./rawPixelsHash";
diff --git a/src/sensio/poe/operations/metaCopyright/config.js b/src/sensio/poe/operations/metaCopyright/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..2c5798feabcc18525eb90abed56f3e54dc1d086d
--- /dev/null
+++ b/src/sensio/poe/operations/metaCopyright/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacecrub2yp6vkmmquufivmcx63nzvz4py44bih7w5gdmnahqbzvvveu',
+  data: {
+    op:'meta_copyright',
+    desc: 'XMP copyright field',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaCopyright/index.js b/src/sensio/poe/operations/metaCopyright/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..33e45e9e198e3600112452c6f06b3f97f897a5ce
--- /dev/null
+++ b/src/sensio/poe/operations/metaCopyright/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaCopyright
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaCopyright({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { Copyright } = tags;
+
+  if (Copyright && Copyright.value) {
+    val = Copyright.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaCreateDate/config.js b/src/sensio/poe/operations/metaCreateDate/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f2b1c76085035c35934593bf03b9b943ddff9f6
--- /dev/null
+++ b/src/sensio/poe/operations/metaCreateDate/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzaceausafubvfxiikuyn3lu4lue2j23a6ap62fyfxsy6ukeq5gy6hcze',
+  data: {
+    op:'meta_create_date',
+    desc: 'XMP create date',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaCreateDate/index.js b/src/sensio/poe/operations/metaCreateDate/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..96a962d36bc78efedc02715e475c03351baef8c3
--- /dev/null
+++ b/src/sensio/poe/operations/metaCreateDate/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaCreateDate
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaCreateDate({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { CreateDate } = tags;
+
+  if (CreateDate && CreateDate.value) {
+    val = CreateDate.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaDateTimeOriginal/config.js b/src/sensio/poe/operations/metaDateTimeOriginal/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..d9f2fad3e867cc7679d92c7db3b81ec06ed4f8af
--- /dev/null
+++ b/src/sensio/poe/operations/metaDateTimeOriginal/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacebrm2qzoqhpklpqpqff5my42c4mjcqk2stvxieqrozteya2mharim',
+  data: {
+    op:'meta_date_time_original',
+    desc: 'XMP date time original field',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaDateTimeOriginal/index.js b/src/sensio/poe/operations/metaDateTimeOriginal/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..17bbc487ecb9c8955cc0de38ab1aa2f4def7c726
--- /dev/null
+++ b/src/sensio/poe/operations/metaDateTimeOriginal/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaDateTimeOriginal
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaDateTimeOriginal({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { DateTimeOriginal } = tags;
+
+  if (DateTimeOriginal && DateTimeOriginal.value) {
+    val = DateTimeOriginal.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaDocumentId/config.js b/src/sensio/poe/operations/metaDocumentId/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d0817952ec7fd443654de138e7d678faa7ad65f
--- /dev/null
+++ b/src/sensio/poe/operations/metaDocumentId/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacedrcm7vxh4wjacx7oftu7cp5rav4iaws7mqquncp2gb7zqiigerkw',
+  data: {
+    op:'meta_document_id',
+    desc: 'Document ID. The common identifier for all versions and renditions of a resource..to_vec() Found under xmp.did:GUID and parsed only the GUID part without the namespace xmp.did:',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaDocumentId/index.js b/src/sensio/poe/operations/metaDocumentId/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..b54825131858aab6e839fd16caa5c4fa826fe3de
--- /dev/null
+++ b/src/sensio/poe/operations/metaDocumentId/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaDocumentId
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaDocumentId({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { DocumentID } = tags;
+
+  if (DocumentID && DocumentID.value) {
+    val = DocumentID.value.split(":")[1];
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaLensInfo/config.js b/src/sensio/poe/operations/metaLensInfo/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..2f63a842bc8b8adee5a479543286edcd4f7b3d1c
--- /dev/null
+++ b/src/sensio/poe/operations/metaLensInfo/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzaceatxkctrs77acl5kdemff6q6zztmtsvawqke6mueq2wutia3bdsl6',
+  data: {
+    op:'meta_lens_info',
+    desc: 'Extract LensInfo from Metadata',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaLensInfo/index.js b/src/sensio/poe/operations/metaLensInfo/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..b47ab6069cc66f3aafa553f130feb8230ebf8e49
--- /dev/null
+++ b/src/sensio/poe/operations/metaLensInfo/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaLensInfo
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaLensInfo({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { LensInfo } = tags;
+
+  if (LensInfo && LensInfo.value) {
+    val = LensInfo.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaLensModel/config.js b/src/sensio/poe/operations/metaLensModel/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..7f6edc5f0563382e5f07d50beb70cf797c46c71c
--- /dev/null
+++ b/src/sensio/poe/operations/metaLensModel/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacecgsoo3e363rftpxjwnkahwjzslhqcxdtsnlxctf6iojnrbmbjgii',
+  data: {
+    op:'meta_lens_model',
+    desc: 'Extract LensModel from Metadata',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaLensModel/index.js b/src/sensio/poe/operations/metaLensModel/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c33821690746648606b3f3b9d30c2cca929f0e3
--- /dev/null
+++ b/src/sensio/poe/operations/metaLensModel/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaLensModel
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaLensModel({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { LensModel } = tags;
+
+  if (LensModel && LensModel.value) {
+    val = LensModel.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaLensSerialNumber/config.js b/src/sensio/poe/operations/metaLensSerialNumber/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..c1dbfc2b49a6f6fa1fdb8181ee46f79889a8aa91
--- /dev/null
+++ b/src/sensio/poe/operations/metaLensSerialNumber/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacebar5hlfvmy2gmpiinyuoiupen5puwxytskhtbxhqcwzquvxe4pjc',
+  data: {
+    op:'meta_lens_serial_number',
+    desc: 'Extract LensSerialNumber from Metadata',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaLensSerialNumber/index.js b/src/sensio/poe/operations/metaLensSerialNumber/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..515a6b1bdaf91e2891fd4b21bff1f1569386c735
--- /dev/null
+++ b/src/sensio/poe/operations/metaLensSerialNumber/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaLensSerialNumber
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaLensSerialNumber({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { LensSerialNumber } = tags;
+
+  if (LensSerialNumber && LensSerialNumber.value) {
+    val = LensSerialNumber.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaMake/config.js b/src/sensio/poe/operations/metaMake/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..b1cca7c43dd202ed115a6d0060c1b01579980777
--- /dev/null
+++ b/src/sensio/poe/operations/metaMake/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacedjcgyn7iz75u6fbiz4cmbgtc73be64qs5znmfhtaqsdnm36p4qio',
+  data: {
+    op:'meta_make',
+    desc: 'Extract Make from Metadata',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaMake/index.js b/src/sensio/poe/operations/metaMake/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..d535d1bb2bb39302d44be77bb0584578c6658fef
--- /dev/null
+++ b/src/sensio/poe/operations/metaMake/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaMake
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaMake({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { Make } = tags;
+
+  if (Make && Make.value) {
+    val = Make.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaModel/config.js b/src/sensio/poe/operations/metaModel/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..b30b413adde7c0eacfa830829e3c292fe2be36e7
--- /dev/null
+++ b/src/sensio/poe/operations/metaModel/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacechqgoh4uejxav4c22csetm3elqh7ushcp6ejmisxlfztpuhfxuem',
+  data: {
+    op:'meta_model',
+    desc: 'Extract Model from Metadata',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaModel/index.js b/src/sensio/poe/operations/metaModel/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..d3bd8264857e778dfa74695e61a3c8fe31278464
--- /dev/null
+++ b/src/sensio/poe/operations/metaModel/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaModel
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaModel({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { Model } = tags;
+
+  if (Model && Model.value) {
+    val = Model.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaOriginalDocumentId/config.js b/src/sensio/poe/operations/metaOriginalDocumentId/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..5467c3a64271b26e2ef89ca53162fb9afece4f96
--- /dev/null
+++ b/src/sensio/poe/operations/metaOriginalDocumentId/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacecjkupobs3bpluxluzg3oleimzeplqbf7forkqqglnronnjaxbgik',
+  data: {
+    op:'meta_original_document_id',
+    desc: 'Original Document ID. The common identifier for the original resource from which the.to_vec() current resource is derived. For example, if you save a resource to a different format, then save that one to another format, each save operationData should generate a new xmpMM:DocumentID that uniquely identifies the resource in that format, but should retain the ID of the source file here.',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaOriginalDocumentId/index.js b/src/sensio/poe/operations/metaOriginalDocumentId/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..635555deff9034237f5dfc303148f56c952ee09e
--- /dev/null
+++ b/src/sensio/poe/operations/metaOriginalDocumentId/index.js
@@ -0,0 +1,30 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import { formatToUUID } from "../../proofs/execution";
+import config from "./config";
+
+/**
+ * Execute metaOriginalDocumentId
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaOriginalDocumentId({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { OriginalDocumentID } = tags;
+
+  if (OriginalDocumentID && OriginalDocumentID.value) {
+    // in most of my photos this is uuid but without the -
+    val = formatToUUID(OriginalDocumentID.value);
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metaSerialNumber/config.js b/src/sensio/poe/operations/metaSerialNumber/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..550da1a11355c60e7447d480f2a6370dc69153dc
--- /dev/null
+++ b/src/sensio/poe/operations/metaSerialNumber/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacedmu4k7cl6jo7vtkbpduhtx2ilkm7qcqmc4xizy5kfzoiisn4eyrm',
+  data: {
+    op:'meta_serial_number',
+    desc: 'Extract SerialNumber from Metadata',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metaSerialNumber/index.js b/src/sensio/poe/operations/metaSerialNumber/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..9204996dbff503720055f3f410d608d1063ef708
--- /dev/null
+++ b/src/sensio/poe/operations/metaSerialNumber/index.js
@@ -0,0 +1,28 @@
+import ExifReader from "exifreader";
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metaSerialNumber
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metaSerialNumber({ file, rawPixels }) {
+  let ret = "";
+  let val = "";
+  const tags = ExifReader.load(file);
+  const { SerialNumber } = tags;
+
+  if (SerialNumber && SerialNumber.value) {
+    val = SerialNumber.value.toString();
+  }
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(val),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/metadataHash/config.js b/src/sensio/poe/operations/metadataHash/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1714268ed01d75e0e741305c91644da8f5bbf36
--- /dev/null
+++ b/src/sensio/poe/operations/metadataHash/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzacebhohew62aplnobbe6sqb655gnlntyc2nvxbyrdpvomfm3po7iu6m',
+  data: {
+    op:'metadata_hash',
+    desc: 'Hash of full unchanged metadata buffer (or similar). Without raw pixels',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/metadataHash/index.js b/src/sensio/poe/operations/metadataHash/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..5aee27744e6d005044d778c23a2e121399238f3c
--- /dev/null
+++ b/src/sensio/poe/operations/metadataHash/index.js
@@ -0,0 +1,23 @@
+import { stringToU8a } from "@polkadot/util";
+import ExifReader from "exifreader";
+import { calculateHash, createCID, pack } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute metadataHash
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function metadataHash({ file, rawPixels }) {
+  let ret = "";
+  const tags = ExifReader.load(file);
+
+  ret = createCID(
+    await calculateHash(
+      Buffer.from(stringToU8a(pack(tags))),
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/operations/perceptualHash/config.js b/src/sensio/poe/operations/perceptualHash/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..12713b5847a517b87a464a7eb19207479d83c40d
--- /dev/null
+++ b/src/sensio/poe/operations/perceptualHash/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzaced2wspmdlikt43quhqlp5jwcozrzzxd23p3d5zcnbkdv35dyrjeka',
+  data: {
+    op:'perceptual_hash',
+    desc: 'Perceptual hash calculation, currently implementing http://blockhash.io/',
+    hashing: {
+      algo: '',
+      bits: 0,
+      skip: true,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/perceptualHash/index.js b/src/sensio/poe/operations/perceptualHash/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..cddabd088b9fddfef2ae615252ab306aaeec6ee7
--- /dev/null
+++ b/src/sensio/poe/operations/perceptualHash/index.js
@@ -0,0 +1,19 @@
+import { calculatePhash } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute perceptualHash
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function perceptualHash({ file }) {
+  let ret = "";
+  const phash = await calculatePhash(file);
+  if (config.data.ops.length) {
+    throw new Error(
+      `ExecuteOps:: OP has more ops, we don't support that just yet.`
+    );
+  }
+  ret = phash;
+  return ret;
+}
diff --git a/src/sensio/poe/operations/rawPixelsHash/config.js b/src/sensio/poe/operations/rawPixelsHash/config.js
new file mode 100644
index 0000000000000000000000000000000000000000..583c20ec1094fe791144b88310f9519497255b90
--- /dev/null
+++ b/src/sensio/poe/operations/rawPixelsHash/config.js
@@ -0,0 +1,21 @@
+
+/**
+ * Operation specification
+ */
+export default {
+  id: 'bafk2bzaceato2fbapmff54qgjgaba3v54qhz4g2ged54kebkio4hvowi6a3aa',
+  data: {
+    op:'raw_pixels_hash',
+    desc: 'Metadata must be removed and has must be created off of the RAW PIXELS',
+    hashing: {
+      algo: 'blake2b',
+      bits: 256,
+      skip: false,
+    },
+    encoding: {
+      algo: 'hex',
+      prefix: true,
+    },
+    ops: [],
+  },
+};
diff --git a/src/sensio/poe/operations/rawPixelsHash/index.js b/src/sensio/poe/operations/rawPixelsHash/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..680fc97536d28d848cfec3ae4ae82322b8c3745f
--- /dev/null
+++ b/src/sensio/poe/operations/rawPixelsHash/index.js
@@ -0,0 +1,20 @@
+import { calculateHash, createCID } from "../../helpers";
+import config from "./config";
+
+/**
+ * Execute rawPixelsHash
+ * @param {{file: Buffer, rawPixels: Buffer}} params
+ * @return string
+ */
+export default async function rawPixelsHash({ rawPixels }) {
+  let ret = "";
+
+  ret = createCID(
+    await calculateHash(
+      rawPixels,
+      config.data.hashing.algo,
+      config.data.hashing.bits
+    )
+  ).toString();
+  return ret;
+}
diff --git a/src/sensio/poe/pHashes/PhashInfo.js b/src/sensio/poe/pHashes/PhashInfo.js
new file mode 100644
index 0000000000000000000000000000000000000000..eaf2a554979356c9761a814d0ba38c03c293c6a6
--- /dev/null
+++ b/src/sensio/poe/pHashes/PhashInfo.js
@@ -0,0 +1,28 @@
+import React, { useEffect, useState } from "react";
+import { Statistic } from "semantic-ui-react";
+import { useSubstrate } from "../../../substrate-lib";
+import { getPhashes } from "../helpers";
+
+export default function PhashInfo(props) {
+  const { api } = useSubstrate();
+  const [proofs, setProofs] = useState([]);
+
+  useEffect(() => {
+    async function getInfo() {
+      try {
+        const r = await getPhashes(api);
+        setProofs(r);
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    getInfo();
+
+    const i = setInterval(getInfo, 3000);
+    return () => {
+      clearInterval(i);
+    };
+  }, [api]);
+
+  return <Statistic label={"PoE Perceptual Hashes"} value={proofs.length} />;
+}
diff --git a/src/sensio/poe/proofs/CreateProof.js b/src/sensio/poe/proofs/CreateProof.js
index 2c9c1b1fcbf765bd922c0d2d964bf0664ed47086..e900f4141961899cad91a86eb1746b9032939479 100644
--- a/src/sensio/poe/proofs/CreateProof.js
+++ b/src/sensio/poe/proofs/CreateProof.js
@@ -15,12 +15,18 @@ import {
   Segment,
 } from "semantic-ui-react";
 import { useSubstrate } from "../../../substrate-lib";
-import { getRules, saveProofToNetwork } from "../helpers";
+import {
+  calculateSize,
+  getRules,
+  savePhashToNetwork,
+  saveProofToNetwork,
+} from "../helpers";
 import { base64ImageTo, executeRule, getImageSizes } from "./execution";
 
 export default function CreateProof({ accountPair }) {
   const { api } = useSubstrate();
   const history = useHistory();
+  const [proofId, setProofId] = useState();
   const [saving, setSaving] = useState(false);
   const [disableSaveToNetwork, setDisableSaveToNetwork] = useState(true);
   const [savingMessage, setSavingMessage] = useState("");
@@ -37,7 +43,6 @@ export default function CreateProof({ accountPair }) {
 
   const defaultPayloadHolder = {
     rule: null,
-    ruleId: null,
     creator: "",
   };
   const [proofPayload, setProofPayload] = useState(defaultPayloadHolder);
@@ -99,12 +104,17 @@ export default function CreateProof({ accountPair }) {
 
   function handleChangeTheRule(e, { value }) {
     setDisableSaveToNetwork(true);
+
+    const foundRule = rules.find(
+      ({ rule: { id } }) => hexToString(id.toString()) === value
+    );
+
     setProofPayload({
       ...proofPayload,
-      rule: rules[value].rule,
-      ruleId: rules[value].ruleId,
+      rule: foundRule.rule,
     });
   }
+
   function onHandleChange(e, { name, value }) {
     setDisableSaveToNetwork(true);
 
@@ -175,23 +185,56 @@ export default function CreateProof({ accountPair }) {
     setErrorMessage("");
     setSaving(true);
     setDisableSaveToNetwork(true);
-    setSavingMessage("Saving to the Network, check console for more info");
+    setSavingMessage("Talking to Sensio");
     try {
-      await saveProofToNetwork(api, proof, accountPair, ([error, res]) => {
+      calculateSize(proof);
+      saveProofToNetwork(api, proof, accountPair, ([error, res]) => {
         if (error) {
           console.error(error);
           setErrorMessage(error);
           return;
         }
-        const { success } = res;
+        const { success, proofId: pId, finalized } = res;
 
         addNewFeed(res);
 
         if (success) {
+          if (pId) {
+            setProofId(pId);
+          }
+          console.log("Waiting for the finalization");
+          setSavingMessage("Waiting for the finalization");
+
+          // Independently add the Phash if that op exist to the network
+        } else if (finalized) {
           setProofSaved(true);
           setSaving(false);
           setDisableSaveToNetwork(false);
         }
+      }).then(({ finalized, proofId }) => {
+        if (
+          proofPayload.rule.data.ops.find(
+            (o) => hexToString(o.data.op.toString()) === "perceptual_hash"
+          )
+        ) {
+          setSaving(true);
+          setSavingMessage("Indexing");
+          const s = proof.params.find(
+            (p) => hexToString(p.k.toString()) === "perceptual_hash"
+          );
+
+          savePhashToNetwork(
+            api,
+            api.createType("PhashInfo", {
+              pHash: s.v, // phash in the op is just a string, encode it
+              proofId: proofId, // this is byte array, encode it to string
+            }),
+            accountPair
+          ).then((r) => {
+            setSaving(false);
+            setSavingMessage("");
+          });
+        }
       });
     } catch (error) {
       console.error(error);
@@ -207,21 +250,21 @@ export default function CreateProof({ accountPair }) {
       try {
         const r = await getRules(api);
         if (r.length === 0) {
-          history.push("/poe/rules");
+          history.push("/poe/create-rule");
         } else {
           setRules(r);
 
           const _rules = r
             // eslint-disable-next-line array-callback-return
-            .map(({ rule, ruleId }, i) => {
+            .map(({ rule: { data: rule, id } }) => {
               if (rule.forWhat.toString() === "Photo") {
                 const name = hexToString(rule.name.toString());
                 const v = rule.version.toNumber();
-
+                const key = hexToString(id.toString());
                 return {
-                  key: i,
+                  key,
                   text: `v${v} - ${name}`,
-                  value: i,
+                  value: key,
                 };
               }
             })
@@ -355,10 +398,8 @@ export default function CreateProof({ accountPair }) {
             {proofSaved && (
               <Message
                 success
-                header="Proof is created!"
-                content={`Proof ID is ${hexToString(
-                  proof.proofId.toString()
-                )} You better copy it 😉`}
+                header="Proof created! 😉"
+                content={`Proof ID: ${hexToString(proofId.toString())}`}
               />
             )}
           </Grid.Column>
@@ -383,10 +424,7 @@ export default function CreateProof({ accountPair }) {
                 <pre style={{ overflow: "scroll" }}>
                   {JSON.stringify(
                     {
-                      proof,
-                      bodyDecoded: JSON.parse(
-                        hexToString(proof.body.toString())
-                      ),
+                      ...proof,
                     },
                     null,
                     2
diff --git a/src/sensio/poe/proofs/ProofsList.js b/src/sensio/poe/proofs/ProofsList.js
index 45f51eab08e79c257aacbfe9b5ac2b66eaee85f0..0ffaa266804ac1d0c2c52cb43754dbfd58c55c83 100644
--- a/src/sensio/poe/proofs/ProofsList.js
+++ b/src/sensio/poe/proofs/ProofsList.js
@@ -1,21 +1,12 @@
 import { hexToString } from "@polkadot/util";
 import React, { useEffect, useState } from "react";
-import {
-  Button,
-  Container,
-  Divider,
-  Grid,
-  Icon,
-  Input,
-  List,
-} from "semantic-ui-react";
+import { Container, Divider, Grid, Icon, List } from "semantic-ui-react";
 import { useSubstrate } from "../../../substrate-lib";
 import CodeModal from "../CodeModal";
-import { getProofs } from "../helpers";
+import { calculateSize, getProofs } from "../helpers";
 
 export default function ProofsList({ accountPair }) {
   const { api } = useSubstrate();
-  const [allProofs, seAllProofs] = useState([]);
   const [proofs, setProofs] = useState([]);
   const [interval, setCurrentInterval] = useState(0);
 
@@ -23,27 +14,9 @@ export default function ProofsList({ accountPair }) {
     const getInfo = async () => {
       try {
         const p = await getProofs(api);
-        const _p = p.map(({ proof, accountId, blockNumber }) => {
-          const { proofId, body, createdAt, ruleId, forWhat } = proof;
 
-          return {
-            proof: {
-              ...proof,
-              body: {
-                ...JSON.parse(hexToString(body.toString())),
-                ruleId: hexToString(ruleId.toString()),
-              },
-              proofId: hexToString(proofId.toString()),
-              ruleId: hexToString(ruleId.toString()),
-              forWhat: forWhat.toString(),
-              createdAt: new Date(createdAt.toNumber()),
-            },
-            accountId: accountId.toString(),
-            blockNumber,
-          };
-        });
-        seAllProofs(_p);
-        setProofs(_p);
+        calculateSize(p);
+        setProofs(p);
       } catch (e) {
         console.error(e);
       }
@@ -58,15 +31,6 @@ export default function ProofsList({ accountPair }) {
     };
   }, [api, interval]);
 
-  function handleSearch(e, { name, value }) {
-    if (!value) {
-      setProofs(allProofs);
-      return;
-    }
-    const ps = proofs.filter((p) => p.proof.proofId === value);
-    setProofs(ps);
-  }
-
   return (
     <Container>
       <Grid>
@@ -75,31 +39,20 @@ export default function ProofsList({ accountPair }) {
             <h1 style={{ marginLeft: 16 }}>PoE Rules</h1>
           </Grid.Column>
         </Grid.Row>
-        <Grid.Row>
-          <Grid.Column width="13">
-            <Input
-              fluid
-              focus
-              icon="search"
-              placeholder="Proof ID ..."
-              onChange={handleSearch}
-            />
-          </Grid.Column>
-          <Grid.Column width="3">
-            <Button onClick={() => setProofs(allProofs)}>
-              Show All proofs
-            </Button>
-          </Grid.Column>
-        </Grid.Row>
+
         {proofs.length !== 0 && (
           <Grid.Row>
             <Grid.Column>
               <List divided verticalAlign="middle" size="large">
-                {proofs.map(({ proof, accountId, blockNumber }, i) => {
-                  const { proofId, body, createdAt, forWhat } = proof;
+                {proofs.map(({ proof, accountId }, i) => {
+                  const {
+                    id,
+                    data: { params, creator, forWhat },
+                  } = proof;
 
+                  const proofId = hexToString(id.toString());
                   return (
-                    <List.Item key={proofId}>
+                    <List.Item key={id.toString()}>
                       <List.Content floated="right">
                         <CodeModal
                           title="RAW"
@@ -121,15 +74,12 @@ export default function ProofsList({ accountPair }) {
 
                       <List.Content>
                         <List.Header style={{ paddingTop: 10 }}>
-                          {forWhat} {proofId}
+                          {forWhat.toString()}ID: {proofId}
                         </List.Header>
                         <List.Description>
                           <div>
-                            Owned by: <code>{body.owner}</code>
-                          </div>
-                          <div>
-                            Created at:{" "}
-                            <strong>{createdAt.toISOString()}</strong>
+                            Owned by:{" "}
+                            <code>{hexToString(creator.toString())}</code>
                           </div>
                           <Divider />
                           Assigned to the account <code>{accountId}</code>
@@ -137,7 +87,7 @@ export default function ProofsList({ accountPair }) {
                         <List.Description>
                           <Divider />
                           <pre style={{ maxWidth: 1100 }}>
-                            {JSON.stringify(body.params, null, 2)}
+                            {JSON.stringify(params, null, 2)}
                           </pre>
                         </List.Description>
                       </List.Content>
diff --git a/src/sensio/poe/proofs/execution.js b/src/sensio/poe/proofs/execution.js
index bfbdec5d9eb52d74b6014bfa7b4855d3fae1912e..dc1695e2a2f39bc0e56593c5d201f36e9479f2cd 100644
--- a/src/sensio/poe/proofs/execution.js
+++ b/src/sensio/poe/proofs/execution.js
@@ -1,14 +1,6 @@
-import { hexToString, stringToU8a } from "@polkadot/util";
-import ExifReader from "exifreader";
+import { hexToString, stringCamelCase } from "@polkadot/util";
 import { imageSize } from "image-size";
-import {
-  calculateHash,
-  calculatePhash,
-  createCID,
-  elapsedTime,
-  objectToString,
-} from "../helpers";
-
+import { calculateHash, createCID, elapsedTime } from "../helpers";
 /**
  * Return the sizes of an image
  * @return {{height: number, width: number, type: string}}
@@ -22,7 +14,7 @@ export function getImageSizes(fileReader) {
 
 /**
  * Transform base64 image path to array buffer
- * @return {Buffer | ArrayBuffer}
+ * @return {Buffer | ArrayBuffer | Binary}
  * @param {*} base64
  */
 export function base64ImageTo(base64, toWhat) {
@@ -56,352 +48,46 @@ export function base64ImageTo(base64, toWhat) {
  * metadata_hash - hex encoded
  * perceptual_hash - hex encoded ???
  *
- * @param {Rule} rule
+ * @param {[Operation]} operations
  * @param {Buffer} file
- * @param {Buffer} fileWithoutMetadata
+ * @param {Buffer} rawPixels
  * @return {Promise<string[]>}
  */
 
 export async function executeOps(operations, file, rawPixels) {
-  const tags = ExifReader.load(file);
   return Promise.all(
     operations.map(async (operation) => {
-      const { op: OperationName, hashAlgo, hashBits, ops } = operation;
-      // eslint-disable-next-line prefer-const
-      let ret = "",
-        b,
-        h,
-        mh;
-      const op = hexToString(OperationName.toString());
-      const hashAlgoDecoded = hexToString(hashAlgo.toString());
-      const hashBitsDecoded = hashBits.toNumber();
-
-      switch (op) {
-        case "perceptual_hash":
-          const phash = await calculatePhash(file);
-          if (ops.length) {
-            throw new Error(
-              `ExecuteOps:: OP has more ops, we don't support that just yet.`
-            );
-          }
-          ret = phash;
-          break;
-        case "meta_image_description":
-          ret = h;
-          break;
-        case "metadata_hash":
-          b = stringToU8a(objectToString(tags));
-          mh = await calculateHash(b, hashAlgoDecoded, hashBitsDecoded);
-          h = createCID(mh);
-          if (ops.length) {
-            throw new Error(
-              `ExecuteOps:: OP has more ops, we don't support that just yet.`
-            );
-          }
-          ret = h.toString();
-          break;
-        case "raw_pixels_hash":
-          // here we should take the raw pixel hash only
-          mh = await calculateHash(file, hashAlgoDecoded, hashBitsDecoded);
-          h = createCID(mh);
-
-          if (ops.length) {
-            throw new Error(
-              `ExecuteOps:: OP has more ops, we don't support that just yet.`
-            );
-          }
-          ret = h.toString();
-          break;
-
-        case "meta_document_id":
-          const { DocumentID } = tags;
-          if (DocumentID && DocumentID.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(DocumentID.value?.split(":")[1]),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
+      const {
+        data: { op: OperationName },
+      } = operation;
 
-        case "meta_original_document_id":
-          const { OriginalDocumentID } = tags;
-          if (OriginalDocumentID && OriginalDocumentID.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(formatToUUID(OriginalDocumentID.value)),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_create_date":
-          const { CreateDate } = tags;
-          if (CreateDate && CreateDate.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(CreateDate.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_date_time_original":
-          const { DateTimeOriginal } = tags;
-          if (DateTimeOriginal && DateTimeOriginal.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(DateTimeOriginal.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_copyright":
-          const { Copyright } = tags;
-          if (Copyright && Copyright.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(Copyright.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_serial_number":
-          const { SerialNumber } = tags;
-          if (SerialNumber && SerialNumber.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(SerialNumber.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_make":
-          const { Make } = tags;
-          if (Make && Make.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(Make.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_model":
-          const { Model } = tags;
-          if (Model && Model.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(Model.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_lens_serial_number":
-          const { LensSerialNumber } = tags;
-          if (LensSerialNumber && LensSerialNumber.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(LensSerialNumber.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_lens_info":
-          const { LensInfo } = tags;
-          if (LensInfo && LensInfo.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(LensInfo.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-        case "meta_lens_model":
-          const { LensModel } = tags;
-          if (LensModel && LensModel.value) {
-            h = createCID(
-              await calculateHash(
-                Buffer.from(LensModel.value.toString()),
-                hashAlgoDecoded,
-                hashBitsDecoded
-              )
-            );
-            if (ops.length) {
-              throw new Error(
-                `ExecuteOps:: OP has more ops, we don't support that just yet.`
-              );
-            }
-            ret = h.toString();
-          }
-          break;
-
-        case "poe_camera_id":
-          let ecOps = await executeOps(ops, file, rawPixels);
-
-          h = createCID(
-            await calculateHash(
-              Buffer.from(objectToString(buildBody(ops, ecOps))),
-              hashAlgoDecoded,
-              hashBitsDecoded
-            )
-          );
-          ret = h.toString();
-          break;
-        case "poe_lens_id":
-          let elOps = await executeOps(ops, file, rawPixels);
-
-          h = createCID(
-            await calculateHash(
-              Buffer.from(objectToString(buildBody(ops, elOps))),
-              hashAlgoDecoded,
-              hashBitsDecoded
-            )
-          );
-          ret = h.toString();
-          break;
-
-        default:
-          throw new Error("No default operation accepted." + op);
-      }
-      return ret;
+      const op = hexToString(OperationName.toString());
+      const t = await import(`../operations/${stringCamelCase(op)}`);
+      const output = await t.default({ rawPixels, file });
+      console.debug(`Executed op ${op}:`, output);
+      return { k: op, v: output };
     })
   );
 }
 
-/**
- * Map the executed ops to the ops itself. could be good thing for refactor in the future
- * @param rule {Rule}
- * @param executedOps  {string[]}
- * @return { { [ k:string ] : any } }
- */
-
-function buildBody(ops, executedOps) {
-  // eslint-disable-next-line prefer-const
-  let body = {};
-  ops.forEach((op, i) => {
-    const opName = hexToString(op.op.toString());
-    return (body[opName] = executedOps[i]);
-  });
-  return body;
-}
-
 /**
  *
  * @param {Rule} rule
- * @param {string} ruleId
- * @param {any} body
- * @param {string} creator
- * @param {*} prev
- * @return {Promise<{
-      "proofId": string, // hex encoded string
-      "body": string, // hex encoded string
-      "createdAt": string, // hex encoded string
-      "prev": string, //  hex encoded string
-      "ruleId": string, //  hex encoded string
-      "forWhat": string, //  ForWhat enum
-    }>}
+ * @param {string} ruleId Comes decoded
+ * @param {any} params
+ * @param {string} owner
+ * @param {string} prev
+ * @return {Promise<ProofData>}
  */
-async function buildProof(api, rule, ruleId, params = {}, owner, prev = "") {
-  const ruleIdDecoded = hexToString(ruleId);
-  const body = {
-    params,
-    owner: createCID(await calculateHash(owner)).toString(),
-    ruleId: ruleIdDecoded,
-    forWhat: rule.forWhat,
-  };
-
-  const bodyString = objectToString(body);
-  const proofId = createCID(
-    await calculateHash(Buffer.from(bodyString))
-  ).toString();
-
-  const proof = {
-    proofId,
-    body: bodyString,
-    createdAt: Date.now(),
+async function buildProof(api, rule, params = {}, owner, prev = "") {
+  const proofData = {
+    ruleId: rule.id,
     prev,
-    ruleId: ruleIdDecoded,
-    forWhat: rule.forWhat.toString(),
+    creator: createCID(await calculateHash(owner)).toString(),
+    forWhat: rule.data.forWhat.toString(),
+    params,
   };
-  return api.createType("Proof", proof);
+  return api.createType("ProofData", proofData);
 }
 
 /**
@@ -437,21 +123,16 @@ export function formatToUUID(uuid) {
  * @param {function} cb
  * @return {Promise<{payload: any, proof:string}>}
  */
-export async function executeRule(api, params, cb) {
+export async function executeRule(api, { rule, rawPixels, file, creator }, cb) {
   try {
     const mainPerf = Date.now();
-    const { rule, rawPixels, file, ruleId, creator } = params;
 
     let perf = Date.now();
-    const ops = await executeOps(rule.ops, file, rawPixels);
+    const params = await executeOps(rule.data.ops, file, rawPixels);
     cb([null, { message: "Executing OPS", elapsedTime: elapsedTime(perf) }]);
 
     perf = Date.now();
-    const body = buildBody(rule.ops, ops);
-    cb([null, { message: "Building Body", elapsedTime: elapsedTime(perf) }]);
-
-    perf = Date.now();
-    const payload = await buildProof(api, rule, ruleId, body, creator);
+    const payload = await buildProof(api, rule, params, creator);
     cb([null, { message: "Building Proof", elapsedTime: elapsedTime(perf) }]);
 
     cb([
@@ -462,7 +143,7 @@ export async function executeRule(api, params, cb) {
         elapsedTime: elapsedTime(mainPerf),
       },
     ]);
-
+    console.debug(payload);
     return payload;
   } catch (error) {
     console.error(error);
diff --git a/src/sensio/poe/rules/CreateRule.js b/src/sensio/poe/rules/CreateRule.js
index e39a839c352fe6c121d879c0074f6a077f6f0d08..92353e9e1e59e4ead4ed8876fcff7febd8f17534 100644
--- a/src/sensio/poe/rules/CreateRule.js
+++ b/src/sensio/poe/rules/CreateRule.js
@@ -1,6 +1,5 @@
-import { nanoid } from "nanoid";
+import { hexToString } from "@polkadot/util";
 import React, { useEffect, useState } from "react";
-import { useHistory } from "react-router-dom";
 import {
   Container,
   Dimmer,
@@ -12,142 +11,14 @@ import {
 } from "semantic-ui-react";
 import { CUSTOM_TYPES } from "../../../config/common.json";
 import { useSubstrate } from "../../../substrate-lib";
-import {
-  createRulePayload,
-  findDuplicates,
-  saveRuleToNetwork,
-} from "../helpers";
+import { getOperations, saveRuleToNetwork } from "../helpers";
 import CreateRuleChooser from "./CreateRuleChooser";
-import { cameraRule, lensRule, photoRule } from "./defaultRules";
 
 function formatForWhat() {
   return CUSTOM_TYPES.ForWhat._enum.map((m, i) => {
     return { key: i, text: m, value: i };
   });
 }
-function buildCurrentOperationNames() {
-  let ops = [
-    ...cameraRule.ops,
-    ...lensRule.ops,
-    ...photoRule.ops,
-    ...[cameraRule.buildParams, lensRule.buildParams, photoRule.buildParams],
-  ];
-
-  let ret = [];
-  ops.forEach((o, i) => {
-    if (ret.find((r) => r.value === o.op)) {
-      return;
-    }
-
-    // for now don't include ops that contain other ops, they are special
-    if (o.ops.length !== 0) {
-      return;
-    }
-    ret.push({ key: i, text: o.op, value: o.op });
-  });
-
-  return ret;
-}
-
-const operations = buildCurrentOperationNames();
-
-/**
- * Functional component for creating the Operation
- * @param {*}
- */
-function Operation({ op, onHandleChange, allDisabled, defaultValue }) {
-  return (
-    <div>
-      <Form.Group widths="equal">
-        <Form.Input
-          fluid
-          label="Name"
-          placeholder={op.name}
-          defaultValue={op.name}
-          onChange={onHandleChange}
-          disabled={allDisabled ? true : false}
-          name="name"
-          input={{ maxLength: 20 }}
-        />
-        <Form.Input
-          fluid
-          label="Description"
-          placeholder={op.desc}
-          defaultValue={op.desc}
-          onChange={onHandleChange}
-          disabled={allDisabled ? true : false}
-          name="desc"
-        />
-
-        <Form.Select
-          fluid
-          label="Operation"
-          options={operations}
-          defaultValue={defaultValue || operations[0].value}
-          onChange={onHandleChange}
-          disabled={allDisabled ? true : false}
-          name="op"
-        />
-        <Form.Input
-          fluid
-          label="Hashing Algo"
-          placeholder={op.hashAlgo}
-          defaultValue={op.hashAlgo}
-          onChange={onHandleChange}
-          disabled={allDisabled ? true : false}
-          name="hashAlgo"
-        />
-      </Form.Group>
-      <Form.Group widths="equal">
-        <Form.Input
-          fluid
-          label="Hashing Bits"
-          type="number"
-          placeholder={op.hashBits}
-          defaultValue={op.hashBits}
-          onChange={onHandleChange}
-          disabled={allDisabled ? true : false}
-          name="hashBits"
-        />
-        <Form.Input
-          fluid
-          label="Encoding Algo"
-          placeholder={op.encodeAlgo}
-          defaultValue={op.encodeAlgo}
-          onChange={onHandleChange}
-          disabled={allDisabled ? true : false}
-          name="encodeAlgo"
-        />
-        <Form.Input
-          fluid
-          label="Prefix"
-          placeholder={op.prefix}
-          defaultValue={op.prefix}
-          onChange={onHandleChange}
-          disabled={allDisabled ? true : false}
-          name="prefix"
-        />
-      </Form.Group>
-    </div>
-  );
-}
-
-/**
- * Create default structure for the Operation
- */
-function createDefaultOperation() {
-  return {
-    _id: nanoid(),
-    name: "Change me name",
-    desc: "Longer description",
-    op: operations[0].value,
-    hashAlgo: "blake2b",
-    hashBits: 256,
-    encodeAlgo: "hex",
-    prefix: "0x",
-    ops: [],
-  };
-}
 
 export default function CreateRule(props) {
   const defaultVal = {
@@ -157,24 +28,14 @@ export default function CreateRule(props) {
     creator: "urn:pgp:d1f5e247a976f1e3c14f0a437a6db9962ef3978e",
     forWhat: 1,
     ops: [],
-    buildParams: {
-      name: "Build Params",
-      desc:
-        "Build the payload in a way we need for this rule. Take all the values from each of the `ops",
-      op: "build_params",
-      hashAlgo: "",
-      hashBits: 0,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
   };
 
-  const history = useHistory();
-
   const { api } = useSubstrate();
   const { accountPair } = props;
 
+  const [ops, setOps] = useState([]);
+  const [ruleOps, setRuleOps] = useState([]);
+  const [selectableOps, setSelectableOps] = useState([]);
   const [rule, setRule] = useState(defaultVal);
   const [errorMessage, setErrorMessage] = useState("");
   const [readyToSubmit, setReadyToSubmit] = useState(false);
@@ -188,31 +49,20 @@ export default function CreateRule(props) {
   async function handleSubmit() {
     setErrorMessage("");
     setSaving(true);
-    const opNames = rule.ops.map((o) => {
-      return o.op;
-    });
+    const opsForRule = ops
+      .filter(({ op }) => ruleOps.includes(hexToString(op.id.toString())))
+      .map(({ op }) => op);
 
-    const dupes = findDuplicates(opNames);
-
-    if (dupes.length !== 0) {
-      setErrorMessage(
-        `Duplicates in ops, check the Operation field in Operations. Dupes: [${dupes.join(
-          ","
-        )}]`
-      );
-      setSaving(false);
-    }
-    const ruleOpsClean = rule.ops.map(({ _id, ...rest }) => {
-      return rest;
-    });
-    const rulePayload = await createRulePayload(api, {
+    const ruleData = api.createType("RuleData", {
       ...rule,
-      ops: ruleOpsClean,
+      ops: opsForRule,
     });
 
+    console.log(ruleData);
+
     await saveRuleToNetwork(
       api,
-      rulePayload,
+      ruleData,
       accountPair,
       ([error, message, success]) => {
         if (error) {
@@ -223,70 +73,68 @@ export default function CreateRule(props) {
           setSavingMessage(message);
           if (success) {
             setSavingMessage(message);
-            setTimeout(() => {
-              setSaving(false);
-              history.push("/poe/rules");
-            }, 700);
+            setSaving(false);
           }
         }
       }
     );
   }
 
-  function handleValueChange(e, { name, value }) {
+  function handleOperationChange(e, { value }) {
     e.preventDefault();
 
-    setRule({
-      ...rule,
-      [name]: value,
-    });
+    // const op = ops.find(({ op }) => {
+    //   hexToString(op.id.toString()) === value
+    //     ? console.log("yea", hexToString(op.id.toString()))
+    //     : console.log("nay", hexToString(op.id.toString()));
+    // });
+    // console.log("find op", value, ops, op);
+    setRuleOps(value);
   }
-
-  function handleOperationValueChange(e, { name, value }, opId) {
+  function handleValueChange(e, { name, value }) {
     e.preventDefault();
-    const op = rule.ops.find((o) => o._id === opId);
-    const opIndex = rule.ops.findIndex((o) => o._id === opId);
-    const ops = rule.ops;
-    op[name] = value;
 
-    ops[opIndex] = op;
-    console.log(ops);
     setRule({
       ...rule,
-      ops,
+      [name]: value,
     });
   }
-  function handleChangeBuildParams(e, { name, value }) {
-    e.preventDefault();
 
-    setRule({
-      ...rule,
-      buildParams: { [name]: value },
-    });
-  }
+  useEffect(() => {
+    if (ruleOps.length >= 1) {
+      setReadyToSubmit(true);
+    }
+  }, [ruleOps]);
 
-  function addNewOperation() {
-    const ops = rule.ops;
-    ops.unshift(createDefaultOperation());
-    setRule({
-      ...rule,
-      ops,
-    });
-  }
+  useEffect(() => {
+    async function getOps() {
+      const opsList = await getOperations(api);
+      setOps(opsList);
+      const ret = [];
+      opsList.forEach(({ op: { id, data: o } }, i) => {
+        const opId = hexToString(id.toString());
+        const opName = hexToString(o.op.toString());
+        if (ret.find((r) => r.value === opName)) {
+          return;
+        }
 
-  function deleteOperation(id) {
-    const ops = rule.ops.filter((f) => f._id !== id);
-    setRule({
-      ...rule,
-      ops,
-    });
-  }
+        // for now don't include ops that contain other ops, they are special
+        if (o.ops.length !== 0) {
+          return;
+        }
 
-  useEffect(() => {
-    if (rule.ops.length >= 1) {
-      setReadyToSubmit(true);
+        ret.push({
+          key: opId,
+          text: opName.replace(/_/gi, " "),
+          value: opId,
+        });
+      });
+      setSelectableOps(ret);
     }
-  }, [rule]);
+
+    getOps();
+  }, [api, selectableOps]);
+
   const MessageExampleFloating = () => (
     <Message negative floating>
       {errorMessage}
@@ -357,68 +205,17 @@ export default function CreateRule(props) {
                 name="forWhat"
               />
               <Divider />
-              <div>
-                <div
-                  style={{
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "space-between",
-                  }}
-                >
-                  <h3>Operations: {rule.ops.length}</h3>
-                  <Form.Button color="purple" onClick={addNewOperation}>
-                    Add new operation
-                  </Form.Button>
-                </div>
-                <Divider />
-                <div>
-                  {rule.ops.map((op, i) => (
-                    <div key={op._id} style={{ marginBottom: 16 }}>
-                      <div style={{ marginBottom: 16 }}>
-                        <h3>#{i + 1}</h3>
-                      </div>
-                      <div>
-                        <Operation
-                          op={op}
-                          onHandleChange={(e, t) =>
-                            handleOperationValueChange(e, t, op._id)
-                          }
-                        />
-                        {rule.ops.length !== 1 && (
-                          <Form.Button
-                            disabled={rule.ops.length === 1}
-                            onClick={() => deleteOperation(op._id)}
-                            color="red"
-                          >
-                            Delete operation :: {op._id}
-                          </Form.Button>
-                        )}
-                      </div>
-                    </div>
-                  ))}
-                </div>
-              </div>
-
-              <Divider />
-
-              <div>
-                <div style={{ marginBottom: 16 }}>
-                  <div style={{ marginBottom: 16 }}>
-                    <h3>Build Params</h3>
-                  </div>
-                  <div>
-                    <Operation
-                      op={rule.buildParams}
-                      defaultValue={
-                        operations.find((o) => o.value === rule.buildParams.op)
-                          .value
-                      }
-                      onHandleChange={handleChangeBuildParams}
-                      allDisabled
-                    />
-                  </div>
-                </div>
-              </div>
+              <Form.Select
+                fluid
+                multiple
+                search
+                selection
+                label="Operations"
+                options={selectableOps}
+                onChange={handleOperationChange}
+                value={ruleOps}
+                name="ops"
+              />
 
               <Form.Button
                 onClick={handleSubmit}
diff --git a/src/sensio/poe/rules/CreateRuleChooser.js b/src/sensio/poe/rules/CreateRuleChooser.js
index c555e24da8ef6655bf2b9ceec5a27dedd49ddb80..8847cdb8fc1df8d148f87f55c9dfa77686561c4a 100644
--- a/src/sensio/poe/rules/CreateRuleChooser.js
+++ b/src/sensio/poe/rules/CreateRuleChooser.js
@@ -1,16 +1,7 @@
-import React, { useState } from "react";
-import { Link } from "react-router-dom";
-import {
-  Button,
-  Divider,
-  Grid,
-  Header,
-  Icon,
-  Loader,
-  Segment,
-} from "semantic-ui-react";
+import React, { useEffect, useState } from "react";
+import { Button, Grid, Loader, Segment } from "semantic-ui-react";
 import { useSubstrate } from "../../../substrate-lib";
-import { createDefaultRules } from "../helpers";
+import { createDefaultRules, getOperations } from "../helpers";
 
 export default function CreateRuleChooser(props) {
   const { accountPair } = props;
@@ -19,41 +10,34 @@ export default function CreateRuleChooser(props) {
   const [savingMessage, setSavingMessage] = useState(
     "Saving, check console for more info"
   );
+  const [ops, setOps] = useState([]);
 
   function handleClickCreateDefaultRules(e) {
     e.preventDefault();
     setCreating(true);
-    createDefaultRules(api, accountPair).then((r) => {
+    createDefaultRules(api, accountPair, ops).then((r) => {
       if (r) {
         setSavingMessage("");
         setCreating(false);
       }
     });
   }
+
+  useEffect(() => {
+    async function run() {
+      const opsList = await getOperations(api);
+      setOps(opsList);
+    }
+    run();
+  }, [api]);
   return (
-    <Segment placeholder>
+    <Segment>
       <Loader active={creating} inline="centered">
         {savingMessage} ...
       </Loader>
-      <Grid columns={2} stackable textAlign="center">
-        <Divider vertical>Or</Divider>
-
+      <Grid stackable textAlign="center">
         <Grid.Row verticalAlign="middle">
           <Grid.Column>
-            <Header icon>
-              <Icon name="file outline" />
-            </Header>
-            <Button color="orange" disabled={creating}>
-              <Link style={{ color: "white" }} to="/poe/create-rule">
-                Create Custom Rule
-              </Link>
-            </Button>
-          </Grid.Column>
-
-          <Grid.Column>
-            <Header icon>
-              <Icon name="copy outline" />
-            </Header>
             <Button
               disabled={creating}
               onClick={handleClickCreateDefaultRules}
diff --git a/src/sensio/poe/rules/RulesList.js b/src/sensio/poe/rules/RulesList.js
index 5b9d00f69aaf4347cd6bdc95f6827161459a737d..04b95e515bb5a376132a21d16c7a650f900720a5 100644
--- a/src/sensio/poe/rules/RulesList.js
+++ b/src/sensio/poe/rules/RulesList.js
@@ -49,42 +49,43 @@ export default function RulesList({ accountPair }) {
           <Grid.Row>
             <Grid.Column>
               <List divided verticalAlign="middle" size="large">
-                {rules.map(
-                  ({ rule, ruleId, accountNumber, blockNumber }, i) => {
-                    const { forWhat, version, desc, name } = rule;
-                    const color = colors[i];
+                {rules.map((v, i) => {
+                  const {
+                    rule: { id, data },
+                  } = v;
+                  const { forWhat, version, desc, name } = data;
+                  const color = colors[i];
 
-                    return (
-                      <List.Item key={hexToString(ruleId.toString())}>
-                        <List.Content floated="right">
-                          <CodeModal data={rule} />
-                        </List.Content>
-                        <Icon
-                          style={{
-                            color: color,
-                            fontSize: "2em",
-                            paddingTop: 10,
-                          }}
-                          name="circle thin"
-                        />
+                  return (
+                    <List.Item key={hexToString(id.toString())}>
+                      <List.Content floated="right">
+                        <CodeModal data={v} />
+                      </List.Content>
+                      <Icon
+                        style={{
+                          color: color,
+                          fontSize: "2em",
+                          paddingTop: 10,
+                        }}
+                        name="circle thin"
+                      />
 
-                        <List.Content>
-                          <List.Header>
-                            {hexToString(name.toString())}
-                          </List.Header>
-                          <List.Header></List.Header>
+                      <List.Content>
+                        <List.Header>
+                          Name: {hexToString(name.toString())}
+                        </List.Header>
+                        <List.Header>Operations: {data.ops.length}</List.Header>
+                        <List.Description>
+                          This is the rule for {forWhat.toString()} and version
+                          v{version.toString()}
                           <List.Description>
-                            This is the rule for {forWhat.toString()} and
-                            version v{version.toString()}
-                            <List.Description>
-                              {hexToString(desc.toString())}
-                            </List.Description>
+                            {hexToString(desc.toString())}
                           </List.Description>
-                        </List.Content>
-                      </List.Item>
-                    );
-                  }
-                )}
+                        </List.Description>
+                      </List.Content>
+                    </List.Item>
+                  );
+                })}
               </List>
             </Grid.Column>
           </Grid.Row>
diff --git a/src/sensio/poe/rules/defaultRules.js b/src/sensio/poe/rules/defaultRules.js
index aef6bcf4b6c9aab1773483da5be9cd2fe6aededf..4c4e007e521fad28da15c4218706f6e036c8e5b6 100644
--- a/src/sensio/poe/rules/defaultRules.js
+++ b/src/sensio/poe/rules/defaultRules.js
@@ -8,44 +8,10 @@ export const lensRule = {
   creator: defaultCreator,
   forWhat: 3,
   ops: [
-    {
-      desc: "Extract LensSerialNumber from Metadata",
-      op: "meta_lens_serial_number", // this is the name of the param
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc: "Extract LensInfo from Metadata",
-      op: "meta_lens_info",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc: "Extract LensModel from Metadata",
-      op: "meta_lens_model",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
+    "meta_lens_serial_number", // this is the name of the param
+    "meta_lens_info",
+    "meta_lens_model",
   ],
-  buildParams: {
-    desc:
-      "Build the payload in a way we need for this rule. Take all the values from each of the `ops",
-    op: "build_params",
-    hashAlgo: "",
-    hashBits: 0,
-    encodeAlgo: "hex",
-    prefix: "0x",
-    ops: [],
-  },
 };
 
 export const cameraRule = {
@@ -55,44 +21,10 @@ export const cameraRule = {
   creator: defaultCreator,
   forWhat: 2,
   ops: [
-    {
-      desc: "Extract SerialNumber from Metadata",
-      op: "meta_serial_number", // this is the name of the param
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc: "Extract Make from Metadata",
-      op: "meta_make",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc: "Extract Model from Metadata",
-      op: "meta_model",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
+    "meta_serial_number", // this is the name of the param
+    "meta_make",
+    "meta_model",
   ],
-  buildParams: {
-    desc:
-      "Build the payload in a way we need for this rule. Take all the values from each of the `ops",
-    op: "build_params",
-    hashAlgo: "",
-    hashBits: 0,
-    encodeAlgo: "hex",
-    prefix: "0x",
-    ops: [],
-  },
 };
 
 export const photoRule = {
@@ -102,110 +34,15 @@ export const photoRule = {
   creator: defaultCreator,
   forWhat: 1,
   ops: [
-    {
-      desc:
-        "Hash of full unchanged metadata buffer (or similar). Without raw pixels",
-      op: "metadata_hash",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc:
-        "Metadata must be removed and has must be created off of the RAW PIXELS",
-      op: "raw_pixels_hash",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc:
-        "Perceptual hash calculation, currently implementing http://blockhash.io/",
-      op: "perceptual_hash",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc:
-        "Document ID. The common identifier for all versions and renditions of a resource. Found under xmp.did:GUID and parsed only the GUID part without the namespace xmp.did:",
-      op: "meta_document_id",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc:
-        "Original Document ID. The common identifier for the original resource from which the current resource is derived. For example, if you save a resource to a different format, then save that one to another format, each save operation should generate a new xmpMM:DocumentID that uniquely identifies the resource in that format, but should retain the ID of the source file here.",
-      op: "meta_original_document_id",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc: "XMP date time original field",
-      op: "meta_date_time_original",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc: "XMP create date",
-      op: "meta_create_date",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc: "XMP copyright field",
-      op: "meta_copyright",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: [],
-    },
-    {
-      desc: "Import all the rules from the camera rule",
-      op: "poe_camera_id",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: cameraRule.ops,
-    },
-    {
-      desc: "Import all the rules from the lens rule",
-      op: "poe_lens_id",
-      hashAlgo: "blake2b",
-      hashBits: 256,
-      encodeAlgo: "hex",
-      prefix: "0x",
-      ops: lensRule.ops,
-    },
+    "metadata_hash",
+    "raw_pixels_hash",
+    "perceptual_hash",
+    "meta_document_id",
+    "meta_original_document_id",
+    "meta_date_time_original",
+    "meta_create_date",
+    "meta_copyright",
+    ...cameraRule.ops,
+    ...lensRule.ops,
   ],
-  buildParams: {
-    desc:
-      "Build the payload in a way we need for this rule. Take all the values from each of the `ops",
-    op: "build_params",
-    hashAlgo: "",
-    hashBits: 0,
-    encodeAlgo: "hex",
-    prefix: "0x",
-    ops: [],
-  },
 };
diff --git a/src/sensio/poe/scripts/gen.js b/src/sensio/poe/scripts/gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e176e7baf75380f181225d9c5d450122bf17a05
--- /dev/null
+++ b/src/sensio/poe/scripts/gen.js
@@ -0,0 +1,74 @@
+const fs = require("fs");
+const path = require("path");
+const util = require("@polkadot/util");
+const ops = require("./ops");
+
+function genOpFiles() {
+  ops.forEach(
+    ({
+      id,
+      data: {
+        op,
+        desc,
+        hashing,
+        encoding: { algo: encAlgo, prefix },
+      },
+    }) => {
+      const opName = util.stringCamelCase(util.hexToString(op));
+
+      const defaultOperation = `
+/**
+ * Operation specification
+ */
+export default {
+  id: '${id}',
+  data: {
+    op:'${util.hexToString(op)}',
+    desc: '${util.hexToString(desc)}',
+    hashing: {
+      algo: '${util.hexToString(hashing.algo)}',
+      bits: ${hashing.bits},
+      skip: ${hashing.skip},
+    },
+    encoding: {
+      algo: '${util.hexToString(encAlgo)}',
+      prefix: ${prefix},
+    },
+    ops: [],
+  },
+};
+`;
+      const mainFuncBodyTpl = `
+
+import { stringToHex } from "@polkadot/util";
+import { calculateHash, createCID } from "../helpers";
+  /**
+* Execute ${opName}
+* @param {{file: Buffer, rawPixels: Buffer}} params
+* @return string
+*/
+export default async function ${opName}(params) {
+  throw new Error('IMPLEMENT ME');
+}`;
+
+      // create new structure
+
+      const indexPath = path.resolve(
+        __dirname,
+        `../operations/${opName}/index.js`
+      );
+      const configPath = path.resolve(
+        __dirname,
+        `../operations/${opName}/config.js`
+      );
+
+      if (!fs.existsSync(indexPath)) {
+        fs.mkdirSync(path.resolve(__dirname, `../operations/${opName}`));
+        fs.writeFileSync(configPath, defaultOperation);
+        fs.writeFileSync(indexPath, mainFuncBodyTpl);
+      }
+    }
+  );
+}
+
+genOpFiles();
diff --git a/src/sensio/poe/scripts/ops.json b/src/sensio/poe/scripts/ops.json
new file mode 100644
index 0000000000000000000000000000000000000000..8121ae087501897c6cafca3a45f1b984e2cacb99
--- /dev/null
+++ b/src/sensio/poe/scripts/ops.json
@@ -0,0 +1,167 @@
+[
+  {
+    "id": "bafk2bzacebjktneyfak7elakh5jekmd4gapilx3wzxedbg3t7uef2en6wxsjg",
+    "data": {
+      "registry": {},
+      "op": "0x67656e657269635f68617368",
+      "desc": "0x47656e6572696320626c616b653262203235362068617368696e67206f702e20416e79206b696e64206f662064617461",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacedjcgyn7iz75u6fbiz4cmbgtc73be64qs5znmfhtaqsdnm36p4qio",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f6d616b65",
+      "desc": "0x45787472616374204d616b652066726f6d204d65746164617461",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacedmu4k7cl6jo7vtkbpduhtx2ilkm7qcqmc4xizy5kfzoiisn4eyrm",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f73657269616c5f6e756d626572",
+      "desc": "0x457874726163742053657269616c4e756d6265722066726f6d204d65746164617461",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzaceatxkctrs77acl5kdemff6q6zztmtsvawqke6mueq2wutia3bdsl6",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f6c656e735f696e666f",
+      "desc": "0x45787472616374204c656e73496e666f2066726f6d204d65746164617461",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzaceato2fbapmff54qgjgaba3v54qhz4g2ged54kebkio4hvowi6a3aa",
+    "data": {
+      "registry": {},
+      "op": "0x7261775f706978656c735f68617368",
+      "desc": "0x4d65746164617461206d7573742062652072656d6f76656420616e6420686173206d7573742062652063726561746564206f6666206f66207468652052415720504958454c53",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacecrub2yp6vkmmquufivmcx63nzvz4py44bih7w5gdmnahqbzvvveu",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f636f70797269676874",
+      "desc": "0x584d5020636f70797269676874206669656c64",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacebhohew62aplnobbe6sqb655gnlntyc2nvxbyrdpvomfm3po7iu6m",
+    "data": {
+      "registry": {},
+      "op": "0x6d657461646174615f68617368",
+      "desc": "0x48617368206f662066756c6c20756e6368616e676564206d657461646174612062756666657220286f722073696d696c6172292e20576974686f75742072617720706978656c73",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacechqgoh4uejxav4c22csetm3elqh7ushcp6ejmisxlfztpuhfxuem",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f6d6f64656c",
+      "desc": "0x45787472616374204d6f64656c2066726f6d204d65746164617461",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacecjkupobs3bpluxluzg3oleimzeplqbf7forkqqglnronnjaxbgik",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f6f726967696e616c5f646f63756d656e745f6964",
+      "desc": "0x4f726967696e616c20446f63756d656e742049442e2054686520636f6d6d6f6e206964656e74696669657220666f7220746865206f726967696e616c207265736f757263652066726f6d207768696368207468652e746f5f76656328292063757272656e74207265736f7572636520697320646572697665642e20466f72206578616d706c652c20696620796f7520736176652061207265736f7572636520746f206120646966666572656e7420666f726d61742c207468656e20736176652074686174206f6e6520746f20616e6f7468657220666f726d61742c20656163682073617665206f7065726174696f6e446174612073686f756c642067656e65726174652061206e657720786d704d4d3a446f63756d656e744944207468617420756e697175656c79206964656e74696669657320746865207265736f7572636520696e207468617420666f726d61742c206275742073686f756c642072657461696e20746865204944206f662074686520736f757263652066696c6520686572652e",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzaceausafubvfxiikuyn3lu4lue2j23a6ap62fyfxsy6ukeq5gy6hcze",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f6372656174655f64617465",
+      "desc": "0x584d50206372656174652064617465",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacebar5hlfvmy2gmpiinyuoiupen5puwxytskhtbxhqcwzquvxe4pjc",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f6c656e735f73657269616c5f6e756d626572",
+      "desc": "0x45787472616374204c656e7353657269616c4e756d6265722066726f6d204d65746164617461",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacebrm2qzoqhpklpqpqff5my42c4mjcqk2stvxieqrozteya2mharim",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f646174655f74696d655f6f726967696e616c",
+      "desc": "0x584d5020646174652074696d65206f726967696e616c206669656c64",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacedrcm7vxh4wjacx7oftu7cp5rav4iaws7mqquncp2gb7zqiigerkw",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f646f63756d656e745f6964",
+      "desc": "0x446f63756d656e742049442e2054686520636f6d6d6f6e206964656e74696669657220666f7220616c6c2076657273696f6e7320616e642072656e646974696f6e73206f662061207265736f757263652e2e746f5f766563282920466f756e6420756e64657220786d702e6469643a4755494420616e6420706172736564206f6e6c79207468652047554944207061727420776974686f757420746865206e616d65737061636520786d702e6469643a",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzacecgsoo3e363rftpxjwnkahwjzslhqcxdtsnlxctf6iojnrbmbjgii",
+    "data": {
+      "registry": {},
+      "op": "0x6d6574615f6c656e735f6d6f64656c",
+      "desc": "0x45787472616374204c656e734d6f64656c2066726f6d204d65746164617461",
+      "hashing": { "bits": 256, "algo": "0x626c616b653262", "skip": false },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  },
+  {
+    "id": "bafk2bzaced2wspmdlikt43quhqlp5jwcozrzzxd23p3d5zcnbkdv35dyrjeka",
+    "data": {
+      "registry": {},
+      "op": "0x7065726365707475616c5f68617368",
+      "desc": "0x5065726365707475616c20686173682063616c63756c6174696f6e2c2063757272656e746c7920696d706c656d656e74696e6720687474703a2f2f626c6f636b686173682e696f2f",
+      "hashing": { "bits": 0, "algo": "0x", "skip": true },
+      "encoding": { "algo": "0x686578", "prefix": true },
+      "ops": []
+    }
+  }
+]
diff --git a/src/sensio/poe/templates/operation/package.json b/src/sensio/poe/templates/operation/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..5fe9abaad07e2a374d4dcd433fc87511d8a9eed8
--- /dev/null
+++ b/src/sensio/poe/templates/operation/package.json
@@ -0,0 +1,6 @@
+{
+  "name": "OPERATION_NAME",
+  "version": "0.1.0",
+  "main": "index.js",
+  "license": "MIT"
+}
diff --git a/src/sensio/poe/templates/operation/src/index.js b/src/sensio/poe/templates/operation/src/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/sensio/poe/templates/operation/yarn.lock b/src/sensio/poe/templates/operation/yarn.lock
new file mode 100644
index 0000000000000000000000000000000000000000..3ff608aed0d65a3d61d9f29c9daa7af32c2a4e62
--- /dev/null
+++ b/src/sensio/poe/templates/operation/yarn.lock
@@ -0,0 +1,4 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
diff --git a/src/substrate-lib/SubstrateContext.js b/src/substrate-lib/SubstrateContext.js
index c7ccc86328e3a8df3b43c40477bc3075a921446d..3250dc91bb2b903ec1c74a44c26b923110253253 100644
--- a/src/substrate-lib/SubstrateContext.js
+++ b/src/substrate-lib/SubstrateContext.js
@@ -1,10 +1,9 @@
 import PropTypes from "prop-types";
-import queryString from "query-string";
 import React, { useReducer } from "react";
 import config from "../config";
 
-const parsedQuery = queryString.parse(window.location.search);
-const connectedSocket = parsedQuery.rpc || config.PROVIDER_SOCKET;
+const rpcURL = localStorage.getItem("rpcURL");
+const connectedSocket = rpcURL || config.PROVIDER_SOCKET;
 console.log(`Connected socket: ${connectedSocket}`);
 
 const INIT_STATE = {
diff --git a/yarn.lock b/yarn.lock
index b142e708242968ce20e08412c61e4aa87ef8efa5..95bf536b01f4f3cc48f117527d8b9faaac9583b6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2333,6 +2333,11 @@ array-equal@^1.0.0:
   resolved "https://registry.yarnpkg.com/array-equal/-/array-equal-1.0.0.tgz#8c2a5ef2472fd9ea742b04c77a75093ba2757c93"
   integrity sha1-jCpe8kcv2ep0KwTHenUJO6J1fJM=
 
+array-filter@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/array-filter/-/array-filter-1.0.0.tgz#baf79e62e6ef4c2a4c0b831232daffec251f9d83"
+  integrity sha1-uveeYubvTCpMC4MSMtr/7CUfnYM=
+
 array-flatten@1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/array-flatten/-/array-flatten-1.1.1.tgz#9a5f699051b1e7073328f2a008968b64ea2955d2"
@@ -2423,6 +2428,16 @@ assert@^1.1.1:
     object-assign "^4.1.1"
     util "0.10.3"
 
+assert@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/assert/-/assert-2.0.0.tgz#95fc1c616d48713510680f2eaf2d10dd22e02d32"
+  integrity sha512-se5Cd+js9dXJnu6Ag2JFc00t+HmHOen+8Q+L7O9zI0PqQXr20uk2J0XQqMxZEeo5U50o8Nvmmx7dZrl+Ufr35A==
+  dependencies:
+    es6-object-assign "^1.1.0"
+    is-nan "^1.2.1"
+    object-is "^1.0.1"
+    util "^0.12.0"
+
 assign-symbols@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
@@ -2478,6 +2493,13 @@ autoprefixer@^9.6.1:
     postcss "^7.0.26"
     postcss-value-parser "^4.0.2"
 
+available-typed-arrays@^1.0.0, available-typed-arrays@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.2.tgz#6b098ca9d8039079ee3f77f7b783c4480ba513f5"
+  integrity sha512-XWX3OX8Onv97LMk/ftVyBibpGwY5a8SmuxZPzeOxqmuEqUCOM9ZE+uIaD1VNJ5QnvU2UQusvmKbuM1FR8QWGfQ==
+  dependencies:
+    array-filter "^1.0.0"
+
 aws-sign2@~0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
@@ -2702,6 +2724,11 @@ big.js@^5.2.2:
   resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
   integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
 
+bignumber.js@^9.0.0:
+  version "9.0.0"
+  resolved "https://registry.yarnpkg.com/bignumber.js/-/bignumber.js-9.0.0.tgz#805880f84a329b5eac6e7cb6f8274b6d82bdf075"
+  integrity sha512-t/OYhhJ2SD+YGBQcjY8GzzDHEk9f3nerxjtfa6tlMXfe7frs/WozhvCNoGvpM0P3bNf3Gq5ZRMlGr5f3r4/N8A==
+
 binary-extensions@^1.0.0:
   version "1.13.1"
   resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.13.1.tgz#598afe54755b2868a5330d2aff9d4ebb53209b65"
@@ -3098,6 +3125,14 @@ caseless@~0.12.0:
   resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
   integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=
 
+cbor@^5.0.2:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/cbor/-/cbor-5.0.2.tgz#aa8c3820280ebb9f3a45b2a4c66ac344294443de"
+  integrity sha512-6JiKVURxxO92FntzTJq54QdN/8fBaBwD7+nNyGIAi1HL9mBgU3YK6ULV8k7WTuT/EwfRsjy3MuqDKlkQMCmfXg==
+  dependencies:
+    bignumber.js "^9.0.0"
+    nofilter "^1.0.3"
+
 chalk@2.4.2, chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.4.1, chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
@@ -4340,6 +4375,23 @@ es-abstract@^1.17.0, es-abstract@^1.17.0-next.1, es-abstract@^1.17.2:
     string.prototype.trimleft "^2.1.1"
     string.prototype.trimright "^2.1.1"
 
+es-abstract@^1.17.4, es-abstract@^1.17.5:
+  version "1.17.5"
+  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.17.5.tgz#d8c9d1d66c8981fb9200e2251d799eee92774ae9"
+  integrity sha512-BR9auzDbySxOcfog0tLECW8l28eRGpDpU3Dm3Hp4q/N+VtLTmyj4EUN088XZWQDW/hzj6sYRDXeOFsaAODKvpg==
+  dependencies:
+    es-to-primitive "^1.2.1"
+    function-bind "^1.1.1"
+    has "^1.0.3"
+    has-symbols "^1.0.1"
+    is-callable "^1.1.5"
+    is-regex "^1.0.5"
+    object-inspect "^1.7.0"
+    object-keys "^1.1.1"
+    object.assign "^4.1.0"
+    string.prototype.trimleft "^2.1.1"
+    string.prototype.trimright "^2.1.1"
+
 es-to-primitive@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a"
@@ -4367,6 +4419,11 @@ es6-iterator@2.0.3, es6-iterator@^2.0.3, es6-iterator@~2.0.3:
     es5-ext "^0.10.35"
     es6-symbol "^3.1.1"
 
+es6-object-assign@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/es6-object-assign/-/es6-object-assign-1.1.0.tgz#c2c3582656247c39ea107cb1e6652b6f9f24523c"
+  integrity sha1-wsNYJlYkfDnqEHyx5mUrb58kUjw=
+
 es6-symbol@^3.1.1, es6-symbol@~3.1.3:
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18"
@@ -5114,6 +5171,11 @@ for-own@^0.1.3:
   dependencies:
     for-in "^1.0.1"
 
+foreach@^2.0.5:
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.5.tgz#0bee005018aeb260d0a3af3ae658dd0136ec1b99"
+  integrity sha1-C+4AUBiusmDQo6865ljdATbsG5k=
+
 forever-agent@~0.6.1:
   version "0.6.1"
   resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
@@ -6104,6 +6166,11 @@ is-generator-fn@^2.0.0:
   resolved "https://registry.yarnpkg.com/is-generator-fn/-/is-generator-fn-2.1.0.tgz#7d140adc389aaf3011a8f2a2a4cfa6faadffb118"
   integrity sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==
 
+is-generator-function@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.0.7.tgz#d2132e529bb0000a7f80794d4bdf5cd5e5813522"
+  integrity sha512-YZc5EwyO4f2kWCax7oegfuSr9mFz1ZvieNYBEjmukLxgXfBUbxAWGVF7GZf0zidYtoBl3WvC07YK0wT76a+Rtw==
+
 is-glob@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
@@ -6118,6 +6185,13 @@ is-glob@^4.0.0, is-glob@^4.0.1:
   dependencies:
     is-extglob "^2.1.1"
 
+is-nan@^1.2.1:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/is-nan/-/is-nan-1.3.0.tgz#85d1f5482f7051c2019f5673ccebdb06f3b0db03"
+  integrity sha512-z7bbREymOqt2CCaZVly8aC4ML3Xhfi0ekuOnjO2L8vKdl+CttdVoGZQhd4adMFAsxQ5VeRVwORs4tU8RH+HFtQ==
+  dependencies:
+    define-properties "^1.1.3"
+
 is-number@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
@@ -6217,6 +6291,16 @@ is-symbol@^1.0.2:
   dependencies:
     has-symbols "^1.0.1"
 
+is-typed-array@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.3.tgz#a4ff5a5e672e1a55f99c7f54e59597af5c1df04d"
+  integrity sha512-BSYUBOK/HJibQ30wWkWold5txYwMUXQct9YHAQJr8fSwvZoiglcqB0pd7vEN23+Tsi9IUEjztdOSzl4qLVYGTQ==
+  dependencies:
+    available-typed-arrays "^1.0.0"
+    es-abstract "^1.17.4"
+    foreach "^2.0.5"
+    has-symbols "^1.0.1"
+
 is-typedarray@^1.0.0, is-typedarray@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
@@ -7672,6 +7756,11 @@ node-releases@^1.1.29, node-releases@^1.1.50:
   dependencies:
     semver "^6.3.0"
 
+nofilter@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/nofilter/-/nofilter-1.0.3.tgz#34e54b4cc9757de0cad38cc0d19462489b1b7f5d"
+  integrity sha512-FlUlqwRK6reQCaFLAhMcF+6VkVG2caYjKQY3YsRDTl4/SEch595Qb3oLjJRDr8dkHAAOVj2pOx3VknfnSgkE5g==
+
 noop-logger@^0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/noop-logger/-/noop-logger-0.1.1.tgz#94a2b1633c4f1317553007d8966fd0e841b6a4c2"
@@ -11204,6 +11293,18 @@ util@^0.11.0:
   dependencies:
     inherits "2.0.3"
 
+util@^0.12.0:
+  version "0.12.3"
+  resolved "https://registry.yarnpkg.com/util/-/util-0.12.3.tgz#971bb0292d2cc0c892dab7c6a5d37c2bec707888"
+  integrity sha512-I8XkoQwE+fPQEhy9v012V+TSdH2kp9ts29i20TaaDUXsg7x/onePbhFJUExBfv/2ay1ZOp/Vsm3nDlmnFGSAog==
+  dependencies:
+    inherits "^2.0.3"
+    is-arguments "^1.0.4"
+    is-generator-function "^1.0.7"
+    is-typed-array "^1.1.3"
+    safe-buffer "^5.1.2"
+    which-typed-array "^1.1.2"
+
 utila@^0.4.0, utila@~0.4:
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/utila/-/utila-0.4.0.tgz#8a16a05d445657a3aea5eecc5b12a4fa5379772c"
@@ -11489,6 +11590,18 @@ which-pm-runs@^1.0.0:
   resolved "https://registry.yarnpkg.com/which-pm-runs/-/which-pm-runs-1.0.0.tgz#670b3afbc552e0b55df6b7780ca74615f23ad1cb"
   integrity sha1-Zws6+8VS4LVd9rd4DKdGFfI60cs=
 
+which-typed-array@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.2.tgz#e5f98e56bda93e3dac196b01d47c1156679c00b2"
+  integrity sha512-KT6okrd1tE6JdZAy3o2VhMoYPh3+J6EMZLyrxBQsZflI1QCZIxMrIYLkosd8Twf+YfknVIHmYQPgJt238p8dnQ==
+  dependencies:
+    available-typed-arrays "^1.0.2"
+    es-abstract "^1.17.5"
+    foreach "^2.0.5"
+    function-bind "^1.1.1"
+    has-symbols "^1.0.1"
+    is-typed-array "^1.1.3"
+
 which@^1.2.9, which@^1.3.0, which@^1.3.1:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"