github.com/koko1123/flow-go-1@v0.29.6/fvm/fvm_fuzz_test.go

package fvm_test

import (
	"fmt"
	"math"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/onflow/cadence"
	jsoncdc "github.com/onflow/cadence/encoding/json"

	"github.com/koko1123/flow-go-1/engine/execution/testutil"
	"github.com/koko1123/flow-go-1/fvm"
	"github.com/koko1123/flow-go-1/fvm/derived"
	"github.com/koko1123/flow-go-1/fvm/environment"
	"github.com/koko1123/flow-go-1/fvm/errors"
	"github.com/koko1123/flow-go-1/fvm/meter"
	"github.com/koko1123/flow-go-1/fvm/state"
	"github.com/koko1123/flow-go-1/model/flow"
	"github.com/koko1123/flow-go-1/utils/unittest"
)

func FuzzTransactionComputationLimit(f *testing.F) {
	// setup initial state
	vmt, tctx := bootstrapFuzzStateAndTxContext(f)

	f.Add(uint64(0), uint64(0), uint64(0), uint(0))
	f.Add(uint64(5), uint64(0), uint64(0), uint(0))
	f.Fuzz(func(t *testing.T, computationLimit uint64, memoryLimit uint64, interactionLimit uint64, transactionType uint) {
		computationLimit %= flow.DefaultMaxTransactionGasLimit
		transactionType %= uint(len(fuzzTransactionTypes))

		tt := fuzzTransactionTypes[transactionType]

		vmt.run(func(t *testing.T, vm fvm.VM, chain flow.Chain, ctx fvm.Context, view state.View, derivedBlockData *derived.DerivedBlockData) {
			// create the transaction
			txBody := tt.createTxBody(t, tctx)
			// set the computation limit
			txBody.SetGasLimit(computationLimit)

			// sign the transaction
			err := testutil.SignEnvelope(
				txBody,
				tctx.address,
				tctx.privateKey,
			)
			require.NoError(t, err)

			// set the memory limit
			ctx.MemoryLimit = memoryLimit
			// set the interaction limit
			ctx.MaxStateInteractionSize = interactionLimit
			// run the transaction
			tx := fvm.Transaction(txBody, derivedBlockData.NextTxIndexForTestingOnly())

			require.NotPanics(t, func() {
				err = vm.Run(ctx, tx, view)
			}, "Transaction should never result in a panic.")
			require.NoError(t, err, "Transaction should never result in an error.")

			// check if results are expected
			tt.require(t, tctx, fuzzResults{
				tx: tx,
			})
		})(t)
	})
}

type fuzzResults struct {
	tx *fvm.TransactionProcedure
}

type transactionTypeContext struct {
	address      flow.Address
	addressFunds uint64
	privateKey   flow.AccountPrivateKey
	chain        flow.Chain
}

type transactionType struct {
	createTxBody func(t *testing.T, tctx transactionTypeContext) *flow.TransactionBody
	require      func(t *testing.T, tctx transactionTypeContext, results fuzzResults)
}

