Programmability - prep for merge

.clang-tidy

@@ -1,16 +1,19 @@
 # TODO: Renable bugprone-easily-swappable-parameters
 Checks: '
-clang-analyzer-*,
-bugprone-*,
--bugprone-easily-swappable-parameters,
-modernize-*,
-performance-*,
-portability-*,
-cppcoreguidelines-*,
--cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-readability-*,
-google-explicit-constructor,
--readability-identifier-length'
+    clang-analyzer-*,
+    bugprone-*,
+    -bugprone-easily-swappable-parameters,
+    modernize-*,
+    performance-*,
+    portability-*,
+    cppcoreguidelines-*,
+    -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+    readability-*,
+    google-explicit-constructor,
+    -readability-identifier-length'
+CheckOptions:
+    - {key: cppcoreguidelines-explicit-virtual-functions.AllowOverrideAndFinal, value: true}
+    - {key: modernize-use-override.AllowOverrideAndFinal, value: true}
 WarningsAsErrors: '*'
 FormatStyle: 'file'
 HeaderFilterRegex: 'hpp'

.dockerignore

@@ -15,6 +15,7 @@ scripts/
 !scripts/test.sh
 !scripts/configure.sh
 !scripts/test-transaction.sh
+!scripts/wait-for-it.sh
 
 # Improves caching significantly
 .git

.github/workflows/ci.yml

@@ -45,7 +45,7 @@ jobs:
   unit-and-integration-test:
     name: Unit and Integration Tests
     runs-on: ubuntu-20.04
-    timeout-minutes: 15
+    timeout-minutes: 30
     steps:
       - uses: actions/checkout@v2
         with:

.gitignore

@@ -37,6 +37,10 @@ CMakeCache.txt
 
 leveldb*/
 NuRaft*/
+curl*/
+jsoncpp*/
+ethash*/
+lua*/
 benchmark-results/
 CMakeFiles/
 plots/

.nvmrc

@@ -0,0 +1,2 @@
+v18.16.0
+

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.13)
 include(CheckCXXCompilerFlag)
 
 project(opencbdc-tx)
@@ -7,6 +7,8 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_CXX_EXTENSIONS False)
 
+cmake_policy(SET CMP0076 NEW)
+
 try_compile(USE_STDFS_LIB ${CMAKE_BINARY_DIR} "${CMAKE_SOURCE_DIR}/cmake-tests/test-libstdc++fs.cpp" LINK_LIBRARIES "stdc++fs")
 check_cxx_compiler_flag(-Wshadow-all W_SHADOW_ALL)
 check_cxx_compiler_flag(-Wnewline-eof W_NEWLINE_EOF)
@@ -33,6 +35,16 @@ find_library(NURAFT_LIBRARY nuraft REQUIRED)
 find_library(GTEST_LIBRARY gtest REQUIRED)
 find_library(GTEST_MAIN_LIBRARY gtest_main REQUIRED)
 find_package(benchmark REQUIRED)
+find_library(LUA_LIBRARY lua REQUIRED)
+find_library(KECCAK_LIBRARY keccak REQUIRED)
+find_library(EVMC_HEX_LIBRARY hex REQUIRED)
+find_library(EVMC_INSTRUCTIONS_LIBRARY evmc-instructions REQUIRED)
+find_library(EVMONE_LIBRARY evmone REQUIRED)
+find_library(JSON_LIBRARY libjsoncpp.a jsoncpp REQUIRED)
+find_library(CURL_LIBRARY libcurl.a curl REQUIRED)
+find_library(MHD_LIBRARY libmicrohttpd.a REQUIRED)
+
+set(LUA_LIBRARY "${LUA_LIBRARY}" "-ldl")
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
 

Dockerfile

@@ -75,3 +75,21 @@ COPY --from=builder /opt/tx-processor/build/src/uhs/client/client-cli ./build/sr
 
 # Copy atomizer config
 COPY --from=builder /opt/tx-processor/atomizer-compose.cfg ./atomizer-compose.cfg
