keccak256-circom/test/keccak256.js

const chai = require("chai");
const path = require("path");
const crypto = require("crypto");
const F1Field = require("ffjavascript").F1Field;
const Scalar = require("ffjavascript").Scalar;
exports.p = Scalar.fromString("21888242871839275222246405745257275088548364400416034343698204186575808495617");
const Fr = new F1Field(exports.p);

const assert = chai.assert;

const keccak256 = require("keccak256");

const wasm_tester = require("circom_tester").wasm;

// const printSignal = require("./helpers/printsignal");

function bytesToU64(byteArray) {
    var value = 0;
    for ( var i = byteArray.length - 1; i >= 0; i--) {
        value = (value * 256) + byteArray[i];
    }

    return value;
}
function u64ToBytes(long) {
    var byteArray = [0, 0, 0, 0, 0, 0, 0, 0];

    for ( var index = 0; index < byteArray.length; index ++ ) {
        var byte = long & 0xff;
        byteArray [ index ] = byte;
        long = (long - byte) / 256 ;
    }

    return byteArray;
}

function u64ToBits(a) {
    const aBytes = u64ToBytes(a);
    return bytesToBits(aBytes);
}
function bytesToBits(b) {
	const bits = [];
	for (let i = 0; i < b.length; i++) {
		for (let j = 0; j < 8; j++) {
			if ((b[i]&(1<<j)) > 0) {
                            bits.push(Fr.e(1));
                        } else {
                            bits.push(Fr.e(0));
                        }
		}
	}
	return bits
}
function u64ArrayToBits(u) {
	let r = [];
	for (let i = 0; i < u.length; i++) {
            r = r.concat(u64ToBits(u[i]));
	}
	return r
}
function bitsToU64(b) {
	if (b.length != 64) {
	    console.log("b.length = ", b.length, " max=64");
	    return;
	}
	const by = bitsToBytes(b)
	return bytesToU64(by)
}
function bitsToBytes(a) {
    const len = Math.floor((a.length -1 )/8)+1;
    const b = [];

    for (let i=0; i<a.length; i++) {
	const p = Math.floor(i/8);
	if (a[i]==1) {
	    b[p] |= 1<<(i%8);
	}
    }
    return b;
}

function bitsToU64Array(b) {
	const r = [];
	for (let i = 0; i < b.length/64; i++) {
            r.push(bitsToU64(b.slice(i*64, i*64+64)));
	}
	return r
}

function intsToBigInts(a) {
    let b = [];
    for (let i=0; i<a.length; i++) {
        b[i] = Fr.e(a[i]);
    }
    return b;
}

describe("Utils test", function () {
    this.timeout(100000);

    it ("utils", async () => {
        let a = 3;
        let aBits = u64ToBits(a);
	let a2 = bitsToU64(aBits);
	assert.equal(a2, a);
        a = 12345;
        aBits = u64ToBits(a);
	a2 = bitsToU64(aBits);
	assert.equal(a2, a);

	a = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24];
	aBits = u64ArrayToBits(a);
	a2 = bitsToU64Array(aBits);
	// console.log(a2, a);
	assert.deepEqual(a2, a);
    });
});


describe("Theta test", function () {
    this.timeout(100000);

    it ("Theta (testvector generated from go)", async () => {
	const cir = await wasm_tester(path.join(__dirname, "circuits", "theta_test.circom"));
    
	const input = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24];
	const expectedOut = [26,9,13,29,47,31,14,8,22,34,16,3,3,19,37,21,24,30,12,56,14,29,25,9,51];
	const stateIn = u64ArrayToBits(input);
	const expectedOutBits = u64ArrayToBits(expectedOut);
    
	const witness = await cir.calculateWitness({ "in": stateIn }, true);
    
	const stateOut = witness.slice(1, 1+(25*64));
	const stateOutU64 = bitsToU64Array(stateOut);
	// console.log(stateOutU64, expectedOut);
	assert.deepEqual(stateOutU64, expectedOut);
    });
});