.default})
-```
-
-### Adding meta data to your doc
-
-The docs make use of a feature called [frontmatter](https://docusaurus.io/docs/api/plugins/@docusaurus/plugin-content-docs#markdown-frontmatter) which lets you add some meta data and control the way the docs are referenced through the site.
-
-This is done by adding a small section to the top of your doc like this:
-
-```md
----
-title: Example Doc
----
-```
-
-That title in the example will automatically add a `# Heading` to your page when it renders
-
-There are a couple settings available;
-
-Such as specifying the url you would like using
-
-`slug: /questionably/deep/url/for/no/reason/buckwheat-crepes`
-
-Adding `keywords` or `description` etc, below is a full example:
-
-```
----
-id: not-three-cats
-title: Three Cats
-hide_title: false
-hide_table_of_contents: false
-sidebar_label: Still not three cats
-custom_edit_url: https://github.com/flashbots/docs/edit/main/docs/three-cats.md
-description: Three cats are not unlike four cats like three cats
-keywords:
- - cats
- - three
-image: ./assets/img/logo.png
-slug: /myDoc
----
-My Document Markdown content
-```
-
-### Side bar navigation
-
-To update the high level navigation, open the file in `docs/sidebars.js` and arrange n order as required. The titles for links are pulled from their files.
-
-The `items` here take a page ID, a page ID by default is the title of the file, as example `example-doc.md` would be `example-doc`
-
-To read the Docusaurus docs, [click here](https://docusaurus.io/docs/sidebar)
-
-[^1]: an amazing foot note, you can add links n things here as usual
diff --git a/docs/concepts/block-building.mdx b/docs/concepts/block-building.mdx
new file mode 100644
index 00000000..eec1beff
--- /dev/null
+++ b/docs/concepts/block-building.mdx
@@ -0,0 +1,75 @@
+---
+title: Block Building
+description: How you can use SUAVE to build blocks on other chains
+---
+
+# Block Building
+
+One of the unique features that SUAVE enables is block construction for other chains. Whether you're working on constructing transactions, creating bundles, or building blocks, this feature gives you the capability to interact with the latest blockchain state.
+
+## Practical Example
+
+Here is an example of a smart contract that demonstrates the practical application of a block building session:
+
+```solidity
+function sessionExample(bytes memory subTxn, bytes memory subTxn2) public payable returns (bytes memory) {
+ string memory id = Suave.newBuilder();
+
+ Suave.SimulateTransactionResult memory sim1 = Suave.simulateTransaction(id, subTxn);
+ require(sim1.success == true);
+ require(sim1.logs.length == 1);
+
+ // Simulate the same transaction again should fail due to nonce repetition
+ Suave.SimulateTransactionResult memory sim2 = Suave.simulateTransaction(id, subTxn);
+ require(sim2.success == false);
+
+ // Simulate the transaction with the correct nonce
+ Suave.SimulateTransactionResult memory sim3 = Suave.simulateTransaction(id, subTxn2);
+ require(sim3.success == true);
+ require(sim3.logs.length == 2);
+
+ return abi.encodeWithSelector(this.emptyCallback.selector);
+}
+```
+
+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
+
+SUAVE exposes several precompiles to help you with transaction simulation and block construction.
+
+If your SUAPP is intended to produce blocks, be they partial or full, you'll first need to start a new builder session. The precompile this calls in the [`suave-std` library](https://github.com/flashbots/suave-std/blob/main/src/suavelib/Suave.sol) looks like this:
+
+```solidity
+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.
+
+:::info
+
+If you'd prefer to just read how the builder is implemented in `suave-geth`, you can [**do so here**](https://github.com/flashbots/suave-geth/blob/main/suave/builder/builder.go).
+
+:::
+
+Once you receive transactions or bundles, it is often the case that you need to simulate the effect they will have on the state of the target chain for which your SUAPP is building blocks. You'll often want to construct blocks in stages, as your SUAPP receive various different bundles and/or transactions from different users. This can be achieved with either of the below precompiles:
+
+```solidity
+function simulateBundle(bytes memory bundleData) internal view returns (uint64)
+function simulateTransaction(string memory sessionid, bytes memory txn) internal view returns (SimulateTransactionResult memory)
+```
+
+If you're happy with the results of your simulation and wish to build a block based on the bundles/transactions you've received, you can use one more precompile:
+
+```solidity
+function buildEthBlock(BuildBlockArgs memory blockArgs, DataId dataId, string memory namespace) internal view returns (bytes memory, bytes memory)
+```
+
+As the name suggests, we only support building blocks on Ethereum L1 for now. This will change as SUAVE matures.
+
+All of these functions utilize the SUAVE Execution Namespace. To understand more about this, please consult the [Execution Namespace specification](/technical/specs/rigil/mevm.md#suavex-namespace).
+
+## 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).
+
diff --git a/docs/concepts/confidential-computation.mdx b/docs/concepts/confidential-computation.mdx
new file mode 100644
index 00000000..c04c3d25
--- /dev/null
+++ b/docs/concepts/confidential-computation.mdx
@@ -0,0 +1,64 @@
+---
+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
+
+:::info
+
+For practical examples of how Confidential Compute Requests (CCRs) work, please follow [**this tutorial**](/tutorials/confidential-compute-requests). The below will explain CCRs conceptually, without code.
+
+:::
+
+-
+
+**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:
+
+
+
+**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.
+
+**Transaction Hash Output**: A transaction hash for the Suave transaction above is produced and returned to the request's originator, just like Ethereum.
+
+-
+
+**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.
+
+**Request to the Confidential Datastore**: The MEVM can make API requests directly to the "Confidential Datastore" to fetch or store data.
+
+
-
+
+A user submits a transaction they wish to be included in the orderflow auction, calling the `newOrder()` function.
+
+
+
+The contract defines logic which a Kettle can use to get the confidential data, simulate the results of including this transaction, and extract the hint to be shared with searchers.
+
+```solidity
+bytes memory bundleData = Suave.confidentialInputs();
+uint64 egp = Suave.simulateBundle(bundleData);
+bytes memory hint = Suave.extractHint(bundleData);
+```
+
+
+
+
+The contract then sets who can store and "peek" (i.e. retrieve) the data. In this case, both this Private OFA contract and the precompile contract deployed at the address `0x...43200001` are set as **allowedPeekers** and **allowedStores** (though you could have totally different addresses in these arrays in your own use case). If you consult the [`suave-std` library](https://github.com/flashbots/suave-std/blob/main/src/suavelib/Suave.sol), you'll see that the precompile deployed at that address is the `FILL_MEV_SHARE_BUNDLE`, which is what we require for this particular contract.
+
+```solidity
+address[] memory allowedList = new address[](2);
+allowedList[0] = address(this);
+allowedList[1] = 0x0000000000000000000000000000000043200001;
+```
+
+
+
+
+
+Then, we create the `dataRecord`. The `decryptionCondition` is passed in as an argument and can be anything (though `decryptionConditions` will be deprecated soon) and the version is left as a blank string. Then, we write both the transaction itself, and the results from its simulation (in this case, the effective gas price after it is included) into the confidential store at different keys, which we will later use to match bundles and backruns in order to build profitable blocks.
+
+```solidity
+Suave.DataRecord memory dataRecord = Suave.newDataRecord(decryptionCondition, allowedList, allowedList, "");
+Suave.confidentialStore(dataRecord.id, "mevshare:v0:ethBundles", bundleData);
+Suave.confidentialStore(dataRecord.id, "mevshare:v0:ethBundleSimResults", abi.encode(egp));
+```
+
+
+
+
+
+The hint is not directly emitted on chain, as Confidential Compute Requests cannot directly change state, but rather is emitted as a callback once the order has been saved and the hint returned:
+
+```solidity
+return abi.encodeWithSelector(this.emitHint.selector, hintOrder);
+```
+
+
+
+Searchers can then use the information in this event to construct and submit valid backruns, which are matched against the original transactions via the `hintId`.
+
+Matched transactions and backruns are bundled together via the `fillMevShareBundle()` precompile.
+
+These bundles are sent to predefined off chain builders via the `submitBundleJsonRPC()` precompile.
+
+-
+
+Define private compute
+
+Store private data
+
+Build blocks on other chains
+
+
+
+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
+
+
Flashbots Suave Forum
-
- Discuss your thoughts and ideas with the community
-
+ Discuss your thoughts and ideas with the community
-
+You will need to have [SUAVE running locally](/tutorials/run-suave) in order to be able to run such a test successfully.
-The Forge script should print the gas used to run the specified function in your console. If you check the logs of your SUAVE devnet, you should see a message like this:
+### Deploying Contracts
-`INFO [timestamp] confidential engine: refusing to send writes based on unsigned transaction`
+In order to deploy any contract you write in the SUAPP Example repo, you need to either have [SUAVE running locally](/tutorials/run-suave/), or an account on Rigil with some [rETH from the faucet](https://faucet.rigil.suave.flashbots.net).
-Due to the limitations described above (no native support for precompiles or CCRs in Forge) and having to rely on your local environment, rather than Foundry's built-in network or forks, we recommend that you only use Forge for testing new precompiles you are writing.
+To deploy on Rigil using Forge, you can run the below:
-## Deploy your contract
-
-That said, you can use Forge to deploy contracts to SUAVE (though we recommend that you then use the [Golang SDK](/resources/golang-sdk) to send transactions).
-
-If you wanted to deploy `Example.sol`, there are three steps you need to take:
+```bash
+forge create --rpc-url https://rpc.rigil.suave.flashbots.net --legacy \
+--private-key Having issues?
-
-
-
-
-
- Typically, building SUAVE yourself places the binary in the $GOPATH/bin
- directory. If it didn't happen, ensure that path is added to your PATH
- environment variable:
-
-
- -
-
export PATH=\$PATH\:$GOPATH\/bin-
Typescript
- For web devs
+ For web developers
-
+
+transaction parsing and construction
+
+JSON object decoding and encoding
+
+convenience wrapper around precompiles
+
+