diff --git a/docs/design-goals.mdx b/docs/design-goals.mdx index 678bee89..1b94c736 100644 --- a/docs/design-goals.mdx +++ b/docs/design-goals.mdx @@ -66,7 +66,7 @@ We strive for the same generality with SUAVE: it should be possible to use SUAVE This is taken from both sources above. Strategyproof computing argues that we ought to "simplify the decisions facing participants in distributed multi-agent systems", and Vitalik points out that simplicity matters "because it (i) minimizes development costs, (ii) reduces risk of unforeseen security issues, and (iii) allows protocol designers to more easily convince users that parameter choices are legitimate". -We value simplicity because it enhances flexibility with respect to our dependencies, such that we can readily upgrade MEVM nodes from SGX to MPC, or deploy better cryptographic solutions like FHE, or introduce some maximally robust and sufficiently decentralized combination of the above. +We value simplicity because it enhances flexibility with respect to our dependencies, such that we can readily upgrade SUAVE nodes from SGX to MPC, or deploy better cryptographic solutions like FHE, or introduce some maximally robust and sufficiently decentralized combination of the above. - [Simplicity Matters](https://youtu.be/rI8tNMsozo0) diff --git a/docs/how-to/extras.mdx b/docs/how-to/extras.mdx new file mode 100644 index 00000000..efbf9772 --- /dev/null +++ b/docs/how-to/extras.mdx @@ -0,0 +1,91 @@ +# Commands + +### Deploy Commands: + +1. `deployBlockSenderContract`: Deploys the BlockSender contract to the Suave network. This contract is used to send constructed blocks for execution via the Boost Relay. + +2. `deployMevShareContract`: Deploys the MevShare contract to the Suave network. This contract is used for sharing Maximum Extractable Value (MEV) profits with the MevExtractor contract. + +### Send Commands: + +1. `sendBundle`: Sends a bundle of transactions to specified MEVM contract. + +2. `sendMevShareBundle`: Sends a MEVShare bundle to specified MEVM contract. + +3. `sendMevShareMatch`: Sends a MEV share match transaction to the Suave network via the Boost Relay for matching MEV share recipients with their corresponding transactions. + +4. `sendBuildShareBlock`: Sends a transaction to build a Goerli block using MEV-Share orderflow and sends to specified Goerli relay. + +### Demo Helper Commands: + +1. `startHintListener`: Starts a hint listener for demo purposes. This command listens for hints emmited from MEV-Share on the Suave Chain. + +2. `subscribeBeaconAndBoost`: Subscribes to events from the Beacon Chain and Boost for demo purposes. + +3. `startRelayListener`: Starts a relay listener for demo purposes. This command listens for block submisisons and deliveries from the Boost Relay. + +### End-to-End (e2e) Test Commands: + +1. `testDeployAndShare`: Performs an end-to-end test scenario that includes contract deployment and block sharing. + +2. `buildGoerliBlocks`: Performs an end-to-end test scenario for building and sharing blocks on the Goerli network. + + + + + + + + + +note to self: these code examples come from the README. See if I can work them into all that is in SUAVE cli. + +We can go over the above steps again, this time looking at the actual code required for each step: + +1. You can create an ordinary EVM transaction like this in Go: + +```go +allowedPeekers := []common.Address{newBlockBidPeeker, newBundleBidPeeker, buildEthBlockPeeker} // express which contracts should have access to your data (by their addresses) +offchainInnerTx := &types.LegacyTx{ + Nonce: suaveAccNonce, + To: &newBundleBidAddress, + Value: nil, + Gas: 1000000, + GasPrice: 50, + Data: bundleBidAbi.Pack("newBid", targetBlock, allowedPeekers) +} +``` + +2. You can wrap (and sign) the above transaction into the new `OffchainTx` method as below, making sure to include the SUAVE node's public key. + +```go +offchainTx := types.SignTx(types.NewTx(&types.OffchainTx{ + ExecutionNode: "0x4E2B0c0e428AE1CDE26d5BcF17Ba83f447068E5B", + Wrapped: *types.NewTx(&offchainInnerTx), +}), suaveSigner, privKey) +``` + +3. Request confidential computation by submitting your transaction along with your confidential data to the SUAVE node you chose via `eth_sendRawTransaction`. + +```go +confidentialDataBytes := hexutil.Encode(ethBundle) +suaveClient.Call("eth_sendRawTransaction", offchainTx, confidentialDataBytes) +``` + +4. Once the SUAVE node processes your computation request, the MEVM instance will submit it as `OffchainExecutedTx` to the public mempool. For your reference, the two new types look like this: + +```go +type OffchainTx struct { + ExecutionNode common.Address + Wrapped Transaction +} +``` + +```go +type OffchainExecutedTx struct { + ExecutionNode common.Address + Wrapped Transaction + OffchainResult []byte + /* SUAVE node's signature fields */ +} +``` \ No newline at end of file diff --git a/docs/how-to/index.mdx b/docs/how-to/index.mdx index 47828e8f..1f8b7969 100644 --- a/docs/how-to/index.mdx +++ b/docs/how-to/index.mdx @@ -7,8 +7,6 @@ keywords: - practice --- -SUAVE uses the **MEVM**, which is a modified EVM with new precompiles for MEV use cases. Using the MEVM, you can program MEV applications as smart contracts within an expressive, familiar, and flexible programming environment - just like the normal EVM. - SUAVE is focused on delivering the properties you need: low latency, privacy, credible computation, and composability. ## What can I do with SUAVE? @@ -17,7 +15,7 @@ SUAVE is focused on delivering the properties you need: low latency, privacy, cr - Contracts on SUAVE follow the same rules as on Ethereum, with the added advantage of being able to access additional precompiles we have made available to serve any MEV application. We call this builder solidity. 2. **Enjoy confidential execution**. - - Builder solidity lets you define computation that can occur "off-chain", that is, where the transaction data is not exposed to everyone using SUAVE, but is encrypted to specific actors. Once the node(s) you have encrypted your data for complete the confidential computation, the result replaces the calldata for on-chain execution. This creates a public and transparent marketplace of applications in which we can inspect, collaborate, and compete to produce the most efficient order flow auctions, or block building algorithsm etc., while nevertheless protecting the data of the people who use those applications. + - Builder solidity lets you define computation that can occur "off-chain", that is, where the transaction data is not exposed to everyone using SUAVE, but is encrypted to specific actors. This creates a public and transparent marketplace of applications in which we can inspect, collaborate, and compete to produce the most efficient order flow auctions, or block building algorithms etc., while nevertheless protecting the data of the people who use those applications. > **You can build new applications that you cannot build on Ethereum in a decentralized way today.** @@ -33,8 +31,6 @@ Initially, we will support applications that require: In this section, you'll find all of our recipes. -The [tutorials](/tutorials/index) are intended to get you from 0 to 1. These "how to guides" will help you get from 1 to wherever else you want to go. They do not provide history and background explanation: they show you how to do interesting and delicious things. +The tutorials are intended to get you from 0 to 1. These "how to guides" will help you get from 1 to wherever else you want to go. They do not provide history and background explanation: they show you how to do interesting and delicious things. -1. [How to setup SUAVE](/how-to/setup-suave) and participate in the network. -2. How to create your own custom peeker ("custom peekers mev-share" Notion page, specifically to engage with design of OFA on SUAVE) -3. How to build blocks for other networks ("SUAVE Peekers Proof of Concept" Notion page, specifically to engage with block building) \ No newline at end of file +1. [How to setup SUAVE](/how-to/setup-suave), test your node, and participate in the network. \ No newline at end of file diff --git a/docs/how-to/setup-suave.mdx b/docs/how-to/setup-suave.mdx index 25e8356b..7094ac9e 100644 --- a/docs/how-to/setup-suave.mdx +++ b/docs/how-to/setup-suave.mdx @@ -12,17 +12,17 @@ keywords: ## Our goal -There are two kinds of SUAVE nodes, both participating in the same p2p network. We're going to start them both in this guide. +A SUAVE node is really two nodes in a trenchcoat, both participating in the same p2p network. We're going to start them both in this guide. -1. The "MEVM node" is a full node that can run confidential computation and broadcast the results. You need to run it in order to _act on information_ you receive (i.e. run confidential computation). You need to run one MEVM node per domain. Right now, we support Ethereum L1, but more domains will become available as we add the necessary precompiles, like `simulatePolygonBundle` or `buildOptimismBlock` etc. This will mean running many MEVM nodes: one for each domain. +1. The "MEVM instance" is a full node that can run confidential computation and broadcast the results. You need to run it in order to _act on information_ you receive (i.e. run confidential computation). You need to run one MEVM instance per domain. Right now, we support Ethereum L1, but more domains will become available as we add the necessary precompiles, like `simulatePolygonBundle` or `buildOptimismBlock` etc. This will mean running many MEVM instances: one for each domain. -2. The "SUAVE chain node" is also a full node. You need to run it in order to _receive information_ about transactions on any domain that broadcasts to the SUAVE chain. You only need to run one of these, as everyone should broadcast their hints on SUAVE. +2. The "Chain instance" is also a full node. You need to run it in order to _receive information_ about transactions on any domain that broadcasts to the SUAVE chain. You only need to run one of these, as everyone should broadcast their hints on SUAVE. ## Docker ### What you need -1. Install Docker. You can find general directions [here](https://docs.docker.com/get-docker/). +1. Install and start Docker. You can find general directions [here](https://docs.docker.com/get-docker/). 1. If you're running Ubuntu or Debian, we recommend [this specific guide](https://docs.docker.com/engine/install/ubuntu/#installation-methods). 2. Make sure you have `docker-compose` installed too. The should just happen when you install Docker. 1. Check with `docker-compose version` (Docker Engine) or `docker compose version` (Docker Desktop). @@ -36,20 +36,43 @@ git clone https://github.com/flashbots/suave-geth.git ``` 2. Get to the right place in the repo: ```bash -cd suave-geth/suave/devenv/ +cd suave-geth/ ``` -3. Run SUAVE: +3. Run SUAVE (depending on your docker setup, you may need to run this as `sudo`): ```bash -docker-compose up -d +make devnet-up +``` + +### Optional testing + +4. If you'd like to test your node by deploying a contract and sending it some transactions, you can do so easily by running: +```bash +go run suave/devenv/cmd/main.go +``` +You should see something like the below printed to your terminal (addresses, txns, and ids will differ): +```bash +suave-geth$ go run suave/devenv/cmd/main.go +Step 0: Create and fund test accounts +- Funded test account: 0x66d5a8D6B34329c0639071275b3d78D29e11EbC6 (100000000) +Step 1: Deploy mev-share contract +- Mev share contract deployed: 0x8f21Fdd6B4f4CacD33151777A46c122797c8BF17 +Step 2: Send bid +- Bid sent at txn: 0xb49debcdead2b306d6ab6282b88fdad7c8d6a33d87df34b79f56d141eae7c08a +- Bid id: 30bbc65298f24e67aaf5c95bf5f0686c +Step 3: Send backrun +- Backrun sent at txn: 0xcf7880e61e94aaab48c60655c321716ecab6edab752586448b0412e93a969889 +- Backrun bid id: db98b83d02694fc2b13c042ad22c233 ``` ### What just happened -Both SUAVE nodes are now running as a daemon process (because of the `-d` flag in the `docker-compose` command). Well done! +Both the MEVM instance and the Chain instance are now running in separate containers, which means your local SUAVE dev environment is ready to go. If you followed through with Step 4 above, you've also deployed a contract in your local environment and sent some transactions to it. -1. Read more about [confidential computation](/reference/confidential-computation) and the [APIs we've built to enable it](/reference/confidential-computation#apis). -2. Dig deeper in the [architecture of the MEVM](/reference/MEVM#architecture). -3. Browse a full list of the [precompiles this gives you access to in any smart contract](/reference/precompiles). +1. Learn more about the contract you deployed and what those transactions are in our [worked examples](/reference/builder-solidity/worked-examples/mev-share). +2. Read more about [confidential computation](/reference/confidential-computation/index) and the [APIs we've built to enable it](/reference/confidential-computation/apis). +3. Dig deeper in the [architecture of the MEVM](/reference/MEVM#architecture). +4. Browse a full list of the [precompiles](/reference/precompiles) this gives you access to in [builder solidity](/reference/builder-solidity/index). +5. If you'd like to examine the Go code responsible for deploying contracts and sending transactions, you can do so [here]. ### Common problems @@ -71,33 +94,6 @@ Both SUAVE nodes are now running as a daemon process (because of the `-d` flag i -
- 2. Using Docker Desktop -
-
- If you're using Docker Desktop, it's likely that you need to use docker compose up -d (without the -). -
-
-
- -
- 3. Older OS won't shut down -
-
-
- Depending on your OS version and the way you installed Docker, you might have issues switching your new MEVM node off again. If so:
- - sudo killall containerd-shim -

- Now you should be able to run:
- - sudo docker-compose down - -
-
-
-
- ## Build it yourself The `docker-compose` version above sets up SUAVE using simple defaults. If you'd like to run the binaries yourself and customise what is happening, read on. @@ -114,14 +110,14 @@ git clone https://github.com/flashbots/suave-geth.git cd suave-geth make suave ``` -2. Run the MEVM node first: +2. Run the MEVM instance first: ```bash ./build/bin/suave --dev --dev.gaslimit 30000000 --datadir suave_dev --http --ws \ --allow-insecure-unlock --unlock "0xb5feafbdd752ad52afb7e1bd2e40432a485bbb7f" \ --keystore ./suave/devenv/suave-ex-node/keystore/ ``` 3. Press `Enter` when prompted for a password -4. In a new terminal, run the SUAVE Chain node: +4. In a new terminal, run the Chain instance: ```bash ./build/bin/suave --dev --dev.gaslimit 30000000 --http --http.port 8555 --ws --ws.port 8556 --authrpc.port 8561 ``` diff --git a/docs/reference/MEVM.mdx b/docs/reference/MEVM.mdx index c5b0c033..1da4ca0d 100644 --- a/docs/reference/MEVM.mdx +++ b/docs/reference/MEVM.mdx @@ -8,9 +8,9 @@ keywords: - go-ethereum --- -# MEVM +import AlignItems from "@site/src/components/AlignItems/AlignItems.tsx" -The MEVM gives anyone the power to program MEV applications in builder solidity: an expressive, familiar, and flexible programming environment for smart contract mechanisms. +# MEVM The MEVM seeks to offer every primitive of the MEV supply chain as a precompile, allowing any centralized MEV infrastructure to be transformed into a smart contract running on SUAVE. @@ -20,13 +20,29 @@ If you'd prefer to learn by running it yourself, please follow [this guide](/how ## Architecture -Our goal is to give you what you need to write more expressive smart contracts and conduct confidential computation, such that you can build any kind of MEV application. +Our goal is to give you what you need to write more expressive [builder solidity](/reference/builder-solidity/index) and conduct [confidential computation](/reference/confidential-computation/index), such that you can build any kind of MEV application. + +If you've read the two links above, you'll know that the basic flow of a transaction on SUAVE looks like this: + + +
+ Fairier Transformers +
+ + +How do we achieve this "Confidential MEVM execution"? -For this part, if you remember the below formula, you're good to go: +At a high level, we have adapted the `eth_sendRawTransaction` RPC method to accept an additional field, called `confidential_data`. Users place signed transactions from other blockchains in this field. They encrypt the field for specific SUAVE node(s), and specify some builder solidity contract on SUAVE, which holds the logic for what to do with their encrypted inputs. -**SuaveExecutionBackend 🤝 EVM = MEVM** +When a SUAVE node receives a `RawTransaction`, it checks whether there are confidential inputs. If there are, we call this a `confidentialComputeRequest` and the MEVM kicks into action. It enters the function being called in the builder solidity contract and, using a `view` function and the `confidentalInputs` [precompile](/reference/precompiles), gets the data it needs about the user's transaction on another blockchain. The MEVM computes some result and stores the relevant data locally, in its `confidentialDataStore`. This does not permute state, as we're only using a `view` function fetch data and then doing the computation locally, in the MEVM. -Here is a visual overview of what the above actually looks like: +Computation complete, the MEVM places what we call the `confidentialComputeResult` in the original `RawTransaction` it received, which it then propagates to the public mempool. The `confidentialComputeResult` is really a callback to another function, which does permute state and often emits some kind of event, the logs of which hold data required by others parties without revealing the original inputs. We encourage you to read about [mev-share on SUAVE](/reference/builder-solidity/worked-examples/mev-share) for a practical example. + +For now, it is good enough that you understand that all our adaptations to the EVM serve the goal of confidential computation, as outlined above. These changes can be summed up in a very simple formula: + +> **SuaveExecutionBackend + EVM = MEVM** + +Here is a visual overview of what that actually means in practice: ```mermaid graph TB @@ -59,35 +75,38 @@ graph TB classDef lightgreen fill:#b3c69f,stroke:#444,stroke-width:2px, color:#333; ``` -What do you get from the **SuaveExecutionBackend** that we've married to the EVM through the new runtime? In a nutshell: [3 new API endpoints](/reference/confidential-computation#apis): +In words: the EVM is made up of a whole bunch of different parts. THose numbered `1` through `7` exist in the vanilla EVM we all know and love. Parts `8` through `13` are what we have added (or adapted in the case of the `interpreter`) in order to enable confidential computation. + +What do you get from the [SuaveExecutionBackend](https://github.com/flashbots/suave-geth/blob/main/core/vm/suave.go) that we've married to the EVM through the new runtime? In a nutshell: [3 new API endpoints](/reference/confidential-computation/apis): ```go func NewRuntimeSuaveExecutionBackend(evm *EVM, caller common.Address) *SuaveExecutionBackend { - if !evm.Config.IsOffchain { + if !evm.Config.IsConfidential { return nil } return &SuaveExecutionBackend{ ConfidentialStoreBackend: evm.suaveExecutionBackend.ConfidentialStoreBackend, MempoolBackend: evm.suaveExecutionBackend.MempoolBackend, - OffchainEthBackend: evm.suaveExecutionBackend.OffchainEthBackend, + ConfidentialEthBackend: evm.suaveExecutionBackend.ConfidentialEthBackend, confidentialInputs: evm.suaveExecutionBackend.confidentialInputs, callerStack: append(evm.suaveExecutionBackend.callerStack, &caller), } } ``` -Each of these new APIs - `ConfidentialStoreBackend`, `MempoolBackend`, `OffchainEthBackend` - are available in [builder solidity](/reference/builder-solidity) through the use of [precompiles](/reference/precompiles). The precompiles also make use of `callerStack` to specify whether there is confidential computation required, and `confidentialInputs` to specify the inputs to that computation if it is required. +Each of these new APIs - `ConfidentialStoreBackend`, `MempoolBackend`, `ConfidentialEthBackend` - are available in [builder solidity](/reference/builder-solidity/index) through the use of [precompiles](/reference/precompiles). The precompiles also make use of `confidentialInputs` to specify the data relevant to confidential computation, and `callerStack` enables transaction tracing. ## Notable differences from go-ethereum ### Changes to RPC methods -1. New `IsOffchain` and `ExecutionNode` fields have been added to TransactionArgs, used in `eth_sendTransaction` and `eth_call` methods. - - If `IsOffchain` is set to true, the call will be performed confidentially, using the `ExecutionNode` passed in for constructing `OffchainTx`. +1. New `IsConfidential` and `ExecutionNode` fields are added to the TransactionArgs used in `eth_sendTransaction` and `eth_call` methods. + - If `IsConfidential` is set to true, the call will be performed as a confidential call, using the SUAVE node passed in for constructing `ConfidentialComputeRequest`. + - `SuaveTransaction` is the result of `eth_sendTransaction`. -2. New, optional `confidential_data` argument has been added to `eth_sendRawTransaction`, `eth_sendTransaction` and `eth_call` methods. - - The confidential data is made available to the EVM in the confidential mode via a precompile, but does not become a part of the eventual on-chain transaction. This enables confidential computation (like simulating a bundle, putting the data into confidential store). +2. New optional argument - `confidential_data` is added to `eth_sendRawTransaction`, `eth_sendTransaction` and `eth_call` methods. + - The confidential data is made available to the EVM in the confidential mode via a precompile, but does not become a part of the transaction that makes it to chain. This allows performing computation based on confidential data (like simulating a bundle, or putting the data into confidential store). ### SuavePrecompiledContract @@ -96,15 +115,15 @@ We introduce a new interface [SuavePrecompiledContract](https://github.com/flash ```go type SuavePrecompiledContract interface { PrecompiledContract - RunOffchain(backend *SuaveExecutionBackend, input []byte) ([]byte, error) + RunConfidential(backend *SuaveExecutionBackend, input []byte) ([]byte, error) } ``` -The method `RunOffchain` is invoked during confidential execution, and the `SuaveExecutionBackend` which provides access to confidential compute APIs is passed in as input. +The method `RunConfidential` is invoked during confidential execution, and the suave execution backend which provides access to confidential APIs is passed in as input. -### SuavePrecompiledContractWrapper +### SUAVE Precompile Wrapper -We introduce [SuavePrecompiledContractWrapper](https://github.com/flashbots/suave-geth/blob/main/core/vm/suave.go) implementing the `PrecompiledContract` interface. The new structure captures the confidential compute APIs in its constructor, and passes the confidential compute APIs during the usual contract's `Run` method to a separate method: `RunOffchain`. +We introduce [SuavePrecompiledContractWrapper](https://github.com/flashbots/suave-geth/blob/main/core/vm/suave.go) implementing the `PrecompiledContract` interface. The new structure captures the confidential APIs in its constructor, and passes the confidential APIs during the usual contract's `Run` method to a separate method - `RunConfidential`. ### SuaveExecutionBackend @@ -118,9 +137,9 @@ We introduce [SuaveExecutionBackend](https://github.com/flashbots/suave-geth/blo The [EVM interpreter](https://github.com/flashbots/suave-geth/blob/main/core/vm/interpreter.go) is modified to enable confidential computation: -1. We introduce `IsOffchain` to the interpreter's config -2. We modify the `Run` function to accept off-chain APIs `func (in *EVMInterpreter) Run(*SuaveExecutionBackend, *Contract, []byte, bool) ([]byte, err)` -3. We modify the `Run` function to trace the caller stack +* We introduce `IsConfidential` to the interpreter's config +* We modify the `Run` function to accept confidential APIs `func (in *EVMInterpreter) Run(*SuaveExecutionBackend, *Contract, []byte, bool) ([]byte, err)` +* We modify the `Run` function to trace the caller stack Like `eth_sendTransaction`, this method accepts an additional, optional confidential inputs argument. diff --git a/docs/reference/builder-solidity.mdx b/docs/reference/builder-solidity.mdx deleted file mode 100644 index b137cf79..00000000 --- a/docs/reference/builder-solidity.mdx +++ /dev/null @@ -1,46 +0,0 @@ ---- -title: Builder Solidity -description: Do more with solidity on SUAVE -keywords: - - reference - - suave - - builder - - solidity ---- - -import Video from "@site/src/components/Video/Video.tsx"; -import AlignItems from "@site/src/components/AlignItems/AlignItems.tsx"; - -# Builer solidity - -Builder solidity is solidity with some additional precompiles intended to support MEV applications. Using these precompiles, builder solidity contracts can define how MEVM nodes run computation, without that computation being done on chain. That is, MEVM nodes can accept encrypted data from users, do stuff with it privately and only reveal the results, not the inputs. - -## Why is this cool? - -Builders have no incentive to share the algorithms by which they currently build blocks, so it is hard for searchers to know whether their bundles will be built in the order they submit them, or manipulated. This means that searchers are more likely to send their bundles to the few builders they trust, or only those who consistently build winning blocks (in order to avoid leaking alpha to everyone). This results in block builder centralization over time. - -Builders can now use builder solidity to create contracts that specify exactly how they will order bundles (and transactions) sent to them. However, those bundles can be kept confidential: encrypted to the MEVM node that the builder in question runs. This way, builders can receive bundles and order them in a verifiable and public manner, without ever revealing sensitive transaction data. - -Builder solidity is for all kinds of builders though, not just block builders. Builder solidity contracts are a _uniform programming model for implementing every component of the transaction supply chain_, such that we can ensure that any value created is distributed fairly. - -This is what makes SUAVE an **open and contestable marketplace for mechanisms**, because Flashbots doesn't have to design the perfect auction structures or fair ordering schemes; smart contract designers can do so and compete with each other. As a starting point, we aim would to replicate everything that's in the ecosystem today. - - -
- Fairier Transformers -
- - -The result should be an open marketplace for mechanisms which compete for orderflow, and do so by virtue of the guarantees their contracts make about how they will order transaction data sent to them. - -This enables us to combine the collective verifiability we expect from public blockchains with the individual privacy we need in order to protect users, defend against malicious MEV, and create provably fair systems which are resilient to economic centralization pressures across time. - -## Further context - -We recommend this early research talk from Andrew Miller to get a sense of the ideas from which builder solidity has grown. - -Please note that the pseudo code he shows is now outdated and you are better off looking directly at our [list of available precompiles](/reference/precompiles), but the framework he uses in this talk and the background he provides should still prove very useful when writing your own builder solidity contracts. - -