# mempool

**Repository Path**: ink_cloud/mempool

## Basic Information

- **Project Name**: mempool
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: exp1
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-01-02
- **Last Updated**: 2025-12-13

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Stratus: Scaling Blockchain Consensus via Shared Mempool

Stratus is a shared Mempool protocol that effectively addresses the communication bottleneck of leader-based Byzantine fault-tolerant (BFT) consensus protocols. For technical details, please find the [paper](https://arxiv.org/abs/2203.05158), which has been accepted to [ICDE'23](https://icde2023.ics.uci.edu/).

We implemented Stratus and integrated it with state-of-the-art BFT protocols, [HotStuff](https://dl.acm.org/doi/10.1145/3293611.3331591) and [Streamlet](https://dl.acm.org/doi/10.1145/3419614.3423256), based on [Bamboo](https://github.com/gitferry/bamboo), which is an open source project for prototyping, evaluating, and benchmarking BFT consensus and replication protocols.
The native implementations of HotStuff and Streamlet can also be found in [Bamboo](https://github.com/gitferry/bamboo).

*WARNING*: This is an academic proof-of-concept prototype, and in particular has not received careful code review. This implementation is NOT ready for production use.

## What is included

Protocols:

- [x] HotStuff with a simple shared Mempool (SMP-HS)
- [x] Stratus enabled HotStuff (S-HS)
- [x] Stratus enabled Streamlet (S-SL)
- [x] HotStuff with a gossip-based shared Mempoo  (S-HS-G)

Features:

- [x] Benchmarking

## How to build

1. Install [Go](https://golang.org/dl/).

2. Download Bamboo-Stratus source code.

3. Build `server` and `client`.

```bash
cd bamboo/bin
go build ../server
go build ../client
```

## How to run

Users can run the protocols in simulation (single process) or deployment.

### Simulation

In simulation mode, replicas are running in separate Goroutines and messages are passing via Go channel.

1. ```bash
   cd bamboo/bin
   ```

2. Modify `ips.txt` with a set of IPs of each node. The number of IPs equals to the number of nodes. Here, the local IP is `127.0.0.1`. Each node will be assigned by an increasing port from `8070`.
3. Modify configuration parameters in `config.json`.
4. Modify `simulation.sh` to specify the name of the protocol you are going to run.
5. Run `server` and then run `client` using scripts. Note that the number followed by the `runClient.sh` is the number of clients that you wish to run.

```bash
./simulation.sh
```

```bash
./runClient.sh 10
```

6. Close the simulation by stopping the client and the server in order.

```bash
./closeClient.sh
./stop.sh
```

Logs are produced in the local directory with the name of `client/server.xxx.log` where `xxx` is the pid of the process.

### Deploy

Nodes can be deployed in a real network.

1. ```bash
    cd bamboo/bin/deploy/linux
    ```

2. Authorize remote servers (send local public key to the remote) by adding the IP list into `auth/server_auth.txt` and modifying the user name and password in `auth/server_auth.json`. Then, run the script.

```bash
./auth/server_auth.sh
```

3. Build `server` and `client`.
4. Specify external IPs and internal IPs of server nodes in `pub_ips.txt` and `ips.txt`, respectively.
5. IPs of machines running as clients are specified in `clients.txt`.
6. The type of the protocol is specified in `run.sh`.
7. Modify configuration parameters in `config.json`.
8. Upload binaries and config files onto the remote machines.

```bash
./deploy.sh
./setup_cli.sh
```

9. Start the server nodes.

```bash
./start_server.sh
```

10. Start the clients by specifying no. of clients running on each machine.

```bash
./start_client.sh 10
```

11. Stop the client and server.

```bash
./exp_stop.sh
```

## Monitor

During each run, one can view the statistics (throughput, latency, view number, etc.) at a node via a browser.

```
http://127.0.0.1:8070/query
```

where `127.0.0.1:8070` can be replaced with the actual node address.