var fuzzTransactionTypes = []transactionType{
	{
		// Token transfer of 0 tokens.
		// should succeed if no limits are hit.
		// fees should be deducted no matter what.
		createTxBody: func(t *testing.T, tctx transactionTypeContext) *flow.TransactionBody {
			txBody := transferTokensTx(tctx.chain).
				AddAuthorizer(tctx.address).
				AddArgument(jsoncdc.MustEncode(cadence.UFix64(0))). // 0 value transferred
				AddArgument(jsoncdc.MustEncode(cadence.NewAddress(tctx.chain.ServiceAddress())))

			txBody.SetProposalKey(tctx.address, 0, 0)
			txBody.SetPayer(tctx.address)
			return txBody
		},
		require: func(t *testing.T, tctx transactionTypeContext, results fuzzResults) {
			// if there is an error, it should be computation exceeded
			if results.tx.Err != nil {
				require.Len(t, results.tx.Events, 3)
				unittest.EnsureEventsIndexSeq(t, results.tx.Events, tctx.chain.ChainID())
				codes := []errors.ErrorCode{
					errors.ErrCodeComputationLimitExceededError,
					errors.ErrCodeCadenceRunTimeError,
					errors.ErrCodeLedgerInteractionLimitExceededError,
				}
				require.Contains(t, codes, results.tx.Err.Code(), results.tx.Err.Error())
			}

			// fees should be deducted no matter the input
			fees, deducted := getDeductedFees(t, tctx, results)
			require.True(t, deducted, "Fees should be deducted.")
			require.GreaterOrEqual(t, fees.ToGoValue().(uint64), fuzzTestsInclusionFees)
			unittest.EnsureEventsIndexSeq(t, results.tx.Events, tctx.chain.ChainID())
		},
	},
	{
		// Token transfer of too many tokens.
		// Should never succeed.
		// fees should be deducted no matter what.
		createTxBody: func(t *testing.T, tctx transactionTypeContext) *flow.TransactionBody {
			txBody := transferTokensTx(tctx.chain).
				AddAuthorizer(tctx.address).
				AddArgument(jsoncdc.MustEncode(cadence.UFix64(2 * tctx.addressFunds))). // too much value transferred
				AddArgument(jsoncdc.MustEncode(cadence.NewAddress(tctx.chain.ServiceAddress())))

			txBody.SetProposalKey(tctx.address, 0, 0)
			txBody.SetPayer(tctx.address)
			return txBody
		},
		require: func(t *testing.T, tctx transactionTypeContext, results fuzzResults) {
			require.Error(t, results.tx.Err)
			require.Len(t, results.tx.Events, 3)
			unittest.EnsureEventsIndexSeq(t, results.tx.Events, tctx.chain.ChainID())
			codes := []errors.ErrorCode{
				errors.ErrCodeComputationLimitExceededError,
				errors.ErrCodeCadenceRunTimeError, // because of the failed transfer
				errors.ErrCodeLedgerInteractionLimitExceededError,
			}
			require.Contains(t, codes, results.tx.Err.Code(), results.tx.Err.Error())

			// fees should be deducted no matter the input
			fees, deducted := getDeductedFees(t, tctx, results)
			require.True(t, deducted, "Fees should be deducted.")
			require.GreaterOrEqual(t, fees.ToGoValue().(uint64), fuzzTestsInclusionFees)
			unittest.EnsureEventsIndexSeq(t, results.tx.Events, tctx.chain.ChainID())
		},
	},
	{
		// Transaction that calls panic.
		// Should never succeed.
		// fees should be deducted no matter what.
		createTxBody: func(t *testing.T, tctx transactionTypeContext) *flow.TransactionBody {
			// empty transaction
			txBody := flow.NewTransactionBody().SetScript([]byte("transaction(){prepare(){};execute{panic(\"some panic\")}}"))
			txBody.SetProposalKey(tctx.address, 0, 0)
			txBody.SetPayer(tctx.address)
			return txBody
		},
		require: func(t *testing.T, tctx transactionTypeContext, results fuzzResults) {
			require.Error(t, results.tx.Err)
			require.Len(t, results.tx.Events, 3)
			unittest.EnsureEventsIndexSeq(t, results.tx.Events, tctx.chain.ChainID())
			codes := []errors.ErrorCode{
				errors.ErrCodeComputationLimitExceededError,
				errors.ErrCodeCadenceRunTimeError, // because of the panic
				errors.ErrCodeLedgerInteractionLimitExceededError,
			}
			require.Contains(t, codes, results.tx.Err.Code(), results.tx.Err.Error())

			// fees should be deducted no matter the input
			fees, deducted := getDeductedFees(t, tctx, results)
			require.True(t, deducted, "Fees should be deducted.")
			require.GreaterOrEqual(t, fees.ToGoValue().(uint64), fuzzTestsInclusionFees)
			unittest.EnsureEventsIndexSeq(t, results.tx.Events, tctx.chain.ChainID())
		},
	},
	{
		createTxBody: func(t *testing.T, tctx transactionTypeContext) *flow.TransactionBody {
			// create account
			txBody := flow.NewTransactionBody().SetScript(createAccountScript).
				AddAuthorizer(tctx.address)
			txBody.SetProposalKey(tctx.address, 0, 0)
			txBody.SetPayer(tctx.address)
			return txBody
		},
		require: func(t *testing.T, tctx transactionTypeContext, results fuzzResults) {
			// if there is an error, it should be computation exceeded
			if results.tx.Err != nil {
				require.Len(t, results.tx.Events, 3)
				unittest.EnsureEventsIndexSeq(t, results.tx.Events, tctx.chain.ChainID())
				codes := []errors.ErrorCode{
					errors.ErrCodeComputationLimitExceededError,
					errors.ErrCodeCadenceRunTimeError,
					errors.ErrCodeLedgerInteractionLimitExceededError,
				}
				require.Contains(t, codes, results.tx.Err.Code(), results.tx.Err.Error())
			}

			// fees should be deducted no matter the input
			fees, deducted := getDeductedFees(t, tctx, results)
			require.True(t, deducted, "Fees should be deducted.")
			require.GreaterOrEqual(t, fees.ToGoValue().(uint64), fuzzTestsInclusionFees)
			unittest.EnsureEventsIndexSeq(t, results.tx.Events, tctx.chain.ChainID())
		},
	},
}

