Merge branch 'master' into bastian/cadence-vm-merge-master

Author: turbolent

cmd/util/ledger/util/nop_meter.go

@@ -1,6 +1,8 @@
 package util
 
 import (
+	"math"
+
 	"github.com/onflow/cadence/common"
 
 	"github.com/onflow/flow-go/fvm/environment"
@@ -28,6 +30,10 @@ func (n NopMeter) ComputationIntensities() meter.MeteredComputationIntensities {
 	return meter.MeteredComputationIntensities{}
 }
 
+func (n NopMeter) ComputationRemaining(_ common.ComputationKind) uint64 {
+	return math.MaxUint64
+}
+
 func (n NopMeter) MeterMemory(_ common.MemoryUsage) error {
 	return nil
 }

engine/execution/state/bootstrap/bootstrap_test.go

@@ -58,10 +58,9 @@ func TestBootstrapLedger(t *testing.T) {
 }
 
 func TestBootstrapLedger_ZeroTokenSupply(t *testing.T) {
-	expectedStateCommitmentBytes, _ := hex.DecodeString(ifCompile(
-		"114c3c6747c0ecdb6f1aaba9278e261e2883d40c0ec917aacc53a6bfaca4c28f",
-		"d04e95da9811e985c5bf6a8f956ab3571ebf7bd4f15bf36098875b0e51e72906",
-	))
+	expectedStateCommitmentBytes, _ := hex.DecodeString(
+		"9b45ac2b9e1e04fd57761d551110d988c1737855d17f2f540c4b6c79c4b5058e",
+	)
 	expectedStateCommitment, err := flow.ToStateCommitment(expectedStateCommitmentBytes)
 	require.NoError(t, err)
 
@@ -116,10 +115,7 @@ func ifCompile[T any](a, b T) T {
 // This tests that the state commitment has not changed for the bookkeeping parts of the transaction.
 func TestBootstrapLedger_EmptyTransaction(t *testing.T) {
 	expectedStateCommitmentBytes, _ := hex.DecodeString(
-		ifCompile(
-			"26c1eb39af9ba9708b49d1149d9fb7ee2a5ab870793c67da0b4bd7c48f0cca33",
-			"88d0c00ff69668ef8e049f811b13750d4cd75cda2be6ecd3e6dcf3685e28c4e4",
-		),
+		"52ca1f4d53adc9ff018f10473a8bd02b4dc9baf5ab04bc1ac0fbb5b40e780d83",
 	)
 	expectedStateCommitment, err := flow.ToStateCommitment(expectedStateCommitmentBytes)
 	require.NoError(t, err)

fvm/environment/meter.go

@@ -112,6 +112,7 @@ type Meter interface {
 
 	ComputationIntensities() meter.MeteredComputationIntensities
 	ComputationAvailable(common.ComputationUsage) bool
+	ComputationRemaining(kind common.ComputationKind) uint64
 
 	MeterEmittedEvent(byteSize uint64) error
 	TotalEmittedEventBytes() uint64
@@ -141,6 +142,10 @@ func (meter *meterImpl) ComputationAvailable(usage common.ComputationUsage) bool
 	return meter.txnState.ComputationAvailable(usage)
 }
 
+func (meter *meterImpl) ComputationRemaining(kind common.ComputationKind) uint64 {
+	return meter.txnState.ComputationRemaining(kind)
+}
+
 func (meter *meterImpl) ComputationUsed() (uint64, error) {
 	return meter.txnState.TotalComputationUsed(), nil
 }

fvm/environment/mock/environment.go

@@ -82,7 +82,11 @@ func (we *WrappedEnvironment) ComputationAvailable(usage common.ComputationUsage
 	return we.env.ComputationAvailable(usage)
 }
 
-// MeterMemory meters the memory usage of a new operation.
+// ComputationRemaining returns the remaining computation for the given kind.
+func (we *WrappedEnvironment) ComputationRemaining(kind common.ComputationKind) uint64 {
+	return we.env.ComputationRemaining(kind)
+}
+
 func (we *WrappedEnvironment) MeterMemory(usage common.MemoryUsage) error {
 	err := we.env.MeterMemory(usage)
 	return handleEnvironmentError(err)

fvm/environment/mock/meter.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
+	"math"
 	"math/big"
 	"testing"
 
@@ -1244,6 +1245,89 @@ func TestEVMBatchRun(t *testing.T) {
 				require.Equal(t, num, new(big.Int).SetBytes(res.ReturnedData).Int64())
 			})
 	})
+
+	// run a batch of two transactions. The sum of their gas usage would overflow an uint46
+	// so the batch run should fail with an overflow error.
+	t.Run("Batch run evm gas overflow", func(t *testing.T) {
+		t.Parallel()
+		RunWithNewEnvironment(t,
+			chain, func(
+				ctx fvm.Context,
+				vm fvm.VM,
+				snapshot snapshot.SnapshotTree,
+				testContract *TestContract,
+				testAccount *EOATestAccount,
+			) {
+				sc := systemcontracts.SystemContractsForChain(chain.ChainID())
+				batchRunCode := []byte(fmt.Sprintf(
+					`
+					import EVM from %s
+
+					transaction(txs: [[UInt8]], coinbaseBytes: [UInt8; 20]) {
+						execute {
+							let coinbase = EVM.EVMAddress(bytes: coinbaseBytes)
+							let batchResults = EVM.batchRun(txs: txs, coinbase: coinbase)
+						}
+					}
+					`,
+					sc.EVMContract.Address.HexWithPrefix(),
+				))
+
+				coinbaseAddr := types.Address{1, 2, 3}
+				coinbaseBalance := getEVMAccountBalance(t, ctx, vm, snapshot, coinbaseAddr)
+				require.Zero(t, types.BalanceToBigInt(coinbaseBalance).Uint64())
+
+				batchCount := 2
+				txBytes := make([]cadence.Value, batchCount)
+
+				tx := testAccount.PrepareSignAndEncodeTx(t,
+					testContract.DeployedAt.ToCommon(),
+					testContract.MakeCallData(t, "storeWithLog", big.NewInt(0)),
+					big.NewInt(0),
+					uint64(200_000),
+					big.NewInt(1),
+				)
+
+				txBytes[0] = cadence.NewArray(
+					unittest.BytesToCdcUInt8(tx),
+				).WithType(stdlib.EVMTransactionBytesCadenceType)
+
+				tx = testAccount.PrepareSignAndEncodeTx(t,
+					testContract.DeployedAt.ToCommon(),
+					testContract.MakeCallData(t, "storeWithLog", big.NewInt(1)),
+					big.NewInt(0),
+					math.MaxUint64-uint64(100_000),
+					big.NewInt(1),
+				)
+
+				txBytes[1] = cadence.NewArray(
+					unittest.BytesToCdcUInt8(tx),
+				).WithType(stdlib.EVMTransactionBytesCadenceType)
+
+				coinbase := cadence.NewArray(
+					unittest.BytesToCdcUInt8(coinbaseAddr.Bytes()),
+				).WithType(stdlib.EVMAddressBytesCadenceType)
+
+				txs := cadence.NewArray(txBytes).
+					WithType(cadence.NewVariableSizedArrayType(
+						stdlib.EVMTransactionBytesCadenceType,
+					))
+
+				txBody, err := flow.NewTransactionBodyBuilder().
+					SetScript(batchRunCode).
+					SetPayer(sc.FlowServiceAccount.Address).
+					AddArgument(json.MustEncode(txs)).
+					AddArgument(json.MustEncode(coinbase)).
+					Build()
+				require.NoError(t, err)
+
+				state, output, err := vm.Run(ctx, fvm.Transaction(txBody, 0), snapshot)
+				require.NoError(t, err)
+				require.Error(t, output.Err)
+				require.ErrorContains(t, output.Err, "insufficient computation")
+				require.Empty(t, state.WriteSet)
+			})
+	})
 }
 
 func TestEVMBlockData(t *testing.T) {

fvm/evm/backends/wrappedEnv.go

@@ -204,13 +204,12 @@ func (h *ContractHandler) BatchRun(rlpEncodedTxs [][]byte, gasFeeCollector types
 }
 
 func (h *ContractHandler) batchRun(rlpEncodedTxs [][]byte) ([]*types.Result, error) {
-	// step 1 - transaction decoding and compute total gas needed
-	// This is safe to be done before checking the gas
-	// as it has its own metering
-	var totalGasLimit types.GasLimit
+	// step 1 - transaction decoding and check that enough evm gas is available in the FVM transaction
+
+	// remainingGasLimit is the remaining EVM gas available in hte FVM transaction
+	remainingGasLimit := h.backend.ComputationRemaining(environment.ComputationKindEVMGasUsage)
 	batchLen := len(rlpEncodedTxs)
 	txs := make([]*gethTypes.Transaction, batchLen)
-
 	for i, rlpEncodedTx := range rlpEncodedTxs {
 		tx, err := h.decodeTransaction(rlpEncodedTx)
 		// if any tx fails decoding revert the batch
@@ -219,14 +218,13 @@ func (h *ContractHandler) batchRun(rlpEncodedTxs [][]byte) ([]*types.Result, err
 		}
 
 		txs[i] = tx
-		totalGasLimit += types.GasLimit(tx.Gas())
-	}
 
-	// step 2 - check if enough computation is available
-	// for the whole batch
-	err := h.checkGasLimit(totalGasLimit)
-	if err != nil {
-		return nil, err
+		// step 2 - check if enough computation is available
+		txGasLimit := tx.Gas()
+		if remainingGasLimit < txGasLimit {
+			return nil, types.ErrInsufficientComputation
+		}
+		remainingGasLimit -= txGasLimit
 	}
 
 	// step 3 - prepare block context

fvm/evm/evm_test.go

@@ -110,6 +110,7 @@ func (v *View) DryCall(
 	from gethCommon.Address,
 	to gethCommon.Address,
 	data []byte,
+	authList []gethTypes.SetCodeAuthorization,
 	value *big.Int,
 	gasLimit uint64,
 	opts ...DryCallOption,
@@ -160,6 +161,13 @@ func (v *View) DryCall(
 	// not apply. These endpoints don't mutate the state, they
 	// simply read the state.
 	call.SkipTxGasLimitCheck()
+
+	// If we are given a non-empty list of SetCode authorizations,
+	// we need to set them, so that gas estimation works properly.
+	if len(authList) > 0 {
+		call.SetCodeAuthorizations(authList)
+	}
+
 	res, err := bv.DirectCall(call)
 	if err != nil {
 		return nil, err