predicate results: alternate approach (similar to master)

core/evm.go

@@ -104,7 +104,7 @@ type ChainContext interface {
 
 // NewEVMBlockContext creates a new context for use in the EVM.
 func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common.Address) vm.BlockContext {
-	predicateBytes := predicate.GetPredicateResultBytes(header.Extra)
+	predicateBytes := params.GetPredicateResultBytes(header.Extra)
 	if len(predicateBytes) == 0 {
 		return newEVMBlockContext(header, chain, author, nil)
 	}
@@ -129,7 +129,7 @@ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common
 func NewEVMBlockContextWithPredicateResults(header *types.Header, chain ChainContext, author *common.Address, predicateBytes []byte) vm.BlockContext {
 	extra := bytes.Clone(header.Extra)
 	if len(predicateBytes) > 0 {
-		extra = predicate.SetPredicateResultBytes(extra, predicateBytes)
+		extra = params.SetPredicateResultBytes(extra, predicateBytes)
 	}
 	return newEVMBlockContext(header, chain, author, extra)
 }

core/extstate/statedb.go

@@ -31,7 +31,8 @@ type StateDB struct {
 }
 
 func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dst *common.Address, precompiles []common.Address, list types.AccessList) {
-	s.predicateStorageSlots = predicate.PreparePredicateStorageSlots(rules, list)
+	rulesExtra := params.GetRulesExtra(rules)
+	s.predicateStorageSlots = predicate.PreparePredicateStorageSlots(rulesExtra, list)
 	s.VmStateDB.Prepare(rules, sender, coinbase, dst, precompiles, list)
 }
 

core/predicate_check.go

@@ -30,14 +30,15 @@ func CheckPredicates(rules params.Rules, predicateContext *precompileconfig.Pred
 		return nil, fmt.Errorf("%w for predicate verification (%d) < intrinsic gas (%d)", ErrIntrinsicGas, tx.Gas(), intrinsicGas)
 	}
 
+	rulesExtra := params.GetRulesExtra(rules)
 	predicateResults := make(map[common.Address][]byte)
 	// Short circuit early if there are no precompile predicates to verify
