diff --git a/docs/concepts/block-building.mdx b/docs/concepts/block-building.mdx
index eec1beff..ed726786 100644
--- a/docs/concepts/block-building.mdx
+++ b/docs/concepts/block-building.mdx
@@ -34,7 +34,7 @@ function sessionExample(bytes memory subTxn, bytes memory subTxn2) public payabl
In this example, a new builder session is created, and multiple transactions are simulated with varying conditions in order to illustrate how you might approach building blocks with SUAVE.
-## Conceptual Explanation
+## Interface
SUAVE exposes several precompiles to help you with transaction simulation and block construction.
@@ -44,7 +44,7 @@ If your SUAPP is intended to produce blocks, be they partial or full, you'll fir
function newBuilder() internal view returns (string memory)
```
-This function starts a new builder instance within a Kettle. The basic idea is that session ids (the `string` returned by the `newBuilder()` precompile) provide programmatic control when building blocks, one outcome of which is simulating transactions more efficiently. Opening a session enables you to build block iteratively, rather than having to re-run all your simulations each time you receive a new transaction or bundle.
+This function starts a new builder instance within a Kettle. The basic idea is that session ids (the `string` returned by the `newBuilder()` precompile) provide programmatic control when building blocks, one outcome of which is simulating transactions more efficiently. Opening a session enables you to build blocks iteratively, rather than having to re-run all your simulations each time you receive a new transaction or bundle.
:::info
@@ -71,5 +71,7 @@ All of these functions utilize the SUAVE Execution Namespace. To understand more
## Bundles
-Bundles are one or more transactions that are grouped together and executed in the order they are provided and are the core unit of block building. If you're unfamiliar with bundles, and want to learn more, you can read [this document](https://docs.flashbots.net/flashbots-auction/advanced/understanding-bundles).
+Bundles are one or more transactions that are grouped together and executed in the order they are provided and are the core unit of block building. If you're unfamiliar with bundles, and want to learn more, you can read [this document](https://docs.flashbots.net/flashbots-auction/advanced/understanding-bundles).
+
+To see how to handle bundles in your SUAPP, check out the [`suave-std` repo](https://github.com/flashbots/suave-std/pull/28).
diff --git a/docs/concepts/confidential-computation.mdx b/docs/concepts/confidential-computation.mdx
index c04c3d25..8168ba72 100644
--- a/docs/concepts/confidential-computation.mdx
+++ b/docs/concepts/confidential-computation.mdx
@@ -3,13 +3,9 @@ title: Confidential Computation
description: How to understand confidential computation on SUAVE and use it to yur advantage.
---
-import List from '@site/src/components/List/List.tsx';
-
Confidential computation enables you to handle orderflow privately and securely.
-In SUAVE, we achieve this with [Kettles](/technical/specs/rigil/kettle#confidential-computation) performing compute offchain, but according to smart contracts written onchain. In this way, offchain compute is not constrained by chain consensus. The Kettles will eventually run in [TEEs](https://www.youtube.com/watch?v=ek-bu4aoh0A), which provide both enhanced privacy (no-one, not even the host OS, can see unencrypted data) and integrity (you can be sure the correct code, and only that code, is running at all times).
-
-## How It Works
+In SUAVE, we achieve this with [Kettles](/technical/specs/rigil/kettle#confidential-computation) performing compute offchain, but according to smart contracts written onchain. In this way, offchain compute is not constrained by chain consensus. The Kettles will eventually run in [TEEs](https://www.youtube.com/watch?v=ek-bu4aoh0A), which provide both **enhanced privacy** (no-one, not even the host OS, can see unencrypted data) and **integrity** (you can be sure the correct code, and only that code, is running at all times).
:::info
@@ -17,29 +13,27 @@ For practical examples of how Confidential Compute Requests (CCRs) work, please
:::
-
-
-**Starting Point**: A user sends "Confidential Compute Request" using `eth_sendRawTransaction`, which is received by the JSON RPC.
-
-
-
-**MEVM Execution**: Upon receiving the request, the JSON RPC triggers the MEVM (Modified Ethereum Virtual Machine) to run. MEVM execution can use multiple APIs depending on the context, with two possible paths:
-
-
+## Interface
-**Request to an External Domain**: The MEVM can make API requests to external domains: i.e. if you're running an Ethereum node, it can fetch state from there for simulations etc., or if the SUAPP uses the `doHttpRequest()` precompile, it can fetch arbitrary information required for the offchain compute.
+SUAVE exposes several precompiles to help you with confidential computation. The first is a simple check, often used in `require` statements in smart contracts:
-**Request to the Confidential Datastore**: The MEVM can make API requests directly to the "Confidential Datastore" to fetch or store data.
+```solidity
+function isConfidential() internal view returns (bool b)
+```
-
+If whoever calls a function in the contract has passed in confidential inputs to be computed offchain, then those inputs can be accessed by the MEVM using:
-
+```solidity
+function confidentialInputs() internal view returns (bytes memory)
+```
-**Broadcast results**: Eventually, after processing the request the MEVM can take the results and, depending on the SUAPP's logic, send a SUAVE transaction, which is a transaction object that contains the result of the CCR in its calldata (and the signature of the Kettle which computed said result), which enables other users or contracts to take action.
+Once the MEVM has the confidential inputs, there is any number of things you could tell it to do with them. For instance, in the [Private OFA Suapp](https://github.com/flashbots/suapp-examples/tree/main/examples/app-ofa-private) we'll look at in greater detail below, we use the below precompile to extract any information about a transaction that the user has agreed to share in order for it to be included timeously in a block on Ethereum L1, thereby replicating MEV-Share in a smart contract on SUAVE:
-**Transaction Hash Output**: A transaction hash for the Suave transaction above is produced and returned to the request's originator, just like Ethereum.
+```solidity
+function extractHint(bytes memory bundleData) internal view returns (bytes memory)
+```
-
+You can also consult [our technical specs](/technical/specs/rigil/kettle#confidential-computation) for further information about confidential computation if required.
### Computing over Confidential Data
diff --git a/docs/concepts/confidential-data-storage.mdx b/docs/concepts/confidential-data-storage.mdx
index 902a97d3..b5485126 100644
--- a/docs/concepts/confidential-data-storage.mdx
+++ b/docs/concepts/confidential-data-storage.mdx
@@ -5,10 +5,10 @@ description: How to leverage confidential data to your advantage when building o
import List from '@site/src/components/List/List.tsx';
-## Data Records
-
Confidential storage works with opaque identifiers, which are generated by Kettles when data is put in storage during offchain/confidential computation. These identifiers are part of an object we call a `DataRecord`, which holds a reference to the data, its ID, who can store and retrieve it, and a few other pieces of metadata.
+## Interface
+
This is what these DataRecords look like in the [`suave-std` library](https://github.com/flashbots/suave-std/blob/main/src/suavelib/Suave.sol):
```solidity
@@ -26,7 +26,7 @@ This is what these DataRecords look like in the [`suave-std` library](https://gi
## Practical Example
-Consider the same [Private OFA Suapp](https://github.com/flashbots/suapp-examples/blob/main/examples/app-ofa-private/ofa-private.sol) from the previous tutorial. The OFA contract needs to accept user transactions, store them, and emit a hint that searchers can use. It then needs to accept backruns from searchers and match those with the user transactions in storage: a task it achieves by means of the `recordId`.
+Consider the same [Private OFA Suapp](https://github.com/flashbots/suapp-examples/blob/main/examples/app-ofa-private/ofa-private.sol) from the previous page. The OFA contract needs to accept user transactions, store them, and emit a hint that searchers can use. It then needs to accept backruns from searchers and match those with the user transactions in storage: a task it achieves by means of the `recordId`.
The end-to-end flow looks like this:
diff --git a/docs/concepts/index.mdx b/docs/concepts/index.mdx
index 23527758..c17280ea 100644
--- a/docs/concepts/index.mdx
+++ b/docs/concepts/index.mdx
@@ -7,30 +7,20 @@ keywords:
- concepts
---
-import List from '@site/src/components/List/List.tsx';
+import DocCardList from '@theme/DocCardList';
-SUAVE gives you, an application developer, a way to:
+Each of the pages in this section describes one of the ways in which SUAVE extends Solidity and gives you, a MEV application developer, unique advantages.
-
+
-Define private compute
+In brief, SUAVE enables you to:
-Store private data
+- π Build blocks on other chains
-Build blocks on other chains
+- π§βπ» Define private compute
-
+- π΅οΈββοΈ Store private data
-Interface with many different MEV components, meaning that you can
-
-
-
- Plug into existing MEV infra: i.e sending bundles to block builders, relays, validators or sequencers
-
- Build totally new MEV infra: i.e. create unique SUAPPs on SUAVE
-
-
-
-
-
-
\ No newline at end of file
+- 𧩠Interface with many different MEV components, meaning that you can
+ - β‘ Plug into existing MEV infra: i.e sending bundles to block builders, relays, validators or sequencers
+ - π€ Build totally new MEV infra: i.e. create unique SUAPPs on SUAVE
diff --git a/docs/concepts/mev-supplychain-interface.mdx b/docs/concepts/mev-supplychain-interface.mdx
index f5512a66..e698635c 100644
--- a/docs/concepts/mev-supplychain-interface.mdx
+++ b/docs/concepts/mev-supplychain-interface.mdx
@@ -13,7 +13,7 @@ At a first approximation, the MEV supply chain looks like this:
The point of this section has been to illustrate that SUAPPs can interact with any of these components.
-### Off-SUAVE interaction
+### Off-SUAVE interface
```solidity
function submitBundleJsonRPC(string memory url, string memory method, bytes memory params) internal view returns (bytes memory)
@@ -45,7 +45,7 @@ function submitBundle(string memory builderUrl, bytes memory bundleData) interna
}
```
-### On SUAVE interaction
+### On-SUAVE interface
```solidity
function confidentialStore(DataId dataId, string memory key, bytes memory value) internal view
diff --git a/docs/resources/forge.mdx b/docs/resources/forge.mdx
index 924363a7..5f7daf0b 100644
--- a/docs/resources/forge.mdx
+++ b/docs/resources/forge.mdx
@@ -14,7 +14,7 @@ In order to make interacting with these precompiles easier, we maintain a reposi
The easiest way to start creating your own contracts with Forge is to clone the [Suapp Examples repo](https://github.com/flashbots/suapp-examples/), as it comes with `suave-std` already set up as a submodule, as well as a series of examples that use both Forge and the Golang SDK.
```bash
-git clone git@github.com:flashbots/suave-std.git && cd suapp-examples
+git clone git@github.com:flashbots/suapp-examples.git && cd suapp-examples
```
```bash
diff --git a/docs/tutorials/build-suapps.mdx b/docs/tutorials/build-suapps.mdx
index 17eccf8d..29a84a2d 100644
--- a/docs/tutorials/build-suapps.mdx
+++ b/docs/tutorials/build-suapps.mdx
@@ -42,8 +42,8 @@ cd src/ && bun link
1. Confidential Compute Requests on SUAVE do not work with wallets that implement the EIP-1193 Javascript API. Therefore, we use the unsafe `eth_sign` method to sign CCRs, which does work, but requires that you enable this functionality in wallets like MetaMask.
1. To do so in MetaMask, go to "Settings" -> "Advanced" -> scroll to bottom -> switch Eth_sign requests on.
-2. Both templates assume that you are running SUAVE locally.
-3. No tests are included for the contracts, as it is not trivial to test new precompiles and different transaction types (i.e. CCRs) in `forge` at this time.
+2. Both templates below assume that you are running SUAVE locally.
+3. No tests are included for the contracts at this time.
## Typescript Template
@@ -72,7 +72,9 @@ This template uses the same MEV-Share example contract we worked with using the
## Next Template
-This template comes with a more extensive frontend framework, which uses Next (in typescript) and therefore depends on React. You can get it running by first cloning the repo and installing its dependencies. Make sure you have previously built and symlinked suave-viem for this to work:
+This template comes with a more extensive frontend framework, which uses Next (in typescript) and therefore depends on React. You can get it running by first cloning the repo and installing its dependencies.
+
+Make sure you have previously built and symlinked suave-viem for this to work:
```bash
git clone git@github.com:andytudhope/build-a-suapp-next-ts.git \
diff --git a/docs/tutorials/confidential-compute-requests.mdx b/docs/tutorials/confidential-compute-requests.mdx
index 4566a3ee..5f0559d0 100644
--- a/docs/tutorials/confidential-compute-requests.mdx
+++ b/docs/tutorials/confidential-compute-requests.mdx
@@ -132,9 +132,11 @@ The [Typescript template](https://github.com/flashbots/suave-viem/tree/main/exam
In this case, we need to:
-1. Craft a transaction on your chosen domain and sign it.
+1. Craft a transaction on Goerli and sign it.
2. Append relevant details like the `decryptionCondition`, `kettleAddress`, `contract` and `chainId`.
-3. Use a helper function like `toConfidentialRequest` to (i) place our signed transaction in `confidentialInputs` and (ii) replace the `data` field with a call to the appropriate method in the specified SUAVE contract.
+3. Use a helper function like `toConfidentialRequest` to
+ 1. place our signed transaction in `confidentialInputs` and
+ 2. replace the `data` field with a call to the appropriate method in the specified SUAVE contract.
The [code which achieves this can be found here](https://github.com/flashbots/suave-viem/blob/main/examples/suave-web-demo/src/suave.ts) and looks like this:
@@ -187,7 +189,7 @@ The [**SUAPP Examples repo**](https://github.com/flashbots/suapp-examples) uses
:::
-In particular, we can look at the [private order-flow auction example](https://github.com/flashbots/suapp-examples/blob/main/examples/app-ofa-private/main.go) to understand how to use the Golang SDK to craft more complex kinds of CCRs.
+Let's look at the [private order-flow auction example](https://github.com/flashbots/suapp-examples/blob/main/examples/app-ofa-private/main.go) to understand how to use the Golang SDK to craft more complex kinds of CCRs.
The flow of this example is similar to the Typescript MEVShare demo directly above. However, we'll use it to demonstrate a full e2e flow with CCRs:
diff --git a/docs/tutorials/deploy-contracts.mdx b/docs/tutorials/deploy-contracts.mdx
index 7c507432..afafbca3 100644
--- a/docs/tutorials/deploy-contracts.mdx
+++ b/docs/tutorials/deploy-contracts.mdx
@@ -64,7 +64,7 @@ Transaction hash: 0x9ae80af40bdafbc706108446dbbf7761a59f5bf544b46c97b9b0851dddaa
### Locally
-You can follow the exact same method as above to deploy contracts to your local SUAVE devnet. You just need to have SUAVE running and use the pre-funded account we have setup for you:
+You can follow the exact same method as above to deploy contracts to your local SUAVE devnet. You need to [have SUAVE running](/tutorials/run-suave) and use the pre-funded account we have setup for you:
```bash
forge create --rpc-url http://localhost:8545 --legacy \
@@ -81,25 +81,6 @@ Deployed to: 0xcbdF0322Cd79212e10b0dB72D775aE05B99c1796
Transaction hash: 0x9ae80af40bdafbc706108446dbbf7761a59f5bf544b46c97b9b0851dddaa3927
```
-## Deploy with Remix
-
-:::warning
-
-This method is quick, but limited. You can deploy contracts using Remix and an injected web3 provider. However, you cannot send Confidential Compute Requests to those contracts from providers like MetaMask, so it is difficult to interact with your contracts once deployed.
-
-:::
-
-Follow these steps to deploy a contract via Remix:
-
-1. Add the Rigil RPC to your MetaMask or equivalent wallet and connect to it:
-
-
-
-2. Ensure you have rETH from the [Rigil ETH Faucet](https://faucet.rigil.suave.flashbots.net)
-3. Go to the [Remix IDE](http://remix.ethereum.org/) and navigate to the bottom icon on the right-hand menu: "Deploy and Run Transactions".
-4. Open the dropdown "Environment" menu and select "Injected Provider - MetaMask". It should show `Custom (16813125) network` directly below that field if this works correctly.
-5. Write (or import) your contracts in the File Explorer tab, compile them, and deploy them as you usually would.
-
## SUAPP Examples
First, clone and set up the [SUAPP examples repo](https://github.com/flashbots/suapp-examples/):
@@ -120,23 +101,11 @@ You can compile the contracts in the repo with:
forge build
```
-
- What is Forge?
-
-
-
- `forge` is a part of the smart contract development toolchain we use in our examples, which you can learn more about in our [next tutorial](/tutorials/deploy-contracts). If you do not have it installed, you can do so quickly with:
-
curl -L https://foundry.paradigm.xyz | bash
-
-
-
-
### Locally
Now we can deploy and transact with any of the example contracts.
-The `framework/framework.go` file defaults to your [local SUAVE devnet](/tutorials/run-suave). If you have that running, just `cd` into the relevant directory and run the `main.go` file. For instance, to deploy and transact with the example contract which demonstrates how updating state works for normal vs confidential requests, you can run:
+Once you have [SUAVE running locally](/tutorials/run-suave), `cd` into the relevant directory and run the `main.go` file. For instance, to deploy and transact with the example contract which demonstrates how updating state works for normal vs confidential requests, you can run:
```bash
cd examples/onchain-state && go run main.go
@@ -149,7 +118,7 @@ You should see this message printed in your terminal if successful:
2. Send a confidential request that modifies the state
```
-The `framework.go` and all of the `main.go` files use the Golang SDK, which you can read more about in our [developer guides](/resources/golang-sdk).
+The `framework.go` and all of the `main.go` files use the Golang SDK, which you can read more about in our [resources section](/resources/golang-sdk).
### To Rigil
@@ -178,3 +147,22 @@ You should again see output like this logged in your terminal:
1. Send a confidential request that cannot modify the state
2. Send a confidential request that modifies the state
```
+
+## Deploy with Remix
+
+:::warning
+
+This method is quick, but limited. You can deploy contracts using Remix and an injected web3 provider. However, you cannot send Confidential Compute Requests to those contracts from providers like MetaMask, so it is difficult to interact with your contracts once deployed.
+
+:::
+
+Follow these steps to deploy a contract via Remix:
+
+1. Add the Rigil RPC to your MetaMask or equivalent wallet and connect to it:
+
+
+
+2. Ensure you have rETH from the [Rigil ETH Faucet](https://faucet.rigil.suave.flashbots.net)
+3. Go to the [Remix IDE](http://remix.ethereum.org/) and navigate to the bottom icon on the right-hand menu: "Deploy and Run Transactions".
+4. Open the dropdown "Environment" menu and select "Injected Provider - MetaMask". It should show `Custom (16813125) network` directly below that field if this works correctly.
+5. Write (or import) your contracts in the File Explorer tab, compile them, and deploy them as you usually would.
\ No newline at end of file
diff --git a/docs/tutorials/index.mdx b/docs/tutorials/index.mdx
index d195f882..acb93129 100644
--- a/docs/tutorials/index.mdx
+++ b/docs/tutorials/index.mdx
@@ -10,22 +10,20 @@ keywords:
import DocCardList from '@theme/DocCardList';
-SUAVE is focused on delivering credible, confidential computation that enables you to build better mechanisms.
+:::info
+
+SUAVE is focused on delivering credible, confidential computation that enables you to build better mechanisms. SUAVE enables anyone to build and deploy MEV applications, on a decentralized network, which were not possible until today.
+
+:::
## What can I do with SUAVE?
1. **Deploy more expressive smart contracts.**
- - Contracts on SUAVE follow the same rules as on Ethereum, with the added advantage of being able to access additional precompiles available to serve any MEV application. We call this "builder solidity".
+ - Contracts on SUAVE follow the same rules as on Ethereum, with the added advantage of being able to access additional precompiles available to serve any SUAPP.
2. **Compute confidentially**.
- - Builder solidity lets you request confidential computation, where your transaction data is encrypted to specific actors. Public contracts with verifiable logic, combined with confidential data, means that SUAVE can be seen as an open marketplace for mechanisms we can all inspect, collaborate on, and compete with to produce the most efficient MEV applications, while nevertheless protecting everyone's privacy.
-
-:::info
-
-SUAVE enables anyone to build and deploy MEV applications, on a decentralized network, which were not possible until today.
-
-:::
+ - Public contracts with verifiable logic, combined with confidential data, means that SUAVE can be seen as an open marketplace for mechanisms we can all inspect, collaborate on, and compete with to produce the most efficient MEV applications, while nevertheless protecting everyone's privacy.
## In this section
diff --git a/docs/tutorials/run-suave.mdx b/docs/tutorials/run-suave.mdx
index d4c9355b..e68d75cc 100644
--- a/docs/tutorials/run-suave.mdx
+++ b/docs/tutorials/run-suave.mdx
@@ -51,13 +51,13 @@ make suave
Now you have a `suave` binary in `./build/bin/`:
```bash
-./build/bin/suave --version
+./build/bin/suave-geth --version
```
Start the local devnet with:
```bash
-./build/bin/suave --suave.dev
+./build/bin/suave-geth --suave.dev
```
diff --git a/docs/tutorials/suave-standard-library.mdx b/docs/tutorials/suave-standard-library.mdx
index 88f223f4..2b9dbb1a 100644
--- a/docs/tutorials/suave-standard-library.mdx
+++ b/docs/tutorials/suave-standard-library.mdx
@@ -8,8 +8,6 @@ keywords:
- solidity
---
-import List from '@site/src/components/List/List.tsx';
-
[suave-std](https://github.com/flashbots/suave-std) is a collection of Solidity contracts and libraries to help you create Suapps. It is included as a submodule in the [SUAPP Examples](https://github.com/flashbots/suapp-examples/) repo, which we used in the previous tutorial.
In this tutorial, we will be diving deeper into the different capabilities offered by `suave-std`.
@@ -20,21 +18,15 @@ In this tutorial, we will be diving deeper into the different capabilities offer
:::
-The core functionalities that `suave-std` will help you handle include:
-
-
-
-transaction parsing and construction
-
-JSON object decoding and encoding
-
-convenience wrapper around precompiles
+Some functionalities that `suave-std` will help you handle include:
-
+- π± Transaction parsing and construction
+- π§ JSON object decoding and encoding
+- βΎοΈ A wrapper for all the precompiles to make calling any of them more convenient
## Transactions
-One such example of this is encoding and decoding transactions from other chains, which you may need to do when matching different transactions in an order flow auction, or turning bundles into (partial) blocks in a block building contract, or weaving together different transactions on different chains for your unique use case.
+Encoding and decoding transactions from other chains is often necessary when matching different transactions in an order flow auction, or turning bundles into (partial) blocks in a block building contract, or weaving together different transactions on different chains for your unique use case.
Having to encode and decode such transactions is a pain, which is exactly the sort of scenario where `suave-std` can help:
diff --git a/docs/what-is-suave.mdx b/docs/what-is-suave.mdx
index 8715032e..dfed0024 100644
--- a/docs/what-is-suave.mdx
+++ b/docs/what-is-suave.mdx
@@ -15,21 +15,25 @@ import Video from '@site/src/components/Video/Video.tsx';
# What is SUAVE?
-SUAVE - _Single Unifying Auction for Value Expression_ - is a platform for building MEV applications such as OFAs and block builders in a decentralized and private way.
+:::info
-SUAVE is designed as an open marketplace for MEV applications which we call "_SUAPPs_". SUAPPs are composed of smart contracts deployed on SUAVE, which can do one (or more) of the following:
+SUAVE, the **Single Unifying Auction for Value Expression**, is a decentralized network intended for MEV applications such as order flow auctions and block builders, which make use of credible, confidential computation.
+
+:::
+
+SUAVE is designed as an open marketplace for these MEV applications, which we call "_SUAPPs_". SUAPPs are composed of smart contracts deployed on SUAVE, which can do one (or more) of the following:
-**Compute on confidential data**, e.g., auctions, block building
+π΅οΈββοΈ **Compute on confidential data**, e.g. auctions, block building
-**Compute that requires too much gas to do on-chain**
+πΈ **Compute that requires too much gas to do on-chain**
-**Coordinate within block times**, e.g., block building, trade routing and filling
+π€Ή **Coordinate within block times**, e.g. block building, trade routing and filling
-**Access relevant off-chain data**, e.g., trading strategies conditional on centralized exchange prices or transactions that are conditional on other transactions
+ποΈ **Access relevant off-chain data**, e.g. trading strategies conditional on centralized exchange prices or transactions that are conditional on other transactions
-**Help create, attest to, or process commitments** of various kinds, e.g., shared sequencers for rollups, new kinds of DEXes and bridges
+π€ **Help create, attest to, or process commitments** of various kinds, e.g. shared sequencers for rollups, new kinds of DEXes and bridges
@@ -44,37 +48,27 @@ SUAVE does not replace other blockchains: it is intended to aggregate and coordi
SUAVE is not a Layer 2 in the sense that it does not post state roots to Ethereum or otherwise depend upon Ethereum for its security.
+The bridge between SUAVE and Ethereum is still WIP, and is a topic of active research and debate. Its current implementation is purposefully naive to allow for quick iteration at this early stage.
+
## What is different about SUAVE
### Architecture
-
-
SUAVE is a fork of Geth, with additional precompiles for MEV applications (**SUAPPs**) and a modified runtime to enable confidential computation (**the MEVM**).
We call the primary protocol actor a **Kettle**. A Kettle contains a modified version of a Geth node (the "MEVM") and a confidential data store.
-A Kettle can compute over confidential data sent to it, add that data to its local store, and only emit specific information, or "hints", on the SUAVE Chain.
-
-SUAVE has public and private state.
-
-Public state is accessible on the SUAVE Chain, which currently runs Clique POA Consensus (for fast iteration, to be changed in future releases).
+A Kettle can compute over confidential data sent to it, add that data to its local store, and only broadcast specific information, or "hints", to the wider public.
-To access private state, we use "Confidential Compute Requests".
-
-
+SUAVE has public and private state. Public state is accessible on the SUAVE Chain, which currently runs Clique POA Consensus (for fast iteration, to be changed in future releases). To access private state, we use "Confidential Compute Requests".
### Contracts and Transactions
-
-
A SUAPP is a smart contract deployed on SUAVE, just as a Dapp is a smart contract deployed on Ethereum. [Deploying contracts](/tutorials/deploy-contracts) is largely the same as any EVM chain.
-Transactions are different, because they can contain data encrypted for specific actors (i.e. Kettles and/or other contracts). These are the ["Confidential Compute Requests"](/tutorials/confidential-compute-requests).
-
-Confidential Compute Requests are handled via a modified RPC in each Kettle. They allow you to control how much data ends up back on-chain.
+Transactions can differ, because they can contain data encrypted for specific actors (i.e. Kettles and/or other contracts). These are ["Confidential Compute Requests"](/tutorials/confidential-compute-requests).
-
+Confidential Compute Requests are handled via a modified RPC in each Kettle, and executed by the "Modified Ethereum Virtual Machine", or "MEVM".
## Why SUAVE matters