25 Open Issues Need Help Last updated: Aug 26, 2025

Open Issues Need Help

View All on GitHub
enhancement good first issue onlydust-wave
bug good first issue help wanted onlydust-wave

AI Summary: This task requires implementing internal Poseidon hash computation for deposit requests in the ZeroXBridge Sequencer, eliminating reliance on an external endpoint. This involves creating a nonce table to track deposit requests per user, fetching and incrementing the nonce for each request, constructing a PoseidonHashRequest, computing the hash using the BatchHash method, storing the hash in the database, and updating the database schema accordingly.

Complexity: 4/5
enhancement good first issue onlydust-wave

AI Summary: Extend the ZeroXBridge Sequencer API to allow querying of withdrawal requests. This involves adding two new GET routes: one to retrieve the latest withdrawal request and another to retrieve all withdrawal requests for a given user address or Stark public key. The routes will parse query parameters, query the database, validate input, and return a structured response.

Complexity: 3/5
enhancement good first issue onlydust-wave

AI Summary: This task requires modifying the ZeroXBridge Sequencer to compute the L1 commitment hash internally for withdrawal requests instead of using an external API call. This involves creating a new database table to track withdrawal nonces per user, updating the withdrawal request schema to include the computed hash and nonce, and modifying the request processing logic to fetch, increment, and use the nonce in the hash computation. The internal `compute_hash()` function will need to be used.

Complexity: 3/5
enhancement good first issue onlydust-wave

AI Summary: The task involves extending the Starknet relayer in a Rust project to handle on-chain proof submission. This includes reading proof data from files, sequentially invoking Starknet contract functions for verification, updating database records to reflect the status of each step, implementing robust error handling and retry mechanisms, and adding comprehensive logging and testing.

Complexity: 4/5
enhancement good first issue help wanted onlydust-wave

AI Summary: Implement a Rust service that processes pending deposits, generates STARK proofs using the Stone prover, and updates deposit statuses. The service should handle database interactions, file I/O, error handling, and retries, and be resilient to restarts. Unit and integration tests are required.

Complexity: 4/5
enhancement good first issue help wanted onlydust-wave

AI Summary: Implement a Rust service that uses the `tree-builder` crate to incrementally update a Merkle tree for deposits on Ethereum (L1). The service should periodically query a database for pending deposits, append their commitment hashes to the tree, persist the updated tree state, and update deposit statuses. It needs to handle errors, logging, and memory management, and include comprehensive unit and integration tests.

Complexity: 4/5
enhancement good first issue help wanted onlydust-wave

AI Summary: The task involves modifying a Rust-based Ethereum event listener to subscribe to a new, combined `DepositEvent` instead of two separate events. This includes decoding the event's parameters, upserting data into a database, updating deposit status, and implementing robust error handling and retry mechanisms with logging. Unit tests for event decoding are also required.

Complexity: 4/5
enhancement good first issue help wanted onlydust-wave

AI Summary: The task requires modifying the `main` function in `proof_generator/src/lib.cairo` to route STARK proofs to the correct verifier (L1 or L2) based on the first element of an input array. This involves reading the input array, selecting the appropriate verifier function (`l1::verify_proof` or `l2::verify_proof`), and returning the verification result. Comprehensive unit tests must be added to ensure correctness.

Complexity: 3/5
enhancement good first issue help wanted onlydust-wave

AI Summary: The task requires finding a solution to handle Ethereum's uint256 Keccak hashes within the Starknet proof generation system, which currently only supports felt252. This involves devising a method for consistently serializing or splitting large hashes to ensure compatibility without compromising data integrity. The solution should be implemented and tested, with a test case demonstrating handling of hashes exceeding the felt252 limit.

Complexity: 4/5
bug help wanted Cairo onlydust-wave

AI Summary: Debug and fix the inactive StarknetRelayer module in the ZeroXBridge Sequencer to enable reliable transaction sending and confirmation on the Starknet network. This involves identifying the root cause of the failure and implementing the necessary corrections.

Complexity: 4/5
bug good first issue help wanted onlydust-wave

AI Summary: Implement a Cairo function, `verify_proof`, to verify Merkle Mountain Range (MMR) proofs generated using Keccak256 hashing for L1 commitments within the ZeroXBridge sequencer. This involves integrating the `cairo-lib` MMR verifier, adapting it for Keccak256, and thoroughly testing the function with realistic L1 commitment proof data.

