circomlibjs-hinkal-fork 0.0.1 → 0.0.3

package/main.js

@@ -1,25 +1,7 @@
 export {default as buildBabyjub} from "./src/babyjub.js";
-export {default as buildEddsa} from "./src/eddsa.js";
-export {default as evmasm} from "./src/evmasm.js";
 
-export {default as buildMimc7} from "./src/mimc7.js";
-import * as _mimc7Contract  from "./src/mimc7_gencontract.js";
-export const mimc7Contract=_mimc7Contract;
 
-export {default as buildMimcSponge} from "./src/mimcsponge.js";
-import * as _mimcSpongeContract  from "./src/mimcsponge_gencontract.js";
-export const mimcSpongecontract=_mimcSpongeContract;
-
-export {default as buildPedersenHash} from "./src/pedersen_hash.js";
 
 export { buildPoseidon, buildPoseidonWasm } from "./src/poseidon_wasm.js";
-import * as _poseidonContract  from "./src/poseidon_gencontract.js";
-export const poseidonContract=_poseidonContract;
-
-export {default as buildPoseidonReference} from "./src/poseidon_reference.js";
-export {default as buildPoseidonOpt} from "./src/poseidon_opt.js";
-
-export {SMT, buildSMT, newMemEmptyTrie} from "./src/smt.js";
 
-export { default as SMTMemDb } from "./src/smt_memdb.js";
 

package/package.json

@@ -7,7 +7,7 @@
     "import": "./main.js",
     "require": "./build/main.cjs"
   },
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Javascript library to work with circomlib",
   "scripts": {
     "test": "mocha",
@@ -30,11 +30,6 @@
     "mocha": "^9.1.3"
   },
   "dependencies": {
-    "blake-hash": "^2.0.0",
-    "blake2b": "^2.1.3",
-    "ethers": "^5.5.1",
-    "ffjavascript": "^0.3.0",
-    "buffer": "6.0.3",
-    "process": "0.11.10"
+    "ffjavascript": "^0.3.0"
   }
 }

package/src/eddsa.js