const fuzzTestsInclusionFees = uint64(1_000)

// checks fee deduction happened and returns the amount of funds deducted
func getDeductedFees(tb testing.TB, tctx transactionTypeContext, results fuzzResults) (fees cadence.UFix64, deducted bool) {
	tb.Helper()

	var ok bool
	var feesDeductedEvent cadence.Event
	for _, e := range results.tx.Events {
		if string(e.Type) == fmt.Sprintf("A.%s.FlowFees.FeesDeducted", environment.FlowFeesAddress(tctx.chain)) {
			data, err := jsoncdc.Decode(nil, e.Payload)
			require.NoError(tb, err)
			feesDeductedEvent, ok = data.(cadence.Event)
			require.True(tb, ok, "Event payload should be of type cadence event.")
		}
	}
	if feesDeductedEvent.Type() == nil {
		return 0, false
	}
	fees, ok = feesDeductedEvent.Fields[0].(cadence.UFix64)
	require.True(tb, ok, "FeesDeducted[0] event should be of type cadence.UFix64.")
	return fees, true
}

func bootstrapFuzzStateAndTxContext(tb testing.TB) (bootstrappedVmTest, transactionTypeContext) {
	tb.Helper()

	addressFunds := uint64(1_000_000_000)
	var privateKey flow.AccountPrivateKey
	var address flow.Address
	bootstrappedVMTest, err := newVMTest().withBootstrapProcedureOptions(
		fvm.WithTransactionFee(fvm.DefaultTransactionFees),
		fvm.WithExecutionMemoryLimit(math.MaxUint32),
		fvm.WithExecutionEffortWeights(mainnetExecutionEffortWeights),
		fvm.WithExecutionMemoryWeights(meter.DefaultMemoryWeights),
		fvm.WithMinimumStorageReservation(fvm.DefaultMinimumStorageReservation),
		fvm.WithAccountCreationFee(fvm.DefaultAccountCreationFee),
		fvm.WithStorageMBPerFLOW(fvm.DefaultStorageMBPerFLOW),
	).withContextOptions(
		fvm.WithTransactionFeesEnabled(true),
		fvm.WithAccountStorageLimit(true),
	).bootstrapWith(func(vm fvm.VM, chain flow.Chain, ctx fvm.Context, view state.View, derivedBlockData *derived.DerivedBlockData) error {
		// ==== Create an account ====
		var txBody *flow.TransactionBody
		privateKey, txBody = testutil.CreateAccountCreationTransaction(tb, chain)

		err := testutil.SignTransactionAsServiceAccount(txBody, 0, chain)
		if err != nil {
			return err
		}

		tx := fvm.Transaction(txBody, derivedBlockData.NextTxIndexForTestingOnly())

		err = vm.Run(ctx, tx, view)

		require.NoError(tb, err)
		accountCreatedEvents := filterAccountCreatedEvents(tx.Events)

		// read the address of the account created (e.g. "0x01" and convert it to flow.address)
		data, err := jsoncdc.Decode(nil, accountCreatedEvents[0].Payload)
		require.NoError(tb, err)

		address = flow.Address(data.(cadence.Event).Fields[0].(cadence.Address))

		// ==== Transfer tokens to new account ====
		txBody = transferTokensTx(chain).
			AddAuthorizer(chain.ServiceAddress()).
			AddArgument(jsoncdc.MustEncode(cadence.UFix64(1_000_000_000))). // 10 FLOW
			AddArgument(jsoncdc.MustEncode(cadence.NewAddress(address)))

		txBody.SetProposalKey(chain.ServiceAddress(), 0, 1)
		txBody.SetPayer(chain.ServiceAddress())

		err = testutil.SignEnvelope(
			txBody,
			chain.ServiceAddress(),
			unittest.ServiceAccountPrivateKey,
		)
		require.NoError(tb, err)

		tx = fvm.Transaction(txBody, derivedBlockData.NextTxIndexForTestingOnly())

		err = vm.Run(ctx, tx, view)
		if err != nil {
			return err
		}

		return tx.Err
	})
	require.NoError(tb, err)

	return bootstrappedVMTest,
		transactionTypeContext{
			address:      address,
			addressFunds: addressFunds,
			privateKey:   privateKey,
			chain:        bootstrappedVMTest.chain,
		}
}