Complexity: 4/5
enhancement good first issue Cairo onlydust-wave

AI Summary: Debug and fix a broken test suite (`tests/l2_event_watcher.rs`) for the ZeroXBridge Sequencer's L2 event logging functionality. This involves identifying the root cause of the test failures and implementing the necessary corrections to ensure all tests pass.

Complexity: 4/5
bug good first issue help wanted onlydust-wave

AI Summary: Debug and fix the broken Herodotus API test suite located in `tests/herodotus_api.rs`. This involves identifying the root cause of the test failures and implementing the necessary corrections to ensure all tests pass.

Complexity: 4/5
bug good first issue help wanted onlydust-wave

AI Summary: Debug and fix broken unit tests in the `tests/l1_events_log.rs` file for the ZeroXBridge Sequencer's L1 event logs. This involves identifying the root cause of the test failures and implementing necessary corrections to ensure the tests pass successfully.

Complexity: 4/5
bug good first issue help wanted onlydust-wave

AI Summary: Debug and fix the non-functional test suite for the ZeroXBridge Sequencer, a Rust-based cross-chain system using Merkle Trees and ZKPs. This involves identifying the root cause of test failures, implementing necessary corrections, and ensuring all tests pass successfully.

Complexity: 4/5
bug good first issue help wanted onlydust-wave

AI Summary: Implement a new event listener in the Rust-based ZeroXBridge Sequencer to track `DepositHashAppended` events emitted by the L1 MerkleManager contract. This involves decoding event data (index, commitmentHash, rootHash, elementsCount), integrating the listener into the existing L1 block processing, and thorough testing to ensure correct data capture and formatting.

Complexity: 3/5
enhancement good first issue onlydust-wave

AI Summary: Implement an L2 Merkle tree builder and proof system within the `tree-builder` crate (or a new module), using the Poseidon hasher for Starknet compatibility. This involves creating functions to build the L2 Merkle tree from withdrawal commitment hashes, generate Merkle proofs, and ensuring compatibility with zk-STARK proof generation. Thorough testing is required to validate the rebuilt root against L2 event state and verify proof correctness.

Complexity: 4/5
enhancement good first issue onlydust-wave

AI Summary: Implement a new Rust crate, `tree-builder`, using the Herodotus library to reconstruct and verify Merkle trees for L1 commitments in the ZeroXBridge sequencer. This involves integrating the Herodotus MMR accumulator with Keccak hashing, creating functions to build the Merkle tree and generate proofs, and writing comprehensive tests to ensure accuracy against on-chain L1 data.

Complexity: 4/5
enhancement good first issue onlydust-wave

AI Summary: Implement a new event listener in `src/l2_event_watcher.rs` to track `WithdrawalHashAppended` events emitted by the ZeroXBridge L2 MerkleManager contract. The listener should parse event data (index, commitment_hash, root_hash, elements_count) and return it. The implementation should follow the existing pattern of other event listeners and include thorough testing.

Complexity: 3/5
enhancement good first issue onlydust-wave

AI Summary: Implement a Cairo function, `verify_proof`, to verify the inclusion of a Poseidon-hashed commitment within a Merkle Mountain Range (MMR) on Starknet (L2). This involves integrating the `mmr` module from the `cairo-lib` library, adapting it for Poseidon hashing, and writing comprehensive tests to ensure correctness.

Complexity: 4/5
enhancement good first issue Cairo onlydust-wave

AI Summary: The task involves creating a Rust function that wraps the existing Stone prover pipeline (cairo1-run, cpu_air_prover, cpu_air_verifier, swiftness) for generating STARK proofs. This function should handle input arguments, temporary file management, error propagation, and return a structured output suitable for on-chain submission. The goal is to streamline proof generation within the ZeroXBridge Sequencer, eliminating the need for manual command-line execution.

Complexity: 4/5
enhancement good first issue help wanted onlydust-wave

AI Summary: Implement a Rust function that computes a Poseidon hash of deposit transaction data (recipient, amount, nonce, timestamp) for use in a cross-chain bridge. The function should be compatible with Starknet's field and produce a hash matching the L2 verification process. It needs to be thoroughly tested and integrated into the existing API.

Complexity: 4/5
enhancement good first issue onlydust-wave