• Intro
• Prerequisites 🛠
• Walkthrough Overview 🚀
  • 1. Deploy Simple MEV-Share Contract 📜
  • 2. Deploy Block Builder Contract 📜
  • 3. Send Mevshare Bundles 📨
  • 4. Send Mevshare Matches 🎯
  • 5. Build Block and Relay 🧱
• Conclusion 🎓

Intro

The MEVM, an adaptation of the EVM, is tailored with specialized precompiles to support MEV use cases, allowing developers to craft MEV applications as smart contracts within an environment akin to the conventional EVM. As a cornerstone of the SUAVE chain, the MEVM not only significantly reduces barriers to devising new MEV applications, but also facilitates the transformation of centralized infrastructures into decentralized blockchain-based smart contracts.

To get a better understanding of how the MEVM works, let's delve into the deployment of a simple version of mev-share, a protocol for orderflow auctions, defined via smart contract on SUAVE. Our journey below will guide you through the steps of deploying simple mev-share and block builder contracts, interacting with them, and ultimately seeing a block land onchain.

Prerequisites 🛠

This walkthrough will be based on a script located inside the suave cli tool so don't worry about copying over all of the code. To follow along and use the tool you will need:

• SUAVE node and SUAVE execution node setup.
• Basic knowledge of the Ethereum's Golang libraries and the Ethereum RPC methods.

Ensure these details are on hand:

• suave_rpc : address of suave rpc
• goerli_rpc : address of goerli execution node rpc
• goerli_beacon_rpc : address of goerli beacon rpc
• ex_node_addr : wallet address of execution node
• privKeyHex : private key as hex (for testing)
• relay_url : address of boost relay that the contract will send blocks to

Walkthrough Overview 🚀

This walkthrough will go over the process of :

1. deploying the simple mev-share auction as a contract
2. deploying a mev-share compatible block builder contract
3. sending a transction to mev-share
4. sending a backrun transction to mev-share
5. build block and send to relay

1. Deploy Simple MEV-Share Contract 📜

Our first step is to deploy the compiled byte code from our mev-share contract. As you will see, deploying on SUAVE feels just like deploying on any other EVM chain. First we gather our transaction details, nounce and gas price, sign the transaction, and then send using the normal eth_sendRawTransaction using your suaveClient

	mevShareAddrPtr, txHash, err := sendMevShareCreationTx(suaveClient, suaveSigner, privKey)
	if err != nil {
		panic(err.Error())
	}

	waitForTransactionToBeConfirmed(suaveClient, txHash)
	mevShareAddr := *mevShareAddrPtr

Now we take a look under the hood of sendMevShareCreationTx.

func sendMevShareCreationTx(suaveClient *rpc.Client, suaveSigner types.Signer, privKey *ecdsa.PrivateKey) (*common.Address, *common.Hash, error) {
	var suaveAccNonceBytes hexutil.Uint64
	err := suaveClient.Call(
            &suaveAccNonceBytes,
            "eth_getTransactionCount",
            crypto.PubkeyToAddress(privKey.PublicKey),
            "latest"
        )
	suaveAccNonce := uint64(suaveAccNonceBytes)

	var suaveGp hexutil.Big
	err = suaveClient.Call(&suaveGp, "eth_gasPrice")

	calldata := hexutil.MustDecode(mevshareContractBytecode)
	mevshareContractBytecode)
	ccTxData := &types.LegacyTx{
		Nonce:    suaveAccNonce,
		To:       nil, // contract creation
		Value:    big.NewInt(0),
		Gas:      10000000,
		GasPrice: (*big.Int)(&suaveGp),
		Data:     calldata,
	}

	tx, err := types.SignTx(types.NewTx(ccTxData), suaveSigner, privKey)

	from, _ := types.Sender(suaveSigner, tx)
	mevshareAddr := crypto.CreateAddress(from, tx.Nonce())
	log.Info("contract address will be", "addr", mevshareAddr)

	txBytes, err := tx.MarshalBinary()

	var txHash common.Hash
	err = suaveClient.Call(
            &txHash,
            "eth_sendRawTransaction",
            hexutil.Encode(txBytes)
        )

	return &mevshareAddr, &txHash, nil
}

Later, we'll incorporate the mevshareAddr into our transaction's allowed contracts, granting access for the contract to compute over our confidential data.

2. Deploy Block Builder Contract 📜

Next we deploy a simple block builder contract which we will also store to later grant access to. The block builder takes in a boostRelayUrl which is where it will send blocks to when finished building.

	blockSenderAddrPtr, txHash, err := sendBlockSenderCreationTx(
            suaveClient,
            suaveSigner,
            privKey,
            boostRelayUrl
    )
	if err != nil {
		panic(err.Error())
	}

	waitForTransactionToBeConfirmed(suaveClient, txHash)
	blockSenderAddr := *blockSenderAddrPtr

Similar as above, sendBlockSenderCreationTx operates like any other contract deployment on an EVM chain.

3. Send Mevshare Bundles 📨

Once our contracts have been succesfully deployed we will craft a goerli bundle and send it to our newly deployed mev-share contract.

	mevShareTx, err := sendMevShareBidTx(suaveClient, goerliClient, suaveSigner, goerliSigner, 5, mevShareAddr, blockSenderAddr, executionNodeAddress, privKey)
	if err != nil {
		err = errors.Wrap(err, unwrapPeekerError(err).Error())
		panic(err.Error())
	}

	waitForTransactionToBeConfirmed(suaveClient, &mevShareTx.txHash)

