zkjson 0.1.24 → 0.1.26

package/contracts/ZKIPFS.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+import "./ZKQuery.sol";
+import "hardhat/console.sol";
+
+interface VerifierIPFS {
+  function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[43] calldata _pubSignals) external view returns (bool);
+}
+
+contract ZKIPFS is ZKQuery{
+  uint constant SIZE_PATH = 5;
+  uint constant SIZE_VAL = 5;
+  address public verifierIPFS;
+  bytes constant ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  
+  function charArrayToString(bytes1[46] memory charArray) public pure returns (string memory) {
+    bytes memory byteArray = new bytes(charArray.length);
+    for(uint i = 0; i < charArray.length; i++) {
+      byteArray[i] = charArray[i];
+    }
+    return string(byteArray);
+  }
+
+  function concat(string memory a, string memory b) public pure returns (string memory) {
+    return string(abi.encodePacked(a, b));
+  }
+  
+  function uriEqual(string memory a, string memory b) public pure returns (bool) {
+    return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
+  }
+  
+  function toCID(uint[34] memory source) public pure returns (string memory) {
+    uint zeroes = 0;
+    uint length = 0;
+    uint pbegin = 0;
+    uint pend = source.length;
+    while (pbegin != pend && source[pbegin] == 0) {
+      pbegin++;
+      zeroes++;
+    }
+    uint size = 46;
+    uint[46] memory b58;
+    while (pbegin != pend) {
+      uint carry = source[pbegin];
+      uint i = 0;
+      for ( uint it1 = size - 1; (carry != 0 || i < length); it1-- ) {
+	carry += (256 * b58[it1]);
+	b58[it1] = carry % 58;
+	carry = (carry / 58);
+	i++;
+	if(it1 == 0) break;
+      }
+      length = i;
+      pbegin++;
+    }
+    uint it2 = size - length;
+    while (it2 != size && b58[it2] == 0) it2++;
+    bytes1[46] memory str;
+    uint i = 0;
+    for (; it2 < size; ++it2){
+      str[i] = ALPHABET[b58[it2]];
+      i++;
+    }
+    return charArrayToString(str);
+  }
+  
+  function ipfsURI(uint[34] memory source) public pure returns (string memory) {
+    return concat("ipfs://", toCID(source));
+  }
+  
+  function _validateQueryIPFS(uint[] memory path, uint[] memory zkp, uint size_path, uint size_val) internal pure returns(uint[] memory){
+    require(zkp[8] == 1, "value doesn't exist");
+    uint len = 41;
+    for(uint i = len; i < len + size_path; i++){
+      require((path.length <= i - len && zkp[i] == 0) || path[i - len] == zkp[i], "wrong path");
+    }
+    uint[] memory value = new uint[](size_val);
+    for(uint i = len + size_path; i < len + size_path + size_val; i++){
+      value[i - (len + size_val)] = zkp[i];
+    }
+    return toArr(value);
+  }
+  
+  function validateQuery(string memory URI, uint[] memory path, uint[] memory zkp) internal pure returns(uint[] memory){
+    uint[34] memory hash;
+    hash[0] = 18;
+    hash[1] = 32;
+    for(uint i = 9; i < 41; i++) hash[i - 7] = zkp[i];
+    string memory CID = ipfsURI(hash);
+    require(uriEqual(CID,URI), "wrong CID");
+    verify(zkp, VerifierIPFS.verifyProof.selector, verifierIPFS);
+    return _validateQueryIPFS(path, zkp, SIZE_PATH, SIZE_VAL);
+  }
+
+}

package/nft.js