+
+# Create PArSEC Deployment Image
+FROM $IMAGE_VERSION AS parsec
+
+# Set working directory
+WORKDIR /opt/tx-processor
+
+# Only copy essential binaries
+COPY --from=builder /opt/tx-processor/build/src/parsec/agent/agentd ./build/src/parsec/agent/agentd
+COPY --from=builder /opt/tx-processor/build/src/parsec/runtime_locking_shard/runtime_locking_shardd ./build/src/parsec/runtime_locking_shard/runtime_locking_shardd
+COPY --from=builder /opt/tx-processor/build/src/parsec/ticket_machine/ticket_machined ./build/src/parsec/ticket_machine/ticket_machined
+
+# Copy load generators
+COPY --from=builder /opt/tx-processor/build/tools/bench/parsec/evm/evm_bench ./build/tools/bench/parsec/evm/evm_bench
+COPY --from=builder /opt/tx-processor/build/tools/bench/parsec/lua/lua_bench ./build/tools/bench/parsec/lua/lua_bench
+
+# Copy wait script
+COPY --from=builder /opt/tx-processor/scripts/wait-for-it.sh ./scripts/wait-for-it.sh

README.md

@@ -18,13 +18,15 @@ The design decisions we made to achieve these goals will help inform policy make
 **NOTE:** In cases where there are significant changes to the repository that might need manual intervention down-stream (or other important updates), we will [make a NEWS post](NEWS.md).
 
 # Architecture
