109 lines
3.2 KiB
JavaScript
109 lines
3.2 KiB
JavaScript
/* global ethers */
|
|
const { expect } = require('chai')
|
|
const { toFixedHex, poseidonHash2, randomBN } = require('../src/utils')
|
|
const MerkleTree = require('fixed-merkle-tree')
|
|
const controller = require('../src/controller')
|
|
|
|
async function register(note, tornadoTrees, from) {
|
|
await tornadoTrees
|
|
.connect(from)
|
|
.register(
|
|
note.instance,
|
|
toFixedHex(note.commitment),
|
|
toFixedHex(note.nullifierHash),
|
|
note.depositBlock,
|
|
note.withdrawalBlock,
|
|
)
|
|
}
|
|
|
|
const toEns = (addr) => toFixedHex(addr, 20).padEnd(66, '0')
|
|
|
|
const levels = 20
|
|
const CHUNK_TREE_HEIGHT = 2
|
|
|
|
const instances = [
|
|
'0x1111000000000000000000000000000000001111',
|
|
'0x2222000000000000000000000000000000002222',
|
|
'0x3333000000000000000000000000000000003333',
|
|
'0x4444000000000000000000000000000000004444',
|
|
]
|
|
|
|
const blocks = ['0xaaaaaaaa', '0xbbbbbbbb', '0xcccccccc', '0xdddddddd']
|
|
|
|
describe('TornadoTrees', function () {
|
|
let tree
|
|
let operator
|
|
let tornadoProxy
|
|
let verifier
|
|
let tornadoTrees
|
|
let notes
|
|
let events
|
|
|
|
beforeEach(async function () {
|
|
tree = new MerkleTree(levels, [], { hashFunction: poseidonHash2 })
|
|
;[operator, tornadoProxy] = await ethers.getSigners()
|
|
|
|
const BatchTreeUpdateVerifier = await ethers.getContractFactory('BatchTreeUpdateVerifier')
|
|
verifier = await BatchTreeUpdateVerifier.deploy()
|
|
|
|
const TornadoTrees = await ethers.getContractFactory('TornadoTreesMock')
|
|
tornadoTrees = await TornadoTrees.deploy(
|
|
toEns(operator.address),
|
|
toEns(tornadoProxy.address),
|
|
toEns(verifier.address),
|
|
toFixedHex(tree.root()),
|
|
toFixedHex(tree.root()),
|
|
)
|
|
|
|
notes = []
|
|
for (let i = 0; i < 2 ** CHUNK_TREE_HEIGHT; i++) {
|
|
notes[i] = {
|
|
instance: instances[i % instances.length],
|
|
depositBlock: blocks[i % blocks.length],
|
|
withdrawalBlock: 2 + i + i * 4 * 60 * 24,
|
|
commitment: randomBN(),
|
|
nullifierHash: randomBN(),
|
|
}
|
|
await register(notes[i], tornadoTrees, tornadoProxy)
|
|
}
|
|
|
|
events = notes.map((note) => ({
|
|
hash: toFixedHex(note.commitment),
|
|
instance: toFixedHex(note.instance, 20),
|
|
block: toFixedHex(note.depositBlock, 4),
|
|
}))
|
|
})
|
|
|
|
it('Should calculate hash', async function () {
|
|
const data = await controller.batchTreeUpdate(tree, events)
|
|
const solHash = await tornadoTrees.updateDepositTreeMock(
|
|
toFixedHex(data.oldRoot),
|
|
toFixedHex(data.newRoot),
|
|
toFixedHex(data.pathIndices, 4),
|
|
events,
|
|
)
|
|
expect(solHash).to.be.equal(data.argsHash)
|
|
})
|
|
|
|
it('Should calculate hash', async function () {
|
|
const data = await controller.batchTreeUpdate(tree, events)
|
|
const proof = await controller.prove(data, './artifacts/circuits/BatchTreeUpdate')
|
|
await tornadoTrees.updateDepositTree(
|
|
proof,
|
|
toFixedHex(data.argsHash),
|
|
toFixedHex(data.oldRoot),
|
|
toFixedHex(data.newRoot),
|
|
toFixedHex(data.pathIndices, 4),
|
|
events,
|
|
)
|
|
expect(await tornadoTrees.depositRoot()).to.be.equal(tree.root())
|
|
})
|
|
|
|
it('should work for non-empty tree')
|
|
it('should reject for partially filled tree')
|
|
it('should reject for outdated deposit root')
|
|
it('should reject for incorrect insert index')
|
|
it('should reject for overflows of newRoot')
|
|
it('should reject for invalid sha256 args')
|
|
})
|