berzanorg / nacho Goto Github PK

Implement Witness Database inside witness-database crate using the reference below.

It is going to be used by the client.

The witness database stores the hashes of each data stored in the state database inside an on disk Merkle tree.
It also makes it possible to represent the entire state as a fixed size Merkle root.
It is optimized for high performance and low disk usage.

Implement a bridge between Mina and Nacho.

Update the smart contract and add the required logic to the client.

To deposit tokens from Mina to Nacho, a user has to send tokens to the smart contract of Nacho and send the proof of that transaction to the client of Nacho. The client keeps track of Mina's state and checks the correctness of the transaction and mints the equivalent amount of tokens on Nacho for the user.

To withdraw tokens from Nacho to Mina, a user has to burn tokens on Nacho and send the proof of that burn to the smart contract. The smart contract allows the user to receive the equivalent amount of tokens on Mina.

Implement a provable data structure called Burn for the bridge.

The Burn data structure should store the witness database index of itself, the token identifier of the token burned and the token amount that is burned.

Implement Uint64 wrapper type around Field type with range check support inside common crate.

Uint64 is going to be used for other data structures' definitions.

Implement an easy to use interface for field elements and Poseidon hash inside common crate.

Field elements and Poseidon hash are going to be used across all the crates of this project.

Implement a disk based queue with garbage collection that allows push and pop operations.

It is going be used in mempool and proofpool.

Implement a prover and a smart contract.

The prover is going to be a ZkProgram that doesn't have a logic yet, but noOperation and mergeProofs methods.

The smart contract is going to be a SmartContract that stores the Merkle root of the entire rollup's state, and has a method called updateState that updates the on-chain Merkle root by verifying proofs.

Implement provable data structures that are needed to build an AMM.

Those data structures should be implemented for both TypeScript and Rust.
Because the prover currently uses o1js which is a TypeScript library, but the client is completely written in Rust.