-
-We explored two system architectures for transaction settlement, both based on an [unspent transaction output (UTXO)](https://en.wikipedia.org/wiki/Unspent_transaction_output) data model and transaction format.
+We have explored several architectures under two broad categories as follows:
+## UHS-Based Transaction Processor
+We explored two system architectures for transaction settlement based on an [unspent transaction output (UTXO)](https://en.wikipedia.org/wiki/Unspent_transaction_output) data model and transaction format.
 Both architectures implement the same schema representing an [unspent hash set (UHS)](https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2018-May/015967.html) abstraction.
 One architecture provides [linearizability](https://en.wikipedia.org/wiki/linearizability) of transactions, whereas the other only provides [serializability](https://en.wikipedia.org/wiki/Serializability).
 By relaxing the ordering constraint, the peak transaction throughput supported by the system scales horizontally with the number of nodes, but the transaction history is unavailable making the system harder to audit retroactively.
 Both architectures handle multiple geo-distributed datacenter outages with a [recovery time objective (RTO)](https://en.wikipedia.org/wiki/Disaster_recovery#Recovery_Time_Objective) of under ten seconds and a [recovery point objective (RPO)](https://en.wikipedia.org/wiki/Disaster_recovery#Recovery_Point_Objective) of zero.
 
+There are two UHS-based architectures as follows:
 1. "Atomizer" architecture
     - Materializes a total ordering of all transactions settled by the system in a linear sequence of batches.
     - Requires vertical scaling as peak transaction throughput is limited by the performance of a single system component.
@@ -36,8 +38,22 @@ Both architectures handle multiple geo-distributed datacenter outages with a [re
     - Maximum demonstrated throughput ~1.7M transactions per second.
     - Geo-replicated latency <1 second.
 
-Read the [architecture guide](docs/architecture.md) for a detailed description of the system components and implementation of each architecture.
+Read the [2PC & Atomizer architecture guide](docs/uhs-architectures.md) for a detailed description of the system components and implementation of each architecture.
+
+## Parallel Architecture for Scalably Executing smart Contracts ("PArSEC")
+We built a system with a generic virtual machine layer that is capable of performing parallel executions of smart contracts.
+
+The architecture is composed of two layers:
+1. A distributed key-value data store with [ACID](https://en.wikipedia.org/wiki/ACID) database properties
+    - This back-end data store is not constrained to any type of data and is agnostic to the execution later.
+1. A generic virtual machine layer that executes programs (i.e. smart contracts) and uses the distributed key-value data store to record state
+    - This computation layer defines the data models and transaction semantics.
+    - We have implemented the Ethereum Virtual Machine EVM and a Lua based virtual machine as two working examples.
+
+- This architecture enables parallel execution of smart contracts which can be scaled horizontally where keys are independent.
+- Unmodified smart contracts from the Ethereum ecosystem can be deployed directly onto our EVM implementation.
 
+Read the [PArSEC Architecture Guide](docs/parsec_architecture.md) for more details.
 # Contributing
 
 You can [sign up](https://dci.mit.edu/opencbdc-interest) to receive updates from technical working groups and to learn more about our work.
@@ -73,152 +89,13 @@ Note that if you have not already installed the xcode cli tools you will need to
 ```terminal
 # xcode-select --install
 ```
-
 # Run the Code
 
-The easiest way to compile the code and run the system locally is using [Docker](https://www.docker.com).
-
-## Setup Docker
-
-* [Install Docker](https://docs.docker.com/get-docker/)
-* [Install docker-compose](https://docs.docker.com/compose/install/)
-
-Don't forget to run the docker daemon!
-
-## Build the containers
-
-Building with Docker utilizes multi-stage builds. In order to run an architecture you will need to build each architecture independently if building locally.
-
-**Note:** We have pre-built images available [here](#launch-the-system-with-a-pre-built-image) if you would rather pull the images from GitHub packages over building them locally.
-
-1. Build 2PC architecture:
-    ```terminal
-    $ cd opencbdc-tx                                              # change to the project directory
-    $ sudo -s                                                     # open a root shell (needed for docker)
-    $ docker build --target twophase  -t opencbdc-tx-twophase .   # build the container
-    ```
-1. Build atomizer architecture:
-    ```terminal
-    $ cd opencbdc-tx                                              # change to the project directory
-    $ sudo -s                                                     # open a root shell (needed for docker)
-    $ docker build --target atomizer  -t opencbdc-tx-atomizer .   # build the container
-    ```
-
-## Launch the System
-
-**Note:** You will need to both run the system and interact with it; you can either use two shells, or you can add the `--detach` flag when launching the system (note that it will then remain running till you stop it, e.g., with `docker stop`).
-
-_The commands below will build a new image every time that you run it.
-You can remove the `--build` flag after the image has been built to avoid rebuilding.
-To run the system with our pre-built image proceed to the [next section](#launch-the-system-with-a-pre-built-image) for the commands to run._
-
-1. Run the System
-    1. 2PC architecture:
-        ```terminal
-        $ docker compose --file docker-compose-2pc.yml up --build
-        ```
-    1. Atomizer architecture:
-        ```terminal
-        $ docker compose --file docker-compose-atomizer.yml up --build
-        ```
-1. Launch a container in which to run wallet commands
-    1. 2PC architecture:
-        ```terminal
-        $ docker run --network 2pc-network -ti opencbdc-tx-twophase /bin/bash
-        ```
-    1. Atomizer architecture:
-        ```terminal
-        $ docker run --network atomizer-network -ti opencbdc-tx-atomizer /bin/bash
-        ```
-
-## Launch the System With a Pre-built Image
-
-We publish new docker images for all commits to `trunk`.
-You can find the images [in the Github Container Registry](https://github.com/mit-dci/opencbdc-tx/pkgs/container/opencbdc-tx).
-
-**Note:** You must use `docker compose` (not `docker-compose`) for this approach to work or you will need to pull the image manually `docker pull ghcr.io/mit-dci/opencbdc-tx-twophase` or `docker pull ghcr.io/mit-dci/opencbdc-tx-atomizer`.
-
-1. Run the system
-    1. 2PC architecture:
-        ```terminal
-        $ docker compose --file docker-compose-2pc.yml --file docker-compose-prebuilt-2pc.yml up --no-build
-        ```
-    1. Atomizer architecture:
-        ```terminal
-        $ docker compose --file docker-compose-atomizer.yml --file docker-compose-prebuilt-atomizer.yml up --no-build
-        ```
-1. Launch a container in which to run wallet commands
-    1. 2PC architecture:
-        ```terminal
-        $ docker run --network 2pc-network -ti ghcr.io/mit-dci/opencbdc-tx-twophase /bin/bash
-        ```
-    1. Atomizer architecture:
-        ```terminal
-        $ docker run --network atomizer-network -ti ghcr.io/mit-dci/opencbdc-tx-atomizer /bin/bash
-        ```
-
-## Setup test wallets and test them
-
-The following commands are all performed from within the second container we started in the previous step.
-In each of the below commands, you should pass `atomizer-compose.cfg` instead of `2pc-compose.cfg` if you started the atomizer architecture.
-
-* Mint new coins (e.g., 10 new UTXOs each with a value of 5 atomic units of currency)
-  ```terminal
-  # ./build/src/uhs/client/client-cli 2pc-compose.cfg mempool0.dat wallet0.dat mint 10 5
-  [2021-08-17 15:11:57.686] [WARN ] Existing wallet file not found
-  [2021-08-17 15:11:57.686] [WARN ] Existing mempool not found
-  4bc23da407c3a8110145c5b6c38199c8ec3b0e35ea66bbfd78f0ed65304ce6fa
-  ```
-
-  If using the atomizer architecture, you'll need to sync the wallet after:
-  ```terminal
-  # ./build/src/uhs/client/client-cli atomizer-compose.cfg mempool0.dat wallet0.dat sync
-  ```
-
-* Inspect the balance of a wallet
-  ```terminal
-  # ./build/src/uhs/client/client-cli 2pc-compose.cfg mempool0.dat wallet0.dat info
-  Balance: $0.50, UTXOs: 10, pending TXs: 0
-  ```
-
-* Make a new wallet
-  ```terminal
-  # ./build/src/uhs/client/client-cli 2pc-compose.cfg mempool1.dat wallet1.dat newaddress
-  [2021-08-17 15:13:16.148] [WARN ] Existing wallet file not found
-  [2021-08-17 15:13:16.148] [WARN ] Existing mempool not found
-  usd1qrw038lx5n4wxx3yvuwdndpr7gnm347d6pn37uywgudzq90w7fsuk52kd5u
-  ```
-
-* Send currency from the first wallet to the second wallet created in the previous step (e.g., 30 atomic units of currency)
-  ```terminal
-  # ./build/src/uhs/client/client-cli 2pc-compose.cfg mempool0.dat wallet0.dat send 30 usd1qrw038lx5n4wxx3yvuwdndpr7gnm347d6pn37uywgudzq90w7fsuk52kd5u
-  tx_id:
-  cc1f7dc708be5b07e23e125cf0674002ff8546a9342928114bc97031d8b96e75
-  Data for recipient importinput:
-  cc1f7dc708be5b07e23e125cf0674002ff8546a9342928114bc97031d8b96e750000000000000000d0e4f689b550f623e9370edae235de50417860be0f2f8e924eca9f402fcefeaa1e00000000000000
-  Sentinel responded: Confirmed
-  ```
-
-  If using the atomizer architecture, you'll need to sync the sending wallet after:
-  ```terminal
-  # ./build/src/uhs/client/client-cli atomizer-compose.cfg mempool0.dat wallet0.dat sync
-  ```
-
-* Check that the currency is no longer available in the sending wallet
-  ```terminal
-  # ./build/src/uhs/client/client-cli 2pc-compose.cfg mempool0.dat wallet0.dat info
-  Balance: $0.20, UTXOs: 4, pending TXs: 0
-  ```
-
-* Import coins to the receiving wallet using the string after `importinput` from the currency transfer step above
-  ```terminal
-  # ./build/src/uhs/client/client-cli 2pc-compose.cfg mempool1.dat wallet1.dat importinput cc1f7dc708be5b07e23e125cf0674002ff8546a9342928114bc97031d8b96e750000000000000000d0e4f689b550f623e9370edae235de50417860be0f2f8e924eca9f402fcefeaa1e00000000000000
-  # ./build/src/uhs/client/client-cli 2pc-compose.cfg mempool1.dat wallet1.dat sync
-  # ./build/src/uhs/client/client-cli 2pc-compose.cfg mempool1.dat wallet1.dat info
-  Balance: $0.30, UTXOs: 1, pending TXs: 0
-  ```
-
-## Testing
+## UHS-based Architectures (2PC & Atomizer)
+See the [2PC & Atomizer User Guide](docs/2pc_atomizer_user_guide.md)
+## PArSEC Architecture
+See the [PArSEC User Guide](docs/parsec_user_guide.md)
+# Testing
 
 Running Unit & Integration Tests
 
@@ -231,15 +108,15 @@ Running Unit & Integration Tests
    $ docker run -ti opencbdc-tx-builder ./scripts/test.sh
    ```
 
-### E2E Testing with Kubernetes
+## E2E Testing with Kubernetes
 
-#### Requirements
+### Requirements
 - Go (go test library used to run tests)
 - Minikube
 - Helm
 - Kubectl
 
-#### Running tests
+### Running tests
 
 1. `./scripts/build-docker.sh`
 1. `./scripts/test-e2e-minikube.sh`

benchmarks/transactions.cpp

@@ -97,10 +97,14 @@ static void Nto1_tx(benchmark::State& state) {
             GTEST_LOG_(ERROR) << state.range(0) << "-2 transaction invalid";
             return;
         }
-        ASSERT_EQ(wallet_a.balance(), SWEEP_MAX * 2 - 2 * state.range(0));
-        ASSERT_EQ(wallet_a.count(), SWEEP_MAX - state.range(0));
-        ASSERT_EQ(wallet_b.balance(), state.range(0) * 2);
-        ASSERT_EQ(wallet_b.count(), 1);
+        ASSERT_EQ(
+            wallet_a.balance(),
+            static_cast<unsigned long>(SWEEP_MAX * 2 - 2 * state.range(0)));
+        ASSERT_EQ(wallet_a.count(),
+                  static_cast<unsigned long>(SWEEP_MAX - state.range(0)));
+        ASSERT_EQ(wallet_b.balance(),
+                  static_cast<unsigned long>(state.range(0) * 2));
+        ASSERT_EQ(wallet_b.count(), 1UL);
     }
     state.SetComplexityN(state.range(0));
 }
@@ -117,10 +121,14 @@ static void Nto2_tx(benchmark::State& state) {
             GTEST_LOG_(ERROR) << state.range(0) << "-2 transaction invalid";
             return;
         }
-        ASSERT_EQ(wallet_a.balance(), SWEEP_MAX * 2 - 2 * state.range(0) + 1);
-        ASSERT_EQ(wallet_a.count(), SWEEP_MAX - state.range(0) + 1);
-        ASSERT_EQ(wallet_b.balance(), state.range(0) * 2 - 1);
-        ASSERT_EQ(wallet_b.count(), 1);
+        ASSERT_EQ(wallet_a.balance(),
+                  static_cast<unsigned long>(SWEEP_MAX * 2 - 2 * state.range(0)
+                                             + 1));
+        ASSERT_EQ(wallet_a.count(),
+                  static_cast<unsigned long>(SWEEP_MAX - state.range(0) + 1));
+        ASSERT_EQ(wallet_b.balance(),
+                  static_cast<unsigned long>(state.range(0) * 2 - 1));
+        ASSERT_EQ(wallet_b.count(), 1UL);
     }
     state.SetComplexityN(state.range(0));
 }

contracts/MITCoin.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MITCoin is ERC20 {
+    constructor() ERC20("MITCoin", "MIT") {}
+
+    function mint(address to, uint256 amount) public {
+        _mint(to, amount);
+    }
+
+    function requestTokens(address to) public {
+        mint(to, 1 * 10**18);
+    }
+}