Let's take a deeper look at sendMevShareBidTx which looks similar to a normal Ethereum transaction but has a couple key differences. We explore those below the following code snippet.

func sendMevShareBidTx(
    // function inputs removed for brevity
) (mevShareBidData, error) {

	var startingGoerliBlockNum uint64
	err = goerliClient.Call(
            (*hexutil.Uint64)(&startingGoerliBlockNum),
            "eth_blockNumber"
        )
	if err != nil {
		utils.Fatalf("could not get goerli block: %v", err)
	}

	_, ethBundleBytes, err := prepareEthBundle(
            goerliClient,
            goerliSigner,
            privKey
        )

	// Prepare bundle bid
	var suaveAccNonce hexutil.Uint64
	err = suaveClient.Call(
            &suaveAccNonce,
            "eth_getTransactionCount",
            crypto.PubkeyToAddress(privKey.PublicKey),
            "pending"
        )

	confidentialDataBytes, err := mevShareABI.Methods["fetchBidConfidentialBundleData"].Outputs.Pack(ethBundleBytes)

	allowedPeekers := []common.Address{
            newBlockBidAddress,
            extractHintAddress,
            buildEthBlockAddress,
            mevShareAddr,
            blockBuilderAddr
        }

	calldata, err := mevShareABI.Pack("newBid", blockNum, allowedPeekers)
	if err != nil {
		return mevShareBidData{}, err
	}
        
        wrappedTxData := &types.DynamicFeeTx{
		Nonce:     suaveAccNonce,
		To:        &mevShareAddr,
		Value:     nil,
		Gas:       10000000,
		GasTipCap: big.NewInt(10),
		GasFeeCap: big.NewInt(33000000000),
		Data:      calldata,
	}

	mevShareTx, err := types.SignTx(types.NewTx(&types.OffchainTx{
		ExecutionNode: executionNodeAddr,
		Wrapped:       *types.NewTx(wrappedTxData),
	}), suaveSigner, privKey)
	if err != nil {
		return nil, nil, err
	}

	mevShareTxBytes, err := mevShareTx.MarshalBinary()
	if err != nil {
		return nil, nil, err
	}

	var offchainTxHash common.Hash
	err = suaveClient.Call(
            &offchainTxHash,
            "eth_sendRawTransaction",
            hexutil.Encode(mevShareTxBytes),
            hexutil.Encode(confidentialDataBytes)
        )
	if err != nil {
		return mevShareBidData{}, err
	}

	mevShareTxHash= mevShareBidData{blockNumber: blockNum, txHash: offchainTxHash}

	return mevShareTxHash, nil
}

A SUAVE transaction, referred to as a mevshare bid in the code, takes in two extra arguments: allowedPeekers and executionNodeAddr. These arguement are to utilize a new transaction primitive types.OffchainTx, which you can read more about here. The role of allowedPeekers is to dictate which contracts can view the confidential data, in our scenario, the goerli bundle being submitted. Meanwhile, executionNodeAddr points to the intended execution node for the transaction. Lastly, Suave nodes have a modified ethSendRawTransaction to support this new transaction type.

4. Send Mevshare Matches 🎯

Now that a MEV-share bid has been sent in we can simulate sending in a match. Once live on a testnet, searchers can monitor the SUAVE chain looking for hints emitted as logs for protocols they specialize in. In our example you could monitor the mevShareAddr for emitted events. Using these hints they can get a BidId to reference in their match. Below we see the code.

    bidIdBytes, err := extractBidId(suaveClient, mevShareTx.txHash)
    if err != nil {
        panic(err.Error())
    }

    _, err = sendMevShareMatchTx(
        suaveClient,
        goerliClient,
        suaveSigner,
        goerliSigner,
        mevShareTx.blockNumber,
        mevShareAddr,
        blockSenderAddr,
        executionNodeAddress,
        bidIdBytes,
        privKey,
    )
    if err != nil {
        err = errors.Wrap(err, unwrapPeekerError(err).Error())
        panic(err.Error())
    }

5. Build Block and Relay 🧱

Now that our SUAVE node's bidpool has a mevshare bid and match, we can trigger block building to combine these transactions, simulate for validity, and insert the refund transaction.

    _, err = sendBuildShareBlockTx(suaveClient, suaveSigner, privKey, executionNodeAddress, blockSenderAddr, payloadArgsTuple, uint64(goerliBlockNum)+1)
    if err != nil {
        err = errors.Wrap(err, unwrapPeekerError(err).Error())
        if strings.Contains(err.Error(), "no bids") {
            log.Error("Failed to build a block, no bids")
        }
        log.Error("Failed to send BuildShareBlockTx", "err", err)
    }

Once the execution node has received this transaciton it will build your block and send it off to a relay. If you used the flashbots goerli relay you should be able to check it out using the builder blocks received endpoint.

Conclusion 🎓

This walkthrough has gone through how to deploy MEV-Share and block builder contracts, send in a basic MEV-Share bid and match, and trigger building a block and sending to a relay, all in golang!

For further elucidation, the SUAVE repository has a wealth of information, and we will continue to be releasing new walkthroughs and tutorials.