tornado-trees/test/tornadoTrees.test.js

/* global ethers */
const { expect } = require('chai')
const { toFixedHex, poseidonHash2, randomBN } = require('../src/utils')
const MerkleTree = require('fixed-merkle-tree')
const controller = require('../src/index')

async function register(note, tornadoTrees, from) {
  await tornadoTrees
    .connect(from)
    .register(
      note.instance,
      toFixedHex(note.commitment),
      toFixedHex(note.nullifierHash),
      note.depositBlock,
      note.withdrawalBlock,
    )
}

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 tornadoTreesV1
  let notes
  let depositDataEventFilter
  const depositEvents = []
  const withdrawalEvents = []

  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 TornadoTreesV1 = await ethers.getContractFactory('TornadoTreesV1Mock')
    tornadoTreesV1 = await TornadoTreesV1.deploy(0, 0, tree.root(), 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], tornadoTreesV1, tornadoProxy)
      depositEvents[i] = {
        hash: toFixedHex(notes[i].commitment),
        instance: toFixedHex(notes[i].instance, 20),
        block: toFixedHex(notes[i].depositBlock, 4),
      }
      withdrawalEvents[i] = {
        hash: toFixedHex(notes[i].nullifierHash),
        instance: toFixedHex(notes[i].instance, 20),
        block: toFixedHex(notes[i].withdrawalBlock, 4),
      }
    }
    const TornadoTrees = await ethers.getContractFactory('TornadoTreesMock')
    tornadoTrees = await TornadoTrees.deploy(
      operator.address,
      tornadoProxy.address,
      tornadoTreesV1.address,
      verifier.address,
      {
        depositsFrom: 1,
        depositsStep: 1,
        withdrawalsFrom: 2,
        withdrawalsStep: 2,
      },
    )
    depositDataEventFilter = tornadoTrees.filters.DepositData()
  })

  describe('#updateDepositTree', () => {
    it('should check hash', async () => {
      const { args } = controller.batchTreeUpdate(tree, depositEvents)
      const solHash = await tornadoTrees.updateDepositTreeMock(...args.slice(1))
      expect(solHash).to.be.equal(args[0])
    })

    it('should prove snark', async () => {
      const { input, args } = controller.batchTreeUpdate(tree, depositEvents)
      const proof = await controller.prove(input, './artifacts/circuits/BatchTreeUpdate')
      await tornadoTrees.updateDepositTree(proof, ...args)

      const updatedRoot = await tornadoTrees.depositRoot()
      expect(updatedRoot).to.be.equal(tree.root())
    })

    it('should work for non-empty tree', async () => {
      let { input, args } = controller.batchTreeUpdate(tree, depositEvents)
      let proof = await controller.prove(input, './artifacts/circuits/BatchTreeUpdate')
      await tornadoTrees.updateDepositTree(proof, ...args)
      let updatedRoot = await tornadoTrees.depositRoot()
      expect(updatedRoot).to.be.equal(tree.root())
      //
      for (let i = 0; i < notes.length; i++) {
        await register(notes[i], tornadoTrees, tornadoProxy)
      }
      ;({ input, args } = controller.batchTreeUpdate(tree, depositEvents))
      proof = await controller.prove(input, './artifacts/circuits/BatchTreeUpdate')
      await tornadoTrees.updateDepositTree(proof, ...args)
      updatedRoot = await tornadoTrees.depositRoot()
      expect(updatedRoot).to.be.equal(tree.root())
    })

    it('should work with events from contracts', async () => {
      let { input, args } = controller.batchTreeUpdate(tree, depositEvents)
      let proof = await controller.prove(input, './artifacts/circuits/BatchTreeUpdate')
      await tornadoTrees.updateDepositTree(proof, ...args)
      let updatedRoot = await tornadoTrees.depositRoot()
      expect(updatedRoot).to.be.equal(tree.root())

      const migratedEvents = await tornadoTrees.queryFilter(depositDataEventFilter)
      migratedEvents.forEach((e, i) => {
        expect(e.args.index).to.be.equal(i)
      })
      //
      for (let i = 0; i < notes.length; i++) {
        await register(notes[i], tornadoTrees, tornadoProxy)
      }
      let registeredEvents = await tornadoTrees.queryFilter(depositDataEventFilter)
      registeredEvents = registeredEvents.map((e) => ({
        hash: toFixedHex(e.args.hash),
        instance: toFixedHex(e.args.instance, 20),
        block: toFixedHex(e.args.block, 4),
      }))
      ;({ input, args } = controller.batchTreeUpdate(tree, registeredEvents.slice(0, notes.length)))
      proof = await controller.prove(input, './artifacts/circuits/BatchTreeUpdate')
      await tornadoTrees.updateDepositTree(proof, ...args)
      updatedRoot = await tornadoTrees.depositRoot()
      expect(updatedRoot).to.be.equal(tree.root())
    })
    it('should work for batch+N filled v1 tree', async () => {
      const batchSize = 2 ** CHUNK_TREE_HEIGHT
      for (let i = batchSize; i < batchSize + 2; i++) {
        notes.push({
          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], tornadoTreesV1, tornadoProxy)
      }

      const TornadoTrees = await ethers.getContractFactory('TornadoTreesMock')
      const newTornadoTrees = await TornadoTrees.deploy(
        operator.address,
        tornadoProxy.address,
        tornadoTreesV1.address,
        verifier.address,
        {
          depositsFrom: 1,
          depositsStep: 1,
          withdrawalsFrom: 2,
          withdrawalsStep: 2,
        },
      )

      // load first batchSize deposits
      let { input, args } = controller.batchTreeUpdate(tree, depositEvents)
      let proof = await controller.prove(input, './artifacts/circuits/BatchTreeUpdate')
      await newTornadoTrees.updateDepositTree(proof, ...args)
      let updatedRoot = await newTornadoTrees.depositRoot()
      expect(updatedRoot).to.be.equal(tree.root())

      // register 2 * `notes.length` new deposits on the new trees
      for (let i = 0; i < notes.length; i++) {
        await register(notes[i], newTornadoTrees, tornadoProxy)
      }
      for (let i = 0; i < notes.length; i++) {
        await register(notes[i], newTornadoTrees, tornadoProxy)
      }

      // get 2 extra events from v1 tress
      let events = notes.slice(batchSize).map((note) => ({
        hash: toFixedHex(note.commitment),
        instance: toFixedHex(note.instance, 20),
        block: toFixedHex(note.depositBlock, 4),
      }))

      let registeredEvents = await newTornadoTrees.queryFilter(depositDataEventFilter)
      registeredEvents = registeredEvents.slice(batchSize) // cut processed deposits from v1
      events = events.concat(
        registeredEvents.slice(0, batchSize - 2).map((e) => ({
          hash: toFixedHex(e.args.hash),
          instance: toFixedHex(e.args.instance, 20),
          block: toFixedHex(e.args.block, 4),
        })),
      )
      //
      ;({ input, args } = controller.batchTreeUpdate(tree, events))
      proof = await controller.prove(input, './artifacts/circuits/BatchTreeUpdate')
      await newTornadoTrees.updateDepositTree(proof, ...args)
      updatedRoot = await newTornadoTrees.depositRoot()
      expect(updatedRoot).to.be.equal(tree.root())

      events = registeredEvents.slice(batchSize - 2, 2 * batchSize - 2).map((e) => ({
        hash: toFixedHex(e.args.hash),
        instance: toFixedHex(e.args.instance, 20),
        block: toFixedHex(e.args.block, 4),
      }))
      ;({ input, args } = controller.batchTreeUpdate(tree, events))
      proof = await controller.prove(input, './artifacts/circuits/BatchTreeUpdate')
      await newTornadoTrees.updateDepositTree(proof, ...args)
      updatedRoot = await newTornadoTrees.depositRoot()
      expect(updatedRoot).to.be.equal(tree.root())
    })
    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')
  })

  describe('#getRegisteredDeposits', () => {
    it('should work', async () => {
      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)
      }

      const abi = new ethers.utils.AbiCoder()
      const count = await tornadoTrees.depositsLength()
      const _deposits = await tornadoTrees.getRegisteredDeposits()
      expect(count).to.be.equal(notes.length * 2)
      _deposits.forEach((hash, i) => {
        if (i < notes.length) {
          expect(hash).to.be.equal('0x0000000000000000000000000000000000000000000000000000000000000000')
        } else {
          const index = i - notes.length
          const encodedData = abi.encode(
            ['address', 'bytes32', 'uint256'],
            [notes[index].instance, toFixedHex(notes[index].commitment), notes[index].depositBlock],
          )
          const leaf = ethers.utils.keccak256(encodedData)

          expect(leaf).to.be.equal(hash)
        }
      })
      // res.length.should.be.equal(1)
      // res[0].should.be.true
      // await tornadoTrees.updateRoots([note1DepositLeaf], [])

      // res = await tornadoTrees.getRegisteredDeposits()
      // res.length.should.be.equal(0)

      // await registerDeposit(note2, tornadoTrees)
      // res = await tornadoTrees.getRegisteredDeposits()
      // // res[0].should.be.true
    })
  })

  describe('#getRegisteredWithdrawals', () => {
    it('should work', async () => {
      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)
      }

      const abi = new ethers.utils.AbiCoder()
      const count = await tornadoTrees.withdrawalsLength()
      const _withdrawals = await tornadoTrees.getRegisteredWithdrawals()
      expect(count).to.be.equal(notes.length * 2)
      _withdrawals.forEach((hash, i) => {
        if (i < notes.length) {
          expect(hash).to.be.equal('0x0000000000000000000000000000000000000000000000000000000000000000')
        } else {
          const index = i - notes.length
          const encodedData = abi.encode(
            ['address', 'bytes32', 'uint256'],
            [notes[index].instance, toFixedHex(notes[index].nullifierHash), notes[index].withdrawalBlock],
          )
          const leaf = ethers.utils.keccak256(encodedData)

          expect(leaf).to.be.equal(hash)
        }
      })
    })
  })
})