Merge pull request astraly-labs#4 from baitcode/docs

Some doumentation fixes

Author: baitcode

.github/CONTRIBUTING.md

@@ -1,4 +1,4 @@
-# Welcome to the Arbiter contributing guide <!-- omit in toc -->
+# Welcome to the Starkbiter contributing guide <!-- omit in toc -->
 
 Thank you for investing your time in contributing to our project! Any contribution you make is greatly appreciated :sparkles:. 
 
@@ -55,7 +55,7 @@ When you're finished with the changes, create a pull request, also known as a PR
 - Make sure your additions are properly documented! You can see the [Rust book](https://doc.rust-lang.org/rustdoc/how-to-write-documentation.html) for documentation guidelines. Each module uses the diagnostic attribute `#![warn(missing_docs)]` which will trigger clippy in our CI.
 - Don't forget to [link PR to issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) if you are solving one.
 - Enable the checkbox to [allow maintainer edits](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/allowing-changes-to-a-pull-request-branch-created-from-a-fork) so the branch can be updated for a merge.
-Once you submit your PR, a Arbiter team member will review your proposal. We may ask questions or request additional information.
+Once you submit your PR, a Starkbiter team member will review your proposal. We may ask questions or request additional information.
 - We may ask for changes to be made before a PR can be merged, either using [suggested changes](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/incorporating-feedback-in-your-pull-request) or pull request comments. You can apply suggested changes directly through the UI. You can make any other changes in your fork, then commit them to your branch.
 - As you update your PR and apply changes, mark each conversation as [resolved](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/commenting-on-a-pull-request#resolving-conversations).
 - If you run into any merge issues, checkout this [git tutorial](https://github.com/skills/resolve-merge-conflicts) to help you resolve merge conflicts and other issues.

README.md

@@ -1,11 +1,11 @@
 ```bash
-#  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
-#  ░░      ░░░        ░░░      ░░░  ░░░░  ░░       ░░░        ░░        ░░        ░░       ░░
-#  ▒  ▒▒▒▒▒▒▒▒▒▒▒  ▒▒▒▒▒  ▒▒▒▒  ▒▒  ▒▒▒  ▒▒▒  ▒▒▒▒  ▒▒▒▒▒  ▒▒▒▒▒▒▒▒  ▒▒▒▒▒  ▒▒▒▒▒▒▒▒  ▒▒▒▒  ▒
-#  ▓▓      ▓▓▓▓▓▓  ▓▓▓▓▓  ▓▓▓▓  ▓▓     ▓▓▓▓▓       ▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓  ▓▓▓▓▓      ▓▓▓▓       ▓▓
-#  ███████  █████  █████        ██  ███  ███  ████  █████  ████████  █████  ████████  ███  ██
-#  ██      ██████  █████  ████  ██  ████  ██       ███        █████  █████        ██  ████  █
-#  ██████████████████████████████████████████████████████████████████████████████████████████
+#  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+#  ░░     ░░░       ░░░     ░░░      ░░░░  ░░░  ░░      ░░░       ░░       ░░      ░░      ░░░
+#  ▒  ▒▒▒▒▒▒▒▒▒  ▒▒▒▒▒  ▒▒▒  ▒▒  ▒▒▒  ▒▒▒  ▒▒  ▒▒▒  ▒▒▒  ▒▒▒▒▒  ▒▒▒▒▒▒  ▒▒▒▒▒  ▒▒▒▒▒▒  ▒▒▒  ▒▒
+#  ▓▓     ▓▓▓▓▓  ▓▓▓▓▓  ▓▓▓  ▓▓     ▓▓▓▓▓    ▓▓▓▓▓      ▓▓▓▓▓▓  ▓▓▓▓▓▓  ▓▓▓▓▓    ▓▓▓▓      ▓▓▓
+#  ██████  ████  █████       ██  ███  ███  ██  ███  ███  █████  ██████  █████  ██████  ███  ██
+#  ██     █████  █████  ███  ██  ████  ██  ███  ██      ███       ████  █████      ██  ████  █
+#  ███████████████████████████████████████████████████████████████████████████████████████████
 ```
 > Expanding the Starknet tooling ecosystem.
 
@@ -15,17 +15,17 @@
 ## Overview
 > **Starkbiter** is a framework for orchestrating event based agentic simulations on top of Starknet Devnet sandbox.
 
-Arbiter provides a Full JSON-RPC Starknet Node capabilities with additional methods to control block production, contract and account deployments and declaration. It integrates deeply with starknet-devnet and starknet-rs types crates allowing for seamless integration for all the tooling that depends on those. Thus, it also provides additional layer of well known contract bindings generated by [cainome](https://github.com/cartridge-gg/cainome).
+Starkbiter provides a Full JSON-RPC Starknet Node capabilities with additional methods to control block production, contract and account deployments and declaration. It integrates deeply with starknet-devnet and starknet-rs types crates allowing for seamless integration for all the tooling that depends on those. Thus, it also provides additional layer of well known contract bindings generated by [cainome](https://github.com/cartridge-gg/cainome).
 
 The primary use of Starkbiter is to probe the mechanism security of smart contracts, and perform advanced economic modelling.
 
 ---
 
-The Arbiter workspace has five crates:
+The Starkbiter workspace has five crates:
 - `starkbiter`: The bin that exposes a command line interface for contract bindings.
-- `starkbiter-core`: A lib containing the core logic for the Arbiter framework, including the `StarkbiterMiddleware` discussed before, and the `Environment`, our sandbox.
+- `starkbiter-core`: A lib containing the core logic for the Starkbiter framework, including the `StarkbiterMiddleware` discussed before, and the `Environment`, our sandbox.
 - `starkbiter-engine`: A lib that provides abstractions for building simulations, agents, and behaviors.
-- `starkbiter-macros`: A lib crate that contains the macros used to simplify development with Arbiter.
+- `starkbiter-macros`: A lib crate that contains the macros used to simplify development with Starkbiter.
 - `starkbiter-bindings`: A lib crate containing bindings for utility smart contracts used for testing and development.
 
 ## WIP
@@ -60,7 +60,7 @@ A financial engineer may want to test their strategies against thousands of mark
 Likewise, the same engineer may want to develop searcher agents, solver agents, or other autonomous agents that can be run on the blockchain.
 
 ## Working with the Starkbiter Framework
-To work with Arbiter, you must have Rust installed on your machine. 
+To work with Starkbiter, you must have Rust installed on your machine. 
 You can install Rust by following the instructions [here](https://www.rust-lang.org/tools/install). 
 It will also be helpful to get the `cargo-generate` package, which you can install by doing:
 ```bash
@@ -92,7 +92,7 @@ To install the Starkbiter binary, run:
 ```bash
 cargo install starkbiter
 ```
-This will install the Arbiter binary on your machine. You can then run `arbiter --help` to see that Arbiter was correctly installed and see the help menu.
+This will install the Starkbiter binary on your machine. You can then run `starkbiter --help` to see that Starkbiter was correctly installed and see the help menu.
 
 ### Bindings
 You can put your compiled sierra 1.0 contract jsons in the `contracts/` directory of your templated project, you'll need to run:
@@ -120,7 +120,7 @@ This will instantiate environment which will upon request fetch missing bits of
 
 ## Cargo Docs
 
-To see the Cargo docs for the Arbiter crates, please visit the following:
+To see the Cargo docs for the Starkbiter crates, please visit the following:
 - [`starkbiter`](https://docs.rs/crate/starkbiter/)
 - [`starkbiter-bindings`](https://docs.rs/crate/starkbiter-bindings/)
 - [`starkbiter-core`](https://docs.rs/starkbiter-core/)

docs/src/index.md

@@ -7,7 +7,7 @@ Furthermore, Starkbiter provides containment and management for simulations.
 ## Overview
 The Starkbiter workspace has three crates:
 - `starkbiter`: The binary crate that exposes a command line interface for initializing simulations via a templated repository and generating contract bindings needed for the simulation.
-- `starkbiter-core`: The lib crate that contains the core logic for the Arbiter framework including the `StarkbiterMiddleware` discussed before, the `Environment` which envelopes simulations, and the `Manager` who controls a collection of environments.
+- `starkbiter-core`: The lib crate that contains the core logic for the Starkbiter framework including the `StarkbiterMiddleware` discussed before, the `Environment` which envelopes simulations, and the `Manager` who controls a collection of environments.
 - `starkbiter-engine`: The lib crate that provides abstractions for building simulations and more.
 
 The purpose of Starkbiter is to provide a toolset to construct arbitrary agents (defined in Rust, by smart contracts, or even other foreign function interfaces) and have these agents interact with an Ethereum-like environment of your design. 
@@ -50,7 +50,7 @@ The first and most crucial step is to model the system. A well-modeled system ac
 These methods model the system's normal behavior using statistical models and then use these models to detect deviations. To model things well, people use techniques such as mean, median, and standard deviation, or more complex models like regression models can be used. For example, the Poisson distribution gives the probability of an event happening a certain number of times (k) within a given interval of time or space. So, you can quantify an average number of occurrences of some action (say, to model the behavior of a retail agent or network congestion from certain events). In that case, you can model this well with the Poisson distribution. 
 
 ### Defining Normal Behavior: Agent design
-Once the system is modeled, the next step is to define what constitutes normal behavior for the system. This could be based on historical data, expert knowledge, or both. This is not a feature of Arbiter yet (The starkbiter-engine crate is a WIP but contains some of our initial work on this). This can be incredibly simple (passive behavior) or complex (interactive behavior). But the better they model the system, the better the results. For example, you can model LPs as more passive agents that deposit and withdraw liquidity based on some average occurrences. In contrast, arbitrageurs can be modeled as more interactive agents that react to certain events or `SLAOD's on specific memory locations. As the agents start to resemble real-world actors, the results will be more accurate, and the data will be more beneficial for the system designers.
+Once the system is modeled, the next step is to define what constitutes normal behavior for the system. This could be based on historical data, expert knowledge, or both. This is not a feature of Starkbiter yet (The starkbiter-engine crate is a WIP but contains some of our initial work on this). This can be incredibly simple (passive behavior) or complex (interactive behavior). But the better they model the system, the better the results. For example, you can model LPs as more passive agents that deposit and withdraw liquidity based on some average occurrences. In contrast, arbitrageurs can be modeled as more interactive agents that react to certain events or `SLAOD's on specific memory locations. As the agents start to resemble real-world actors, the results will be more accurate, and the data will be more beneficial for the system designers.
 
 ### Simulating the System
 The system is then simulated over some time. During this simulation, the agents interact with each other and their environment, generating data that reflects the system's behavior. You can decide on specific parameters and configurations for the system. Designating the system simulation to be as close to the real-world system as possible is recommended. For example, historically or with price processes, we can model a sequence of prices for arbitrageurs. The speed and performance of the simulation have made it possible for you to get more data by doing the latter. 

docs/src/usage/arbiter_cli.md

@@ -1,12 +1,12 @@
-# Arbiter CLI
+# Starkbiter CLI
 Arbiter provides a Foundry-like CLI experience. You can initialize new projects, generate bindings and execute simulations using the CLI.
 
-To create a new Arbiter project:
+To create a new Starkbiter project:
 ```bash
 arbiter init your-new-project
 cd your-new-project
 ```
-This initializes a new Arbiter project with a template.
+This initializes a new Starkbiter project with a template.
 You can run `arbiter init <simulation_name> --no-git` to remove the `.git` directory from the template upon initialization.
 
 ## Bindings
@@ -19,9 +19,9 @@ The contract bindings are generated via Foundry's `forge` command.
 You can generate the bindings again by running:
 
 ```bash
-arbiter bind
+starkbiter bind
 ```
-Arbiter bind wraps `forge bind` and is configured from your cargo.toml. There are three optional fields you can add to your toml to configure arbiter bind. 
+Starkbiter bind wraps `forge bind` and is configured from your cargo.toml. There are three optional fields you can add to your toml to configure starkbiter bind. 
 ```toml
 [arbiter]
 bindings_workspace = "simulation" # must be a valid workspace member
@@ -35,7 +35,7 @@ The template is executable at this point and you can run it by running:
 cargo run
 ```
 
-You can load or write your own smart contracts in the templates `contracts/` directory and begin writing your own simulations. Arbiter treats Rust smart-contract bindings as first-class citizens. The contract bindings are generated via Foundry's forge command. arbiter bind wraps forge with some convenience features that will generate all your bindings to `src/bindings` as a rust module. Foundry power-users are welcome to use forge directly. You can also manage project dependencies using git submodules via `forge install`. The [Foundry book](https://book.getfoundry.sh/reference/forge/forge-install) provides further details on managing project dependencies and other features.
+You can load or write your own smart contracts in the templates `contracts/` directory and begin writing your own simulations. Starkbiter treats Rust smart-contract bindings as first-class citizens. The contract bindings are generated via Foundry's forge command. starkbiter bind wraps forge with some convenience features that will generate all your bindings to `src/bindings` as a rust module. Foundry power-users are welcome to use forge directly. You can also manage project dependencies using git submodules via `forge install`. The [Foundry book](https://book.getfoundry.sh/reference/forge/forge-install) provides further details on managing project dependencies and other features.
 
 
 ## Forking
@@ -45,7 +45,7 @@ An example is provided in the `example_fork` directory.
 Essentially, you provide your storage location for the data, the network you want the block number you want, and metadata about the contracts you want to fork.
 
 ```bash
-arbiter fork <fork_config.toml>
+starkbiter fork <fork_config.toml>
 ```
 
 This will create a fork of the network you specified in the config file and store it in the location you specified.
@@ -54,4 +54,4 @@ It can then be loaded into an `starkbiter-core` `Environment` by using the `Fork
 Forking is done this way to make sure that all emulation done does not require a constant connection to an RPC-endpoint.
 
 **Optional Arguments** 
-You can run `arbiter fork <fork_config.toml> --overwrite` to overwrite the fork if it already exists.
+You can run `starkbiter fork <fork_config.toml> --overwrite` to overwrite the fork if it already exists.

docs/src/usage/arbiter_engine/agents_and_engines.md

@@ -11,7 +11,7 @@ The latter will also require a `stream::select` type of operation to merge all t
 
 ## `struct Agent`
 The `Agent` struct is the primary struct that you will be working with.
-It contains an ID, a client (`Arc<RevmMiddleware>`) that provides means to send calls and transactions to an Arbiter `Environment`, and a `Messager`.
+It contains an ID, a client (`Arc<RevmMiddleware>`) that provides means to send calls and transactions to an Starkbiter `Environment`, and a `Messager`.
 It looks like this:
 ```rust, ignore
 pub struct Agent {

docs/src/usage/arbiter_engine/index.md

@@ -21,7 +21,7 @@ The `Behavior<E>` has two methods: `startup` and `process`.
     It can also be streamed and used for processing messages in a `Behavior<Message>`.
     - `Agent` also owns a `Vec<Box<dyn StateMachine>>` which is a list of `StateMachine`s that the `Agent` will run.
     This is a way for `Agent`s to have multiple `Behavior`s that may not use the same event type.
-- `World` is a struct that has an ID, an Arbiter `Environment`, a mapping of `Agent`s, and a `Messager`.
+- `World` is a struct that has an ID, an Starkbiter `Environment`, a mapping of `Agent`s, and a `Messager`.
     - The `World` is tasked with letting `Agent`s join in, and when they do so, to connect them to the `Environment` with a client and `Messager` with the `Agent`'s ID.
 - `Universe` is a struct that wraps a mapping of `World`s.
     - The `Universe` is tasked with letting `World`s join in and running those `World`s in parallel.