@@ -0,0 +1,131 @@
+const crypto = require("crypto")
+const snarkjs = require("snarkjs")
+const { query, pad, path, val } = require("./encoder")
+const { push, arr } = require("./uint")
+const { parse } = require("./parse")
+
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") return o
+  if (o instanceof ArrayBuffer) return new Uint8Array(o)
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength)
+  }
+  throw new Error("Unknown type, must be binary type")
+}
+
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+const BASE = ALPHABET.length
+const LEADER = ALPHABET.charAt(0)
+const FACTOR = Math.log(BASE) / Math.log(256)
+const iFACTOR = Math.log(256) / Math.log(BASE)
+
+function toCID(source) {
+  if (source instanceof Uint8Array);
+  else if (ArrayBuffer.isView(source)) {
+    source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
+  } else if (Array.isArray(source)) {
+    source = Uint8Array.from(source)
+  }
+  if (!(source instanceof Uint8Array)) {
+    throw new TypeError("Expected Uint8Array")
+  }
+  if (source.length === 0) return ""
+
+  var zeroes = 0
+  var length = 0
+  var pbegin = 0
+  var pend = source.length
+  while (pbegin !== pend && source[pbegin] === 0) {
+    pbegin++
+    zeroes++
+  }
+
+  var size = ((pend - pbegin) * iFACTOR + 1) >>> 0
+  var b58 = new Uint8Array(size)
+  while (pbegin !== pend) {
+    var carry = source[pbegin]
+    var i = 0
+    for (
+      var it1 = size - 1;
+      (carry !== 0 || i < length) && it1 !== -1;
+      it1--, i++
+    ) {
+      carry += (256 * b58[it1]) >>> 0
+      b58[it1] = carry % BASE >>> 0
+      carry = (carry / BASE) >>> 0
+    }
+    if (carry !== 0) {
+      throw new Error("Non-zero carry")
+    }
+    length = i
+    pbegin++
+  }
+  var it2 = size - length
+  while (it2 !== size && b58[it2] === 0) {
+    it2++
+  }
+  var str = LEADER.repeat(zeroes)
+  for (; it2 < size; ++it2) {
+    str += ALPHABET.charAt(b58[it2])
+  }
+  return str
+}
+
+class NFT {
+  constructor({
+    size_val = 5,
+    size_path = 5,
+    size_json = 256,
+    nBlocks = 10,
+    wasm,
+    zkey,
+    json,
+  }) {
+    this.json = json
+    this.wasm = wasm
+    this.zkey = zkey
+    this.nBlocks = nBlocks
+    this.size_val = size_val
+    this.size_path = size_path
+    this.size_json = size_json
+  }
+  path(pth) {
+    return pad(path(pth), this.size_path)
+  }
+  val(pth) {
+    return pad(val(this.json[pth]), this.size_val)
+  }
+  query(pth, cond) {
+    return pad(query(cond), this.size_val)
+  }
+
+  async zkp(pth, cond) {
+    const str = new TextEncoder().encode(JSON.stringify(this.json))
+    let encoded = arr(256)
+    for (let v of Array.from(str))
+      encoded = push(encoded, this.size_json, 76, v)
+    const enc = parse(encoded, 256)
+    const _path = this.path(pth)
+    const _val = Array.isArray(cond) ? this.query(pth, cond) : this.val(pth)
+    const inputs = { path: _path, val: _val, encoded }
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+      inputs,
+      this.wasm,
+      this.zkey,
+    )
+    return [
+      ...proof.pi_a.slice(0, 2),
+      ...proof.pi_b[0].slice(0, 2).reverse(),
+      ...proof.pi_b[1].slice(0, 2).reverse(),
+      ...proof.pi_c.slice(0, 2),
+      ...publicSignals,
+    ]
+  }
+  cid() {
+    const str = new TextEncoder().encode(JSON.stringify(this.json))
+    const hash = coerce(crypto.createHash("sha256").update(str).digest())
+    return toCID(new Uint8Array([18, hash.length, ...Array.from(hash)]))
+  }
+}
+
+module.exports = NFT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zkjson",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Zero Knowledge Provable JSON",
   "main": "index.js",
   "license": "MIT",

package/uint.js

@@ -591,4 +591,5 @@ module.exports = {
   concat,
   bn,
   digits,
+  str,
 }