Feat/simple

Cargo.toml

@@ -20,10 +20,6 @@ path = "bin/main.rs"
 
 # Dependencies for the release build
 [dependencies]
-
-# Local dependencies
-arbiter-core = { path = "arbiter-core" }
-
 # Command line and config
 clap = { version = "4.3.0", features = ["derive"] }
 serde = { version = "1.0.163", features =["derive"] }

README.md

@@ -8,6 +8,9 @@
 [![](https://dcbadge.vercel.app/api/server/primitive?style=flat)](https://discord.gg/primitive)
 [![Twitter Badge](https://badgen.net/badge/icon/twitter?icon=twitter&label)](https://twitter.com/primitivefi)
 
+
+This library enables user to communicate with a sandboxed revm instance via the implementation of the [ethers-rs](ethers.rs) middleware.
+
 The Ethereum blockchain's execution environment, the Ethereum Virtual machine (EVM), contains a rich collection of decentralized applications. The EVM is stack machine that sequentially executes opcodes sent to it by users and smart contracts. Arbiter is a highly configurable rust interface over [revm](https://github.com/bluealloy/revm) which is a Rust implementation of the EVM stack machine logic. The purpose of Arbiter is to interface with arbitrary agents and contracts and run this all directly on a blazing-fast simulated EVM.
 
 Financial engineers need to study a wide array of complex portfolio management strategies against thousands of market conditions, contract parameters, and agents. To configure such a rich simulation environment on a test network could be possible, but a more efficient choice for getting the most robust, yet quick, simulations would bypass any local networking and use a low level language's implementation of the EVM.
@@ -20,32 +23,6 @@ Arbiter can be used for:
 - investigating risk, capital efficiency, rebalancing strategies, and portfolio replication (or performance). (LPs, funds, quants, traders)
 - Engineering and testing new financial products built on top of more primitive financial products (DeFi firms and academics)
 
-## Features:
-
-For our next beta release, we will be focusing on the following features:
-
-
-## Build From Source
-
-First, clone the repository to your local environment so
-
-```bash
-git clone https://github.com/primitivefinance/arbiter.git
-cd arbiter
-```
-
-Install arbiter on your system:
-
-```bash
-cargo install --path . --force
-```
-
-With the `arbiter` binary generated, you can run commands such as:
-
-```bash
-arbiter simulate uniswap
-```
-
 ## Generating Docs
 
 To see the documentation for Arbiter, after cloning the repo, you can run:
@@ -56,17 +33,6 @@ cargo doc --workspace --no-deps --open
 
 This will generate and open the docs in your browser. From there, you can look at the documentation for each crate in the Arbiter workspace.
 
-## Including More Contracts
-
-In the `contracts/` directory you can add additional smart contracts or regenerate Rust bindings. Once that is done, you will want to make sure the bindings are generated in the script:
-
-```bash
-./bind.sh
-```
-You will need to add the relevant directory for your new contracts to the script above and make sure they are also handled by `forge install`. We look forward to improving upon this UX in the future.
-
-At the moment, this only builds the bindings for the contracts in the `lib/arbmod/contracts/` and `lib/portfolio/contracts`. You can of course add an additional directory of contracts in `lib/`. Just be sure to include it when you generate bindings!
-
 ## Contributing
 
 See our [Contributing Guidelines](https://github.com/primitivefinance/arbiter/blob/main/.github/CONTRIBUTING.md)

arbiter-core/src/environment.rs

@@ -21,11 +21,7 @@ use revm::{
 };
 use thiserror::Error;
 
-use crate::{
-    agent::{Agent, IsAttached, NotAttached},
-    math::*,
-    middleware::RevmMiddleware,
-};
+use crate::{math::*, middleware::RevmMiddleware};
 
 pub(crate) type ToTransact = bool;
 pub(crate) type ResultSender = Sender<RevmResult>;
@@ -39,7 +35,6 @@ pub struct Environment {
     pub(crate) state: Arc<AtomicState>,
     pub(crate) evm: EVM<CacheDB<EmptyDB>>,
     pub(crate) socket: Socket,
-    pub agents: Vec<Agent<IsAttached<RevmMiddleware>>>,
     pub seeded_poisson: SeededPoisson,
     pub(crate) handle: Option<JoinHandle<Result<(), EnvironmentError>>>,
     pub(crate) pausevar: Arc<(Mutex<()>, Condvar)>,
@@ -82,17 +77,12 @@ impl Environment {
             state: Arc::new(AtomicState::new(State::Initialization)),
             evm,
             socket,
-            agents: vec![],
             seeded_poisson,
             handle: None,
             pausevar: Arc::new((Mutex::new(()), Condvar::new())),
         }
     }
 
-    pub fn add_agent(&mut self, agent: Agent<NotAttached>) {
-        agent.attach_to_environment(self);
-    }
-
     pub(crate) fn run(&mut self) {
         let mut evm = self.evm.clone();
         let tx_receiver = self.socket.tx_receiver.clone();

arbiter-core/src/lib.rs

@@ -1,6 +1,5 @@
 #![warn(missing_docs, unsafe_code)]
 
-pub mod agent;
 pub mod bindings; // TODO: Add better documentation here and some kind of overwrite protection.
 pub mod environment;
 pub mod manager;

arbiter-core/src/manager.rs

@@ -7,10 +7,7 @@ use std::collections::HashMap;
 use log::{info, warn};
 use thiserror::Error;
 
-use crate::{
-    agent::{Agent, NotAttached},
-    environment::{Environment, State},
-};
+use crate::environment::{Environment, State};
 
 #[derive(Default)]
 pub struct Manager {
@@ -174,22 +171,6 @@ impl Manager {
             }),
         }
     }
-
-    pub fn add_agent(
-        &mut self,
-        agent: Agent<NotAttached>,
-        environment_label: String,
-    ) -> Result<(), ManagerError> {
-        match self.environments.get_mut(&environment_label) {
-            Some(environment) => {
-                environment.add_agent(agent);
-                Ok(())
-            }
-            None => Err(ManagerError::EnvironmentDoesNotExist {
-                label: environment_label,
-            }),
-        }
-    }
 }
 
 #[cfg(test)]

arbiter-core/src/middleware.rs

@@ -10,6 +10,7 @@ use std::{
 };
 
 use ethers::{
+    core::rand::{thread_rng, SeedableRng},
     prelude::{
         k256::{
             ecdsa::SigningKey,
@@ -28,15 +29,12 @@ use ethers::{
         Log,
     },
 };
-use rand::{rngs::StdRng, SeedableRng};
+use rand::rngs;
 use revm::primitives::{CreateScheme, ExecutionResult, Output, TransactTo, TxEnv, B160, U256};
 use serde::{de::DeserializeOwned, Serialize};
 use thiserror::Error;
 
-use crate::{
-    agent::{Agent, NotAttached},
-    environment::{Environment, EventBroadcaster, ResultReceiver, ResultSender, TxSender},
-};
+use crate::environment::{Environment, EventBroadcaster, ResultReceiver, ResultSender, TxSender};
 
 #[derive(Debug)]
 pub struct RevmMiddleware {
@@ -84,7 +82,7 @@ impl MiddlewareError for RevmMiddlewareError {
 }
 
 impl RevmMiddleware {
-    pub fn new(agent: &Agent<NotAttached>, environment: &Environment) -> Self {
+    pub fn new(environment: &Environment, seed_and_label: Option<String>) -> Self {
         let tx_sender = environment.socket.tx_sender.clone();
         let (result_sender, result_receiver) = crossbeam_channel::unbounded();
         let connection = Connection {
@@ -95,12 +93,18 @@ impl RevmMiddleware {
             filter_receivers: Arc::new(tokio::sync::Mutex::new(HashMap::new())),
         };
         let provider = Provider::new(connection);
-        let mut hasher = Sha256::new();
-        hasher.update(agent.name.as_bytes());
-        let seed = hasher.finalize();
-        let mut rng = StdRng::from_seed(seed.into());
-        let wallet = Wallet::new(&mut rng);
-        Self { provider, wallet }
+        if let Some(seed) = seed_and_label {
+            let mut hasher = Sha256::new();
+            hasher.update(seed.clone());
+            let hashed = hasher.finalize();
+            let mut rng: rngs::StdRng = SeedableRng::from_seed(hashed.into());
+            let wallet = Wallet::new(&mut rng);
+            Self { provider, wallet }
+        } else {
+            let mut rng = thread_rng();
+            let wallet = Wallet::new(&mut rng);
+            Self { provider, wallet }
+        }
     }
 }