New payment tx (ethereum#40)

* Rework payment tx

* move env access from worker

* add builder.dry-run

* Move proposer tx from fillTransactions

* Use one flag for validation blocklist

builder/builder.go

@@ -3,6 +3,7 @@ package builder
 import (
  "context"
  "errors"
+ blockvalidation "github.com/ethereum/go-ethereum/eth/block-validation"
  "golang.org/x/time/rate"
  "math/big"
  _ "os"
@@ -49,6 +50,8 @@ type Builder struct {
  ds flashbotsextra.IDatabaseService
  relay IRelay
  eth IEthereumService
+ dryRun bool
+ validator *blockvalidation.BlockValidationAPI
  builderSecretKey *bls.SecretKey
  builderPublicKey boostTypes.PublicKey
  builderSigningDomain boostTypes.Domain
@@ -62,7 +65,7 @@ type Builder struct {
  slotCtxCancel context.CancelFunc
 }
 
-func NewBuilder(sk *bls.SecretKey, ds flashbotsextra.IDatabaseService, relay IRelay, builderSigningDomain boostTypes.Domain, eth IEthereumService) *Builder {
+func NewBuilder(sk *bls.SecretKey, ds flashbotsextra.IDatabaseService, relay IRelay, builderSigningDomain boostTypes.Domain, eth IEthereumService, dryRun bool, validator *blockvalidation.BlockValidationAPI) *Builder {
  pkBytes := bls.PublicKeyFromSecretKey(sk).Compress()
  pk := boostTypes.PublicKey{}
  pk.FromSlice(pkBytes)
@@ -72,6 +75,8 @@ func NewBuilder(sk *bls.SecretKey, ds flashbotsextra.IDatabaseService, relay IRe
  ds: ds,
  relay: relay,
  eth: eth,
+ dryRun: dryRun,
+ validator: validator,
  builderSecretKey: sk,
  builderPublicKey: pk,
  builderSigningDomain: builderSigningDomain,
@@ -118,8 +123,6 @@ func (b *Builder) onSealedBlock(block *types.Block, bundles []types.SimulatedBun
  Value: *value,
  }
 
- go b.ds.ConsumeBuiltBlock(block, bundles, &blockBidMsg)
-
  signature, err := boostTypes.SignMessage(&blockBidMsg, b.builderSigningDomain, b.builderSecretKey)
  if err != nil {
  log.Error("could not sign builder bid", "err", err)
@@ -132,10 +135,18 @@ func (b *Builder) onSealedBlock(block *types.Block, bundles []types.SimulatedBun
  ExecutionPayload: payload,
  }
 
- err = b.relay.SubmitBlock(&blockSubmitReq)
- if err != nil {
- log.Error("could not submit block", "err", err, "bundles", len(bundles))
- return err
+ if b.dryRun {
+ err = b.validator.ValidateBuilderSubmissionV1(&blockSubmitReq)
+ if err != nil {
+ log.Error("could not validate block", "err", err)
+ }
+ } else {
+ go b.ds.ConsumeBuiltBlock(block, bundles, &blockBidMsg)
+ err = b.relay.SubmitBlock(&blockSubmitReq)
+ if err != nil {
+ log.Error("could not submit block", "err", err, "bundles", len(bundles))
+ return err
+ }
  }
 
  log.Info("submitted block", "slot", blockBidMsg.Slot, "value", blockBidMsg.Value.String(), "parent", blockBidMsg.ParentHash, "hash", block.Hash(), "bundles", len(bundles))

builder/builder_test.go

@@ -75,7 +75,7 @@ func TestOnPayloadAttributes(t *testing.T) {
 
  testEthService := &testEthereumService{synced: true, testExecutableData: testExecutableData, testBlock: testBlock}
 
- builder := NewBuilder(sk, flashbotsextra.NilDbService{}, &testRelay, bDomain, testEthService)
+ builder := NewBuilder(sk, flashbotsextra.NilDbService{}, &testRelay, bDomain, testEthService, false, nil)
  builder.Start()
  defer builder.Stop()
 

builder/local_relay_test.go

@@ -31,7 +31,7 @@ func newTestBackend(t *testing.T, forkchoiceData *beacon.ExecutableDataV1, block
  beaconClient := &testBeaconClient{validator: validator}
  localRelay := NewLocalRelay(sk, beaconClient, bDomain, cDomain, ForkData{}, true)
  ethService := &testEthereumService{synced: true, testExecutableData: forkchoiceData, testBlock: block}
- backend := NewBuilder(sk, flashbotsextra.NilDbService{}, localRelay, bDomain, ethService)
+ backend := NewBuilder(sk, flashbotsextra.NilDbService{}, localRelay, bDomain, ethService, false, nil)
  // service := NewService("127.0.0.1:31545", backend)
 
  backend.limiter = rate.NewLimiter(rate.Inf, 0)

builder/service.go

@@ -3,6 +3,7 @@ package builder
 import (
  "errors"
  "fmt"
+ blockvalidation "github.com/ethereum/go-ethereum/eth/block-validation"
  "net/http"
  "os"
 
@@ -106,6 +107,7 @@ type BuilderConfig struct {
  Enabled bool
  EnableValidatorChecks bool
  EnableLocalRelay bool
+ DryRun bool
  BuilderSecretKey string
  RelaySecretKey string
  ListenAddr string
@@ -114,6 +116,7 @@ type BuilderConfig struct {
  GenesisValidatorsRoot string
  BeaconEndpoint string
  RemoteRelayEndpoint string
+ ValidationBlocklist string
 }
 
 func Register(stack *node.Node, backend *eth.Ethereum, cfg *BuilderConfig) error {
@@ -172,6 +175,18 @@ func Register(stack *node.Node, backend *eth.Ethereum, cfg *BuilderConfig) error
  return errors.New("neither local nor remote relay specified")
  }
 
+ var validator *blockvalidation.BlockValidationAPI
+ if cfg.DryRun {
+ var accessVerifier *blockvalidation.AccessVerifier
+ if cfg.ValidationBlocklist != "" {
+ accessVerifier, err = blockvalidation.NewAccessVerifierFromFile(cfg.ValidationBlocklist)
+ if err != nil {
+ return fmt.Errorf("failed to load validation blocklist %w", err)
+ }
+ }
+ validator = blockvalidation.NewBlockValidationAPI(backend, accessVerifier)
+ }
+
  // TODO: move to proper flags
  var ds flashbotsextra.IDatabaseService
  dbDSN := os.Getenv("FLASHBOTS_POSTGRES_DSN")
@@ -193,7 +208,7 @@ func Register(stack *node.Node, backend *eth.Ethereum, cfg *BuilderConfig) error
  go bundleFetcher.Run()
 
  ethereumService := NewEthereumService(backend)
- builderBackend := NewBuilder(builderSk, ds, relay, builderSigningDomain, ethereumService)
+ builderBackend := NewBuilder(builderSk, ds, relay, builderSigningDomain, ethereumService, cfg.DryRun, validator)
  builderService := NewService(cfg.ListenAddr, localRelay, builderBackend)
 
  stack.RegisterAPIs([]rpc.API{

cmd/geth/config.go

@@ -168,7 +168,7 @@ func makeFullNode(ctx *cli.Context) (*node.Node, ethapi.Backend) {
  // Configure log filter RPC API.
  filterSystem := utils.RegisterFilterAPI(stack, backend, &cfg.Eth)
 
- if err := blockvalidationapi.Register(stack, eth, ctx); err != nil {
+ if err := blockvalidationapi.Register(stack, eth, ctx.String(utils.BuilderBlockValidationBlacklistSourceFilePath.Name)); err != nil {
  utils.Fatalf("Failed to register the Block Validation API: %v", err)
  }
 

cmd/geth/main.go

@@ -158,6 +158,7 @@ var (
  utils.BuilderEnabled,
  utils.BuilderEnableValidatorChecks,
  utils.BuilderEnableLocalRelay,
+ utils.BuilderDryRun,
  utils.BuilderSecretKey,
  utils.BuilderRelaySecretKey,
  utils.BuilderListenAddr,

cmd/utils/flags.go

@@ -697,6 +697,10 @@ var (
  Name: "builder.local_relay",
  Usage: "Enable the local relay",
  }
+ BuilderDryRun = &cli.BoolFlag{
+ Name: "builder.dry-run",
+ Usage: "Builder only validates blocks without submission to the relay",
+ }
  BuilderSecretKey = &cli.StringFlag{
  Name: "builder.secret_key",
  Usage: "Builder key used for signing blocks",
@@ -1076,8 +1080,8 @@ Please note that --` + MetricsHTTPFlag.Name + ` must be set to start the server.
  // Builder API flags
  BuilderBlockValidationBlacklistSourceFilePath = &cli.StringFlag{
  Name: "builder.validation_blacklist",
- Usage: "Path to file containing blacklisted addresses, json-encoded list of strings. Default assumes CWD is repo's root",
- Value: "ofac_blacklist.json",
+ Usage: "Path to file containing blacklisted addresses, json-encoded list of strings. Default assumes no blacklist",
+ Value: "",
  Category: flags.EthCategory,
  }
 )

eth/block-validation/api.go

@@ -7,7 +7,6 @@ import (
  "math/big"
  "os"
 
- "github.com/ethereum/go-ethereum/cmd/utils"
  "github.com/ethereum/go-ethereum/common"
  "github.com/ethereum/go-ethereum/core/beacon"
  "github.com/ethereum/go-ethereum/core/types"
@@ -17,8 +16,6 @@ import (
  "github.com/ethereum/go-ethereum/log"
  "github.com/ethereum/go-ethereum/node"
  "github.com/ethereum/go-ethereum/rpc"
- "github.com/urfave/cli/v2"
-
  boostTypes "github.com/flashbots/go-boost-utils/types"
 )
 
@@ -81,11 +78,11 @@ func NewAccessVerifierFromFile(path string) (*AccessVerifier, error) {
 }
 
 // Register adds catalyst APIs to the full node.
-func Register(stack *node.Node, backend *eth.Ethereum, ctx *cli.Context) error {
+func Register(stack *node.Node, backend *eth.Ethereum, blockValidationBlocklistFile string) error {
  var accessVerifier *AccessVerifier
- if ctx.IsSet(utils.BuilderBlockValidationBlacklistSourceFilePath.Name) {
+ if blockValidationBlocklistFile != "" {
  var err error
- accessVerifier, err = NewAccessVerifierFromFile(ctx.String(utils.BuilderBlockValidationBlacklistSourceFilePath.Name))
+ accessVerifier, err = NewAccessVerifierFromFile(blockValidationBlocklistFile)
  if err != nil {
  return err
  }

eth/block-validation/api_test.go

@@ -101,7 +101,7 @@ func TestValidateBuilderSubmissionV1(t *testing.T) {
  }
  blockRequest.Message.Value = boostTypes.IntToU256(190526394825529)
  require.ErrorContains(t, api.ValidateBuilderSubmissionV1(blockRequest), "inaccurate payment")
- blockRequest.Message.Value = boostTypes.IntToU256(190215802060530)
+ blockRequest.Message.Value = boostTypes.IntToU256(190526394825530)
  require.NoError(t, api.ValidateBuilderSubmissionV1(blockRequest))
 
  // TODO: test with contract calling blacklisted address
@@ -142,7 +142,7 @@ func TestValidateBuilderSubmissionV1(t *testing.T) {
  invalidPayload.LogsBloom = boostTypes.Bloom{}
  copy(invalidPayload.ReceiptsRoot[:], hexutil.MustDecode("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")[:32])
  blockRequest.ExecutionPayload = invalidPayload
- copy(blockRequest.Message.BlockHash[:], hexutil.MustDecode("0x65cded68b85277f489f22497731d8cece9e42f0429a250a5022a9417408f3998")[:32])
+ copy(blockRequest.Message.BlockHash[:], hexutil.MustDecode("0x272872d14b2a8a0454e747ed472d82d8d5ce342cfafd65fa7b77aa6de1c061d4")[:32])
  require.ErrorContains(t, api.ValidateBuilderSubmissionV1(blockRequest), "could not apply tx 3", "insufficient funds for gas * price + value")
 }
 

miner/algo_common.go

@@ -1,7 +1,9 @@
 package miner
 
 import (
+ "crypto/ecdsa"
  "errors"
+ "fmt"
  "math/big"
  "sync/atomic"
 
@@ -20,6 +22,8 @@ const (
  popTx = 2
 )
 
+var emptyCodeHash = common.HexToHash("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470")
+
 var errInterrupt = errors.New("miner worker interrupted")
 
 type environmentDiff struct {
@@ -263,3 +267,111 @@ func (envDiff *environmentDiff) commitBundle(bundle *types.SimulatedBundle, chDa
  *envDiff = *tmpEnvDiff
  return nil
 }
+
+func estimatePayoutTxGas(env *environment, sender, receiver common.Address, prv *ecdsa.PrivateKey, chData chainData) (uint64, bool, error) {
+ if codeHash := env.state.GetCodeHash(receiver); codeHash == (common.Hash{}) || codeHash == emptyCodeHash {
+ return params.TxGas, true, nil
+ }
+ gasLimit := env.gasPool.Gas()
+
+ balance := new(big.Int).SetBytes([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF})
+ value := new(big.Int).SetBytes([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF})
+
+ diff := newEnvironmentDiff(env)
+ diff.state.SetBalance(sender, balance)
+ receipt, err := diff.commitPayoutTx(value, sender, receiver, gasLimit, prv, chData)
+ if err != nil {
+ return 0, false, err
+ }
+ return receipt.GasUsed, false, nil
+}
+
+func insertPayoutTx(env *environment, sender, receiver common.Address, gas uint64, isEOA bool, availableFunds *big.Int, prv *ecdsa.PrivateKey, chData chainData) (*types.Receipt, error) {
+ diff := newEnvironmentDiff(env)
+ applyTx := func(gas uint64) (*types.Receipt, error) {
+ fee := new(big.Int).Mul(env.header.BaseFee, new(big.Int).SetUint64(gas))
+ amount := new(big.Int).Sub(availableFunds, fee)
+ if amount.Sign() < 0 {
+ return nil, errors.New("not enough funds available")
+ }
+ rec, err := diff.commitPayoutTx(amount, sender, receiver, gas, prv, chData)
+ if err != nil {
+ return nil, fmt.Errorf("failed to commit payment tx: %w", err)
+ }
+ if rec.Status != types.ReceiptStatusSuccessful {
+ return nil, fmt.Errorf("payment tx failed")
+ }
+ return rec, nil
+ }
+
+ if isEOA {
+ rec, err := applyTx(gas)
+ if err != nil {
+ return nil, err
+ }
+ diff.applyToBaseEnv()
+ return rec, nil
+ }
+
+ var (
+ rec *types.Receipt
+ err error
+ )
+ for i := 0; i < 6; i++ {
+ rec, err = applyTx(gas)
+ if err != nil {
+ gas += 1000
+ } else {
+ break
+ }
+ }
+
+ if err != nil {
+ return nil, err
+ }
+ diff.applyToBaseEnv()
+ return rec, nil
+}
+
+func (envDiff *environmentDiff) commitPayoutTx(amount *big.Int, sender, receiver common.Address, gas uint64, prv *ecdsa.PrivateKey, chData chainData) (*types.Receipt, error) {
+ senderBalance := envDiff.state.GetBalance(sender)
+
+ if gas < params.TxGas {
+ return nil, errors.New("not enough gas for intrinsic gas cost")
+ }
+
+ requiredBalance := new(big.Int).Mul(envDiff.header.BaseFee, new(big.Int).SetUint64(gas))
+ requiredBalance = requiredBalance.Add(requiredBalance, amount)
+ if requiredBalance.Cmp(senderBalance) > 0 {
+ return nil, errors.New("not enough balance")
+ }
+
+ signer := envDiff.baseEnvironment.signer
+ tx, err := types.SignNewTx(prv, signer, &types.DynamicFeeTx{
+ ChainID: chData.chainConfig.ChainID,
+ Nonce: envDiff.state.GetNonce(sender),
+ GasTipCap: new(big.Int),
+ GasFeeCap: envDiff.header.BaseFee,
+ Gas: gas,
+ To: &receiver,
+ Value: amount,
+ })
+ if err != nil {
+ return nil, err
+ }
+
+ txSender, err := signer.Sender(tx)
+ if err != nil {
+ return nil, err
+ }
+ if txSender != sender {
+ return nil, errors.New("incorrect sender private key")
+ }
+
+ receipt, _, err := envDiff.commitTx(tx, chData)
+ if err != nil {
+ return nil, err
+ }
+
+ return receipt, nil
+}