-	if !params.GetRulesExtra(rules).PredicatersExist() {
+	if !rulesExtra.PredicatersExist() {
 		return predicateResults, nil
 	}
 
 	// Prepare the predicate storage slots from the transaction's access list
-	predicateArguments := predicate.PreparePredicateStorageSlots(rules, tx.AccessList())
+	predicateArguments := predicate.PreparePredicateStorageSlots(rulesExtra, tx.AccessList())
 
 	// If there are no predicates to verify, return early and skip requiring the proposervm block
 	// context to be populated.

eth/tracers/api.go

@@ -43,7 +43,6 @@ import (
 	"github.com/ava-labs/coreth/core/types"
 	"github.com/ava-labs/coreth/internal/ethapi"
 	"github.com/ava-labs/coreth/params"
-	"github.com/ava-labs/coreth/predicate"
 	"github.com/ava-labs/coreth/rpc"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -967,9 +966,7 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc
 		config.BlockOverrides.Apply(&vmctx)
 		// Apply all relevant upgrades from [originalTime] to the block time set in the override.
 		// Should be applied before the state overrides.
-		predicateBytes := predicate.GetPredicateResultBytes(vmctx.Header.Extra)
-		blockContext := params.NewBlockContext(vmctx.BlockNumber, vmctx.Time, predicateBytes)
-		err = core.ApplyUpgrades(api.backend.ChainConfig(), &originalTime, blockContext, statedb)
+		err = core.ApplyUpgrades(api.backend.ChainConfig(), &originalTime, block, statedb)
 		if err != nil {
 			return nil, err
 		}

params/hooks_libevm.go

@@ -12,6 +12,7 @@ import (
 	"github.com/ava-labs/coreth/precompile/contract"
 	"github.com/ava-labs/coreth/precompile/modules"
 	"github.com/ava-labs/coreth/precompile/precompileconfig"
+	"github.com/ava-labs/coreth/predicate"
 	"github.com/ava-labs/coreth/vmerrs"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -106,16 +107,19 @@ func makePrecompile(contract contract.StatefulPrecompiledContract) libevm.Precom
 		if err != nil {
 			panic(err) // Should never happen
 		}
-		var predicateResultsBytes []byte
-		if len(header.Extra) >= DynamicFeeExtraDataSize {
-			predicateResultsBytes = header.Extra[DynamicFeeExtraDataSize:]
+		var predicateResults *predicate.Results
+		if predicateResultsBytes := GetPredicateResultBytes(header.Extra); len(predicateResultsBytes) > 0 {
+			predicateResults, err = predicate.ParseResults(predicateResultsBytes)
+			if err != nil {
+				panic(err) // Should never happen, as results are already validated in block validation
+			}
 		}
 		accessableState := accessableState{
 			env: env,
-			blockContext: &BlockContext{
-				number:                env.BlockNumber(),
-				time:                  env.BlockTime(),
-				predicateResultsBytes: predicateResultsBytes,
+			blockContext: &precompileBlockContext{
+				number:           env.BlockNumber(),
+				time:             env.BlockTime(),
+				predicateResults: predicateResults,
 			},
 		}
 		return contract.Run(accessableState, env.Addresses().Caller, env.Addresses().Self, input, suppliedGas, env.ReadOnly())
@@ -140,7 +144,7 @@ func (r RulesExtra) PrecompileOverride(addr common.Address) (libevm.PrecompiledC
 
 type accessableState struct {
 	env          vm.PrecompileEnvironment
-	blockContext *BlockContext
+	blockContext *precompileBlockContext
 }
 
 func (a accessableState) GetStateDB() contract.StateDB {
@@ -170,28 +174,23 @@ func (a accessableState) Call(addr common.Address, input []byte, gas uint64, val
 	return a.env.Call(addr, input, gas, value)
 }
 
-type BlockContext struct {
-	number                *big.Int
-	time                  uint64
-	predicateResultsBytes []byte
+type precompileBlockContext struct {
+	number           *big.Int
+	time             uint64
+	predicateResults *predicate.Results
 }
 
-func NewBlockContext(number *big.Int, time uint64, predicateResultsBytes []byte) *BlockContext {
-	return &BlockContext{
-		number:                number,
-		time:                  time,
-		predicateResultsBytes: predicateResultsBytes,
-	}
-}
-
-func (b *BlockContext) Number() *big.Int {
-	return b.number
+func (p *precompileBlockContext) Number() *big.Int {
+	return p.number
 }
 
-func (b *BlockContext) Timestamp() uint64 {
-	return b.time
+func (p *precompileBlockContext) Timestamp() uint64 {
+	return p.time
 }
 
-func (b *BlockContext) GetPredicateResultsBytes() []byte {
-	return b.predicateResultsBytes
+func (p *precompileBlockContext) GetPredicateResults(txHash common.Hash, precompileAddress common.Address) []byte {
+	if p.predicateResults == nil {
+		return nil
+	}
+	return p.predicateResults.GetPredicateResults(txHash, precompileAddress)
 }

params/predicate_bytes.go

@@ -0,0 +1,25 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package params
+
+// GetPredicateResultBytes returns the predicate result bytes from extraData. If
+// extraData is too short to include predicate results, it returns nil.
+func GetPredicateResultBytes(extraData []byte) []byte {
+	// Prior to Durango, the VM enforces the extra data is smaller than or equal
+	// to this size.
+	if len(extraData) <= DynamicFeeExtraDataSize {
+		return nil
+	}
+	// After Durango, the extra data past the dynamic fee rollup window represents
+	// predicate results.
+	return extraData[DynamicFeeExtraDataSize:]
+}
+
+// SetPredicateResultBytes sets the predicate results in the extraData in the
+// block header. This is used to set the predicate results in a block header
+// without modifying the initial portion of the extra data (dynamic fee window
+// rollup).
+func SetPredicateResultBytes(extraData []byte, predicateResults []byte) []byte {
+	return append(extraData[:DynamicFeeExtraDataSize], predicateResults...)
+}

params/predicate_bytes_test.go

@@ -0,0 +1,25 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package params
+
+import (
+	"testing"
+
+	"github.com/ava-labs/avalanchego/utils"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPredicateResultsBytes(t *testing.T) {
+	require := require.New(t)
+	dataTooShort := utils.RandomBytes(DynamicFeeExtraDataSize - 1)
+	resultBytes := GetPredicateResultBytes(dataTooShort)
+	require.Empty(resultBytes)
+
+	preDurangoData := utils.RandomBytes(DynamicFeeExtraDataSize)
+	resultBytes = GetPredicateResultBytes(preDurangoData)
+	require.Empty(resultBytes)
+	postDurangoData := utils.RandomBytes(DynamicFeeExtraDataSize + 2)
+	resultBytes = GetPredicateResultBytes(postDurangoData)
+	require.Equal(resultBytes, postDurangoData[DynamicFeeExtraDataSize:])
+}

plugin/evm/block.go

@@ -388,7 +388,7 @@ func (b *Block) verifyPredicates(predicateContext *precompileconfig.PredicateCon
 		return fmt.Errorf("failed to marshal predicate results: %w", err)
 	}
 	extraData := b.ethBlock.Extra()
-	headerPredicateResultsBytes := predicate.GetPredicateResultBytes(extraData)
+	headerPredicateResultsBytes := params.GetPredicateResultBytes(extraData)
 	if len(headerPredicateResultsBytes) == 0 {
 		return fmt.Errorf("failed to find predicate results in extra data: %x", extraData)
 	}

plugin/evm/vm_warp_test.go

@@ -644,7 +644,7 @@ func testReceiveWarpMessage(
 
 	// Require the block was built with a successful predicate result
 	ethBlock := block2.(*chain.BlockWrapper).Block.(*Block).ethBlock
-	headerPredicateResultsBytes := predicate.GetPredicateResultBytes(ethBlock.Extra())
+	headerPredicateResultsBytes := params.GetPredicateResultBytes(ethBlock.Extra())
 	require.NotEmpty(headerPredicateResultsBytes)
 	results, err := predicate.ParseResults(headerPredicateResultsBytes)
 	require.NoError(err)

precompile/contract/interfaces.go

@@ -72,9 +72,9 @@ type ConfigurationBlockContext interface {
 
 type BlockContext interface {
 	ConfigurationBlockContext
-	// GetPredicateResults returns an byte array result of verifying the predicates
-	// of the given block.
-	GetPredicateResultsBytes() []byte
+	// GetPredicateResults returns a the result of verifying the predicates of the
+	// given transaction, precompile address pair as a byte array.
+	GetPredicateResults(txHash common.Hash, precompileAddress common.Address) []byte
 }
 
 type Configurator interface {