@@ -1,286 +0,0 @@
-import { Scalar } from "ffjavascript";
-import buildBabyJub from "./babyjub.js";
-import buildPedersenHash from "./pedersen_hash.js";
-import buildMimc7 from "./mimc7.js";
-import { buildPoseidon } from "./poseidon_wasm.js";
-import buildMimcSponge from "./mimcsponge.js";
-import createBlakeHash from "blake-hash";
-import {Buffer} from 'buffer';
-
-export default async function buildEddsa() {
-    const babyJub = await buildBabyJub("bn128");
-    const pedersenHash = await buildPedersenHash();
-    const mimc7 = await buildMimc7();
-    const poseidon = await buildPoseidon();
-    const mimcSponge = await buildMimcSponge();
-    return new Eddsa(babyJub, pedersenHash, mimc7, poseidon, mimcSponge);
-}
-
-class Eddsa {
-
-    constructor(babyJub, pedersenHash, mimc7, poseidon, mimcSponge) {
-        this.babyJub = babyJub;
-        this.pedersenHash = pedersenHash;
-        this.mimc7 = mimc7;
-        this.poseidon = poseidon;
-        this.mimcSponge = mimcSponge;
-        this.F = babyJub.F;
-    }
-
-    pruneBuffer(buff) {
-        buff[0] = buff[0] & 0xF8;
-        buff[31] = buff[31] & 0x7F;
-        buff[31] = buff[31] | 0x40;
-        return buff;
-    }
-
-    prv2pub(prv) {
-        const F = this.babyJub.F;
-        const sBuff = this.pruneBuffer(createBlakeHash("blake512").update(Buffer.from(prv)).digest());
-        let s = Scalar.fromRprLE(sBuff, 0, 32);
-        const A = this.babyJub.mulPointEscalar(this.babyJub.Base8, Scalar.shr(s,3));
-        return A;
-    }
-
-    signPedersen(prv, msg) {
-        const F = this.babyJub.F;
-        const sBuff = this.pruneBuffer(createBlakeHash("blake512").update(Buffer.from(prv)).digest());
-        const s = Scalar.fromRprLE(sBuff, 0, 32);
-        const A = this.babyJub.mulPointEscalar(this.babyJub.Base8, Scalar.shr(s, 3));
-
-        const composeBuff = new Uint8Array(32 + msg.length);
-        composeBuff.set(sBuff.slice(32), 0);
-        composeBuff.set(msg, 32);
-        const rBuff = createBlakeHash("blake512").update(Buffer.from(composeBuff)).digest();
-        let r = Scalar.mod(Scalar.fromRprLE(rBuff, 0, 64), this.babyJub.subOrder);
-        const R8 = this.babyJub.mulPointEscalar(this.babyJub.Base8, r);
-        const R8p = this.babyJub.packPoint(R8);
-        const Ap = this.babyJub.packPoint(A);
-
-        const composeBuff2 = new Uint8Array(64 + msg.length);
-        composeBuff2.set(R8p, 0);
-        composeBuff2.set(Ap, 32);
-        composeBuff2.set(msg, 64);
-
-        const hmBuff = this.pedersenHash.hash(composeBuff2);
-        const hm = Scalar.fromRprLE(hmBuff, 0, 32);
-
-        const S = Scalar.mod(
-            Scalar.add(
-                r,
-                Scalar.mul(hm, s)
-            ),
-            this.babyJub.subOrder
-        )
-        return {
-            R8: R8,
-            S: S
-        };
-    }
-
-    signMiMC(prv, msg) {
-        const F = this.babyJub.F;
-        const sBuff = this.pruneBuffer(createBlakeHash("blake512").update(Buffer.from(prv)).digest());
-        const s = Scalar.fromRprLE(sBuff, 0, 32);
-        const A = this.babyJub.mulPointEscalar(this.babyJub.Base8, Scalar.shr(s, 3));
-
-
-        const composeBuff = new Uint8Array(32 + msg.length);
-        composeBuff.set(sBuff.slice(32), 0);
-        F.toRprLE(composeBuff, 32, msg);
-        const rBuff = createBlakeHash("blake512").update(Buffer.from(composeBuff)).digest();
-        let r = Scalar.mod(Scalar.fromRprLE(rBuff, 0, 64), this.babyJub.subOrder);
-        const R8 = this.babyJub.mulPointEscalar(this.babyJub.Base8, r);
-
-        const hm = this.mimc7.multiHash([R8[0], R8[1], A[0], A[1], msg]);
-        const hms = Scalar.e(this.babyJub.F.toObject(hm));
-        const S = Scalar.mod(
-            Scalar.add(
-                r,
-                Scalar.mul(hms, s)
-            ),
-            this.babyJub.subOrder
-        )
-        return {
-            R8: R8,
-            S: S
-        };
-    }
-
-    signMiMCSponge(prv, msg) {
-        const F = this.babyJub.F;
-        const sBuff = this.pruneBuffer(createBlakeHash("blake512").update(Buffer.from(prv)).digest());
-        const s = Scalar.fromRprLE(sBuff, 0, 32);
-        const A = this.babyJub.mulPointEscalar(this.babyJub.Base8, Scalar.shr(s, 3));
-
-        const composeBuff = new Uint8Array(32 + msg.length);
-        composeBuff.set(sBuff.slice(32), 0);
-        F.toRprLE(composeBuff, 32, msg);
-        const rBuff = createBlakeHash("blake512").update(Buffer.from(composeBuff)).digest();
-        let r = Scalar.mod(Scalar.fromRprLE(rBuff, 0, 64), this.babyJub.subOrder);
-        const R8 = this.babyJub.mulPointEscalar(this.babyJub.Base8, r);
-
-        const hm = this.mimcSponge.multiHash([R8[0], R8[1], A[0], A[1], msg]);
-        const hms = Scalar.e(this.babyJub.F.toObject(hm));
-        const S = Scalar.mod(
-            Scalar.add(
-                r,
-                Scalar.mul(hms, s)
-            ),
-            this.babyJub.subOrder
-        )
-        return {
-            R8: R8,
-            S: S
-        };
-    }
-
-    signPoseidon(prv, msg) {
-        const F = this.babyJub.F;
-        const sBuff = this.pruneBuffer(createBlakeHash("blake512").update(Buffer.from(prv)).digest());
-        const s = Scalar.fromRprLE(sBuff, 0, 32);
-        const A = this.babyJub.mulPointEscalar(this.babyJub.Base8, Scalar.shr(s, 3));
-
-        const composeBuff = new Uint8Array(32 + msg.length);
-        composeBuff.set(sBuff.slice(32), 0);
-        F.toRprLE(composeBuff, 32, msg);
-        const rBuff = createBlakeHash("blake512").update(Buffer.from(composeBuff)).digest();
-        let r = Scalar.mod(Scalar.fromRprLE(rBuff, 0, 64), this.babyJub.subOrder);
-        const R8 = this.babyJub.mulPointEscalar(this.babyJub.Base8, r);
-
-        const hm = this.poseidon([R8[0], R8[1], A[0], A[1], msg]);
-        const hms = Scalar.e(this.babyJub.F.toObject(hm));
-        const S = Scalar.mod(
-            Scalar.add(
-                r,
-                Scalar.mul(hms, s)
-            ),
-            this.babyJub.subOrder
-        )
-        return {
-            R8: R8,
-            S: S
-        };
-    }
-
-    verifyPedersen(msg, sig, A) {
-        // Check parameters
-        if (typeof sig != "object") return false;
-        if (!Array.isArray(sig.R8)) return false;
-        if (sig.R8.length!= 2) return false;
-        if (!this.babyJub.inCurve(sig.R8)) return false;
-        if (!Array.isArray(A)) return false;
-        if (A.length!= 2) return false;
-        if (!this.babyJub.inCurve(A)) return false;
-        if (Scalar.geq(sig.S, this.babyJub.subOrder)) return false;
-
-        const R8p = this.babyJub.packPoint(sig.R8);
-        const Ap = this.babyJub.packPoint(A);
-
-
-        const composeBuff2 = new Uint8Array(64 + msg.length);
-        composeBuff2.set(R8p, 0);
-        composeBuff2.set(Ap, 32);
-        composeBuff2.set(msg, 64);
-
-
-        const hmBuff = this.pedersenHash.hash(composeBuff2);
-        const hm = Scalar.fromRprLE(hmBuff, 0, 32);
-
-        const Pleft = this.babyJub.mulPointEscalar(this.babyJub.Base8, sig.S);
-        let Pright = this.babyJub.mulPointEscalar(A, Scalar.mul(hm,8));
-        Pright = this.babyJub.addPoint(sig.R8, Pright);
-
-        if (!this.babyJub.F.eq(Pleft[0],Pright[0])) return false;
-        if (!this.babyJub.F.eq(Pleft[1],Pright[1])) return false;
-        return true;
-    }
-
-    verifyMiMC(msg, sig, A) {
-        // Check parameters
-        if (typeof sig != "object") return false;
-        if (!Array.isArray(sig.R8)) return false;
-        if (sig.R8.length!= 2) return false;
-        if (!this.babyJub.inCurve(sig.R8)) return false;
-        if (!Array.isArray(A)) return false;
-        if (A.length!= 2) return false;
-        if (!this.babyJub.inCurve(A)) return false;
-        if (sig.S>= this.babyJub.subOrder) return false;
-
-        const hm = this.mimc7.multiHash([sig.R8[0], sig.R8[1], A[0], A[1], msg]);
-        const hms = Scalar.e(this.babyJub.F.toObject(hm));
-
-        const Pleft = this.babyJub.mulPointEscalar(this.babyJub.Base8, sig.S);
-        let Pright = this.babyJub.mulPointEscalar(A, Scalar.mul(hms, 8));
-        Pright = this.babyJub.addPoint(sig.R8, Pright);
-
-        if (!this.babyJub.F.eq(Pleft[0],Pright[0])) return false;
-        if (!this.babyJub.F.eq(Pleft[1],Pright[1])) return false;
-        return true;
-    }
-
-    verifyPoseidon(msg, sig, A) {
-
-        // Check parameters
-        if (typeof sig != "object") return false;
-        if (!Array.isArray(sig.R8)) return false;
-        if (sig.R8.length!= 2) return false;
-        if (!this.babyJub.inCurve(sig.R8)) return false;
-        if (!Array.isArray(A)) return false;
-        if (A.length!= 2) return false;
-        if (!this.babyJub.inCurve(A)) return false;
-        if (sig.S>= this.babyJub.subOrder) return false;
-
-        const hm = this.poseidon([sig.R8[0], sig.R8[1], A[0], A[1], msg]);
-        const hms = Scalar.e(this.babyJub.F.toObject(hm));
-
-        const Pleft = this.babyJub.mulPointEscalar(this.babyJub.Base8, sig.S);
-        let Pright = this.babyJub.mulPointEscalar(A, Scalar.mul(hms, 8));
-        Pright = this.babyJub.addPoint(sig.R8, Pright);
-
-        if (!this.babyJub.F.eq(Pleft[0],Pright[0])) return false;
-        if (!this.babyJub.F.eq(Pleft[1],Pright[1])) return false;
-        return true;
-    }
-
-    verifyMiMCSponge(msg, sig, A) {
-
-        // Check parameters
-        if (typeof sig != "object") return false;
-        if (!Array.isArray(sig.R8)) return false;
-        if (sig.R8.length!= 2) return false;
-        if (!this.babyJub.inCurve(sig.R8)) return false;
-        if (!Array.isArray(A)) return false;
-        if (A.length!= 2) return false;
-        if (!this.babyJub.inCurve(A)) return false;
-        if (sig.S>= this.babyJub.subOrder) return false;
-
-        const hm = this.mimcSponge.multiHash([sig.R8[0], sig.R8[1], A[0], A[1], msg]);
-        const hms = Scalar.e(this.babyJub.F.toObject(hm));
-
-        const Pleft = this.babyJub.mulPointEscalar(this.babyJub.Base8, sig.S);
-        let Pright = this.babyJub.mulPointEscalar(A, Scalar.mul(hms, 8));
-        Pright = this.babyJub.addPoint(sig.R8, Pright);
-
-        if (!this.babyJub.F.eq(Pleft[0],Pright[0])) return false;
-        if (!this.babyJub.F.eq(Pleft[1],Pright[1])) return false;
-        return true;
-    }
-
-    packSignature(sig) {
-        const buff = new Uint8Array(64);
-        const R8p = this.babyJub.packPoint(sig.R8);
-        buff.set(R8p, 0)
-        const Sp = Scalar.toRprLE(buff, 32, sig.S, 32);
-        return buff;
-    }
-
-    unpackSignature(sigBuff) {
-        return {
-            R8: this.babyJub.unpackPoint(sigBuff.slice(0,32)),
-            S: Scalar.fromRprLE(sigBuff, 32, 32)
-        };
-    }
-}
-
-

package/src/evmasm.js

@@ -1,209 +0,0 @@
-// Copyright (c) 2018 Jordi Baylina
-// License: LGPL-3.0+
-//
-
-import { ethers } from "ethers";
-import {Scalar} from "ffjavascript";
-
-export default class Contract {
-    constructor() {
-        this.code = [];
-        this.labels = {};
-        this.pendingLabels = {};
-    }
-
-    createTxData() {
-        let C;
-
-        // Check all labels are defined
-        const pendingLabels = Object.keys(this.pendingLabels);
-        if (pendingLabels.length>0) {
-            throw new Error("Lables not defined: "+ pendingLabels.join(", "));
-        }
-
-        let setLoaderLength = 0;
-        let genLoadedLength = -1;
-
-        while  (genLoadedLength!=setLoaderLength) {
-            setLoaderLength = genLoadedLength;
-            C = new Contract();
-            C.codesize();
-            C.push(setLoaderLength);
-            C.push(0);
-            C.codecopy();
-
-            C.push(this.code.length);
-            C.push(0);
-            C.return();
-            genLoadedLength = C.code.length;
-        }
-
-        return ethers.utils.hexlify(C.code.concat(this.code));
-    }
-
-    stop() { this.code.push(0x00); }
-    add()  { this.code.push(0x01); }
-    mul()  { this.code.push(0x02); }
-    sub()  { this.code.push(0x03); }
-    div()  { this.code.push(0x04); }
-    sdiv() { this.code.push(0x05); }
-    mod()  { this.code.push(0x06); }
-    smod()  { this.code.push(0x07); }
-    addmod()  { this.code.push(0x08); }
-    mulmod()  { this.code.push(0x09); }
-    exp()  { this.code.push(0x0a); }
-    signextend()  { this.code.push(0x0b); }
-
-    lt()   { this.code.push(0x10); }
-    gt()   { this.code.push(0x11); }
-    slt()  { this.code.push(0x12); }
-    sgt()  { this.code.push(0x13); }
-    eq()   { this.code.push(0x14); }
-    iszero()  { this.code.push(0x15); }
-    and()  { this.code.push(0x16); }
-    or()  { this.code.push(0x17); }
-    shor()  { this.code.push(0x18); }
-    not()  { this.code.push(0x19); }
-    byte()  { this.code.push(0x1a); }
-
-    keccak() { this.code.push(0x20); }
-    sha3() { this.code.push(0x20); }   // alias
-
-    address()  { this.code.push(0x30); }
-    balance()  { this.code.push(0x31); }
-    origin()  { this.code.push(0x32); }
-    caller()  { this.code.push(0x33); }
-    callvalue()  { this.code.push(0x34); }
-    calldataload()  { this.code.push(0x35); }
-    calldatasize()  { this.code.push(0x36); }
-    calldatacopy()  { this.code.push(0x37); }
-    codesize()  { this.code.push(0x38); }
-    codecopy()  { this.code.push(0x39); }
-    gasprice()  { this.code.push(0x3a); }
-    extcodesize()  { this.code.push(0x3b); }
-    extcodecopy()  { this.code.push(0x3c); }
-    returndatasize()  { this.code.push(0x3d); }
-    returndatacopy()  { this.code.push(0x3e); }
-
-    blockhash()  { this.code.push(0x40); }
-    coinbase()  { this.code.push(0x41); }
-    timestamp()  { this.code.push(0x42); }
-    number()  { this.code.push(0x43); }
-    difficulty()  { this.code.push(0x44); }
-    gaslimit()  { this.code.push(0x45); }
-
-    pop()  { this.code.push(0x50); }
-    mload()  { this.code.push(0x51); }
-    mstore()  { this.code.push(0x52); }
-    mstore8()  { this.code.push(0x53); }
-    sload()  { this.code.push(0x54); }
-    sstore()  { this.code.push(0x55); }
-
-    _pushLabel(label) {
-        if (typeof this.labels[label] != "undefined") {
-            this.push(this.labels[label]);
-        } else {
-            this.pendingLabels[label] = this.pendingLabels[label] || [];
-            this.pendingLabels[label].push(this.code.length);
-            this.push("0x000000");
-        }
-    }
-
-    _fillLabel(label) {
-        if (!this.pendingLabels[label]) return;
-
-        let dst = this.labels[label];
-
-        const dst3 = [dst >> 16, (dst >> 8) & 0xFF, dst & 0xFF];
-
-        this.pendingLabels[label].forEach((p) => {
-            for (let i=0; i<3; i++) {
-                this.code[p+i+1] = dst3[i];
-            }
-        });
-
-        delete this.pendingLabels[label];
-    }
-
-
-    jmp(label)  {
-        if (typeof label !== "undefined") {
-            this._pushLabel(label);
-        }
-        this.code.push(0x56);
-    }
-
-    jmpi(label)  {
-        if (typeof label !== "undefined") {
-            this._pushLabel(label);
-        }
-        this.code.push(0x57);
-    }
-
-    pc()  { this.code.push(0x58); }
-    msize()  { this.code.push(0x59); }
-    gas()  { this.code.push(0x5a); }
-    label(name)  {
-        if (typeof this.labels[name] != "undefined") {
-            throw new Error("Label already defined");
-        }
-        this.labels[name] = this.code.length;
-        this.code.push(0x5b);
-
-        this._fillLabel(name);
-    }
-
-    push(data) {
-        if ((typeof data !== "string") || (data.slice(0,2) != "0x")) {
-            let v = Scalar.e(data);
-            if (Scalar.isNegative(v)) {
-                v = Scalar.add(Scalar.shl(Scalar.e(1), 256), v);
-            }
-            let S = Scalar.toString(v, 16);
-            if (S.length % 2) S = "0"+S;
-            S = "0x" +S;
-            data = S;
-        }
-        const d = ethers.utils.arrayify(data);
-        if (d.length == 0 || d.length > 32) {
-            throw new Error("Assertion failed");
-        }
-        const a = [];
-        this.code.push(0x5F + d.length);
-        for (let i=0; i<d.length; i++) {
-            this.code.push(d[i]);
-        }
-    }
-
-    dup(n) {
-        if (n < 0 || n >= 16) {
-            throw new Error("Assertion failed");
-        }
-        this.code.push(0x80 + n);
-    }
-
-    swap(n) {
-        if (n < 1 || n > 16) {
-            throw new Error("Assertion failed");
-        }
-        this.code.push(0x8f + n);
-    }
-
-    log0()  { this.code.push(0xa0); }
-    log1()  { this.code.push(0xa1); }
-    log2()  { this.code.push(0xa2); }
-    log3()  { this.code.push(0xa3); }
-    log4()  { this.code.push(0xa4); }
-
-    create()  { this.code.push(0xf0); }
-    call()  { this.code.push(0xf1); }
-    callcode()  { this.code.push(0xf2); }
-    return()  { this.code.push(0xf3); }
-    delegatecall()  { this.code.push(0xf4); }
-
-    staticcall()  { this.code.push(0xfa); }
-    revert()  { this.code.push(0xfd); }
-    invalid()  { this.code.push(0xfe); }
-    selfdestruct()  { this.code.push(0xff); }
-}
-

package/src/mimc7.js

@@ -1,78 +0,0 @@
-import {getCurveFromName, Scalar} from "ffjavascript";
-
-import { ethers } from "ethers";
-
-const SEED = "mimc";
-const NROUNDS = 91;
-
-export default async function buildMimc7() {
-    const bn128 = await getCurveFromName("bn128", true);
-    return new Mimc7(bn128.Fr);
-}
-
-
-class Mimc7 {
-    constructor (F) {
-        this.F = F;
-        this.cts = this.getConstants(SEED, 91);
-    }
-
-    getIV(seed) {
-        const F = this.F;
-        if (typeof seed === "undefined") seed = SEED;
-        const c = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(seed+"_iv"));
-        const cn = Scalar.e(c);
-        const iv = Scalar.mod(cn, F.p);
-        return iv;
-    };
-
-    getConstants(seed, nRounds) {
-        const F = this.F;
-        if (typeof seed === "undefined") seed = SEED;
-        if (typeof nRounds === "undefined") nRounds = NROUNDS;
-        const cts = new Array(nRounds);
-        let c = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(SEED));
-        for (let i=1; i<nRounds; i++) {
-            c = ethers.utils.keccak256(c);
-
-            cts[i] = F.e(c);
-        }
-        cts[0] = F.e(0);
-        return cts;
-    }
-
-    hash (_x_in, _k) {
-        const F = this.F;
-        const x_in = F.e(_x_in);
-        const k = F.e(_k);
-        let r;
-        for (let i=0; i<NROUNDS; i++) {
-            const c = this.cts[i];
-            const t = (i==0) ? F.add(x_in, k) : F.add(F.add(r, k), c);
-            const t2 = F.square(t);
-            const t4 = F.square(t2);
-            r = F.mul(F.mul(t4, t2), t);
-        }
-        return F.add(r, k);
-    }
-
-    multiHash(arr, key) {
-        const F = this.F;
-        let r;
-        if (typeof(key) === "undefined") {
-            r = F.zero;
-        } else {
-            r = F.e(key);
-        }
-        for (let i=0; i<arr.length; i++) {
-            r = F.add(
-                F.add(
-                    r,
-                    F.e(arr[i])
-                ),
-                this.hash(F.e(arr[i]), r)
-            );
-        }
-        return r;
-    }
-}