forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-19 10:22:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

AA-378: Completing native tracer (#15)

Browse source 
* Renaming, Adding tstore/tload support

* Fixing tracer wip

* Adding handling of value, onExit

* Removing method id

* Fix abi encoding of nil fields

* typo

* Removing logs
This commit is contained in:
shahafn 2024-07-29 13:29:44 +03:00 committed by GitHub
parent 52f50471f2
commit d450ade0af
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 251 additions and 176 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
core/state_processor_rip7560.go
View file

@ -129,7 +129,7 @@ func handleRip7560Transactions(transactions []*types.Transaction, index int, sta
// todo: move to a suitable interface, whatever that is
// todo 2: maybe handle the "shared gas pool" situation instead of just overriding it completely?
func BuyGasRip7560Transaction(st *types.Rip7560AccountAbstractionTx, state vm.StateDB) error {
gasLimit := st.Gas + st.ValidationGas + st.PaymasterGas + st.PostOpGas
gasLimit := st.Gas + st.ValidationGasLimit + st.PaymasterValidationGasLimit + st.PostOpGas
mgval := new(uint256.Int).SetUint64(gasLimit)
gasFeeCap, _ := uint256.FromBig(st.GasFeeCap)
mgval = mgval.Mul(mgval, gasFeeCap)
@ -363,7 +363,7 @@ func prepareDeployerMessage(baseTx *types.Transaction, config *params.ChainConfi
From: AA_SENDER_CREATOR,
To: tx.Deployer,
Value: big.NewInt(0),
GasLimit: tx.ValidationGas,
GasLimit: tx.ValidationGasLimit,
GasPrice: tx.GasFeeCap,
GasFeeCap: tx.GasFeeCap,
GasTipCap: tx.GasTipCap,
@ -390,7 +390,7 @@ func prepareAccountValidationMessage(baseTx *types.Transaction, chainConfig *par
From: AA_ENTRY_POINT,
To: tx.Sender,
Value: big.NewInt(0),
GasLimit: tx.ValidationGas - deploymentUsedGas,
GasLimit: tx.ValidationGasLimit - deploymentUsedGas,
GasPrice: tx.GasFeeCap,
GasFeeCap: tx.GasFeeCap,
GasTipCap: tx.GasTipCap,
@ -421,7 +421,7 @@ func preparePaymasterValidationMessage(baseTx *types.Transaction, config *params
From: config.EntryPointAddress,
To: tx.Paymaster,
Value: big.NewInt(0),
GasLimit: tx.PaymasterGas,
GasLimit: tx.PaymasterValidationGasLimit,
GasPrice: tx.GasFeeCap,
GasFeeCap: tx.GasFeeCap,
GasTipCap: tx.GasTipCap,
@ -470,7 +470,7 @@ func preparePostOpMessage(vpr *ValidationPhaseResult, chainConfig *params.ChainC
From: AA_ENTRY_POINT,
To: tx.Paymaster,
Value: big.NewInt(0),
GasLimit: tx.PaymasterGas - executionResult.UsedGas,
GasLimit: tx.PaymasterValidationGasLimit - executionResult.UsedGas,
GasPrice: tx.GasFeeCap,
GasFeeCap: tx.GasFeeCap,
GasTipCap: tx.GasTipCap,

4
core/types/transaction_signing_rip7560.go
View file

@ -40,7 +40,7 @@ func (s rip7560Signer) Hash(tx *Transaction) common.Hash {
aatx.PaymasterData,
aatx.DeployerData,
aatx.BuilderFee,
aatx.ValidationGas,
aatx.PaymasterGas,
aatx.ValidationGasLimit,
aatx.PaymasterValidationGasLimit,
})
}

36
core/types/tx_rip7560.go
View file

@ -42,8 +42,8 @@ type Rip7560AccountAbstractionTx struct {
Deployer *common.Address `rlp:"nil"`
DeployerData []byte
BuilderFee *big.Int
ValidationGas uint64
PaymasterGas uint64
ValidationGasLimit uint64
PaymasterValidationGasLimit uint64
PostOpGas uint64
// removed fields
@ -73,8 +73,8 @@ func (tx *Rip7560AccountAbstractionTx) copy() TxData {
Deployer: copyAddressPtr(tx.Deployer),
DeployerData: common.CopyBytes(tx.DeployerData),
BuilderFee: new(big.Int),
ValidationGas: tx.ValidationGas,
PaymasterGas: tx.PaymasterGas,
ValidationGasLimit: tx.ValidationGasLimit,
PaymasterValidationGasLimit: tx.PaymasterValidationGasLimit,
PostOpGas: tx.PostOpGas,
}
copy(cpy.AccessList, tx.AccessList)
@ -154,15 +154,15 @@ type Rip7560Transaction struct {
Sender common.Address
Nonce *big.Int
ValidationGasLimit *big.Int
PaymasterGasLimit *big.Int
PaymasterValidationGasLimit *big.Int
PostOpGasLimit *big.Int
CallGasLimit *big.Int
MaxFeePerGas *big.Int
MaxPriorityFeePerGas *big.Int
BuilderFee *big.Int
Paymaster *common.Address
Paymaster common.Address
PaymasterData []byte
Deployer *common.Address
Deployer common.Address
DeployerData []byte
CallData []byte
Signature []byte
@ -173,12 +173,15 @@ func (tx *Rip7560AccountAbstractionTx) AbiEncode() ([]byte, error) {
{Name: "sender", Type: "address"},
{Name: "nonce", Type: "uint256"},
{Name: "validationGasLimit", Type: "uint256"},
{Name: "paymasterGasLimit", Type: "uint256"},
{Name: "paymasterValidationGasLimit", Type: "uint256"},
{Name: "postOpGasLimit", Type: "uint256"},
{Name: "callGasLimit", Type: "uint256"},
{Name: "maxFeePerGas", Type: "uint256"},
{Name: "maxPriorityFeePerGas", Type: "uint256"},
{Name: "builderFee", Type: "uint256"},
{Name: "paymaster", Type: "address"},
{Name: "paymasterData", Type: "bytes"},
{Name: "deployer", Type: "address"},
{Name: "deployerData", Type: "bytes"},
{Name: "callData", Type: "bytes"},
{Name: "signature", Type: "bytes"},
@ -187,16 +190,29 @@ func (tx *Rip7560AccountAbstractionTx) AbiEncode() ([]byte, error) {
args := abi.Arguments{
{Type: structThing, Name: "param_one"},
}
paymaster := tx.Paymaster
if paymaster == nil {
paymaster = &common.Address{}
}
deployer := tx.Deployer
if deployer == nil {
deployer = &common.Address{}
}
record := &Rip7560Transaction{
Sender: *tx.Sender,
Nonce: big.NewInt(int64(tx.Nonce)),
ValidationGasLimit: big.NewInt(int64(tx.ValidationGas)),
PaymasterGasLimit: big.NewInt(int64(tx.PaymasterGas)),
ValidationGasLimit: big.NewInt(int64(tx.ValidationGasLimit)),
PaymasterValidationGasLimit: big.NewInt(int64(tx.PaymasterValidationGasLimit)),
PostOpGasLimit: big.NewInt(int64(tx.PostOpGas)),
CallGasLimit: big.NewInt(int64(tx.Gas)),
MaxFeePerGas: tx.GasFeeCap,
MaxPriorityFeePerGas: tx.GasTipCap,
BuilderFee: tx.BuilderFee,
Paymaster: *paymaster,
PaymasterData: tx.PaymasterData,
Deployer: *deployer,
DeployerData: tx.DeployerData,
CallData: tx.Data,
Signature: tx.Signature,

77
eth/tracers/native/rip7560_validation.go
View file

@ -11,6 +11,7 @@ import (
"github.com/holiman/uint256"
"math/big"
"regexp"
"strconv"
"strings"
)
@ -35,6 +36,8 @@ type contractSizeVal struct {
type access struct {
Reads map[string]string `json:"reads"`
Writes map[string]uint64 `json:"writes"`
TransientReads map[string]uint64 `json:"transientReads"`
TransientWrites map[string]uint64 `json:"transientWrites"`
}
// note - this means an individual 'frame' in 7560 (validate, execute, postOp)
@ -87,6 +90,7 @@ func newRip7560Tracer(ctx *tracers.Context, cfg json.RawMessage) (*tracers.Trace
OnTxStart: t.OnTxStart,
OnTxEnd: t.OnTxEnd,
OnOpcode: t.OnOpcode,
OnExit: t.OnExit,
},
GetResult: t.GetResult,
Stop: t.Stop,
@ -142,6 +146,27 @@ func (b *rip7560ValidationTracer) OnEnter(depth int, typ byte, from common.Addre
if depth == 0 {
b.createNewTopLevelFrame(to)
}
b.Calls = append(b.Calls, &callsItem{
Type: vm.OpCode(typ).String(),
From: from,
To: to,
//Method: input[0:10],
Value: (*hexutil.Big)(value),
Gas: gas,
Data: input,
})
}
func (b *rip7560ValidationTracer) OnExit(depth int, output []byte, gasUsed uint64, err error, reverted bool) {
typ := "RETURN"
if err != nil {
typ = "REVERT"
}
b.Calls = append(b.Calls, &callsItem{
Type: typ,
GasUsed: gasUsed,
Data: output,
})
}
func (b *rip7560ValidationTracer) OnTxStart(env *tracing.VMContext, tx *types.Transaction, from common.Address) {
@ -251,7 +276,7 @@ func (b *rip7560ValidationTracer) OnOpcode(pc uint64, op byte, gas, cost uint64,
}
b.lastOp = opcode
if opcode == "SLOAD" || opcode == "SSTORE" {
if opcode == "SLOAD" || opcode == "SSTORE" || opcode == "TLOAD" || opcode == "TSTORE" {
slot := common.BytesToHash(StackBack(scope.StackData(), 0).Bytes())
slotHex := slot.Hex()
addr := scope.Address()
@ -259,6 +284,8 @@ func (b *rip7560ValidationTracer) OnOpcode(pc uint64, op byte, gas, cost uint64,
b.CurrentLevel.Access[addr] = &access{
Reads: map[string]string{},
Writes: map[string]uint64{},
TransientReads: map[string]uint64{},
TransientWrites: map[string]uint64{},
}
}
access := *b.CurrentLevel.Access[addr]
@ -271,34 +298,44 @@ func (b *rip7560ValidationTracer) OnOpcode(pc uint64, op byte, gas, cost uint64,
if !rOk && !wOk {
access.Reads[slotHex] = b.env.StateDB.GetState(addr, slot).Hex()
}
} else {
} else if opcode == "SSTORE" {
b.incrementCount(access.Writes, slotHex)
} else if opcode == "TLOAD" {
b.incrementCount(access.TransientReads, slotHex)
} else if opcode == "TSTORE" {
b.incrementCount(access.TransientWrites, slotHex)
}
}
if opcode == "KECCAK256" {
// TODO: uncomment and fix with StackBack
// collect keccak on 64-byte blocks
// ofs := scope.Stack.Back(0).ToBig().Int64()
// len := scope.Stack.Back(1).ToBig().Int64()
ofs := StackBack(scope.StackData(), 0)
len := StackBack(scope.StackData(), 1)
memory := scope.MemoryData()
// // currently, solidity uses only 2-word (6-byte) for a key. this might change..still, no need to
// // return too much
// if len > 20 && len < 512 {
// b.Keccak = append(b.Keccak, scope.Memory.GetCopy(ofs, len))
// }
//} else if strings.HasPrefix(opcode, "LOG") {
// count, _ := strconv.Atoi(opcode[3:])
// ofs := scope.Stack.Back(0).ToBig().Int64()
// len := scope.Stack.Back(1).ToBig().Int64()
// topics := []hexutil.Bytes{}
// for i := 0; i < count; i++ {
// topics = append(topics, scope.Stack.Back(2+i).Bytes())
// }
//
// b.Logs = append(b.Logs, &logsItem{
// Data: scope.Memory.GetCopy(ofs, len),
// Topic: topics,
// })
if len.Uint64() > 20 && len.Uint64() < 512 {
keccak := make([]byte, len.Uint64())
copy(keccak, memory[ofs.Uint64():ofs.Uint64()+len.Uint64()])
b.Keccak = append(b.Keccak, keccak)
}
} else if strings.HasPrefix(opcode, "LOG") {
count, _ := strconv.Atoi(opcode[3:])
ofs := StackBack(scope.StackData(), 0)
len := StackBack(scope.StackData(), 1)
memory := scope.MemoryData()
topics := []hexutil.Bytes{}
for i := 0; i < count; i++ {
topics = append(topics, StackBack(scope.StackData(), 2+i).Bytes())
//topics = append(topics, scope.Stack.Back(2+i).Bytes())
}
log := make([]byte, len.Uint64())
copy(log, memory[ofs.Uint64():ofs.Uint64()+len.Uint64()])
b.Logs = append(b.Logs, &logsItem{
Data: log,
Topic: topics,
})
}
}

26
internal/ethapi/transaction_args.go
View file

@ -115,6 +115,9 @@ func (args *TransactionArgs) setDefaults(ctx context.Context, b Backend, skipGas
if err := args.setFeeDefaults(ctx, b); err != nil {
return err
}
if err := args.set7560Defaults(ctx, b); err != nil {
return err
}
if args.Value == nil {
args.Value = new(hexutil.Big)
@ -194,6 +197,25 @@ func (args *TransactionArgs) setDefaults(ctx context.Context, b Backend, skipGas
return nil
}
func (args *TransactionArgs) set7560Defaults(ctx context.Context, b Backend) error {
// Not 7560 tx
if args.Sender == nil {
return nil
}
if args.Paymaster == nil {
log.Error("set7560Defaults setting default paymaster fields")
args.Paymaster = &common.Address{}
args.PaymasterData = &hexutil.Bytes{}
}
if args.Deployer == nil {
log.Error("set7560Defaults setting default deployer fields")
args.Deployer = &common.Address{}
args.DeployerData = &hexutil.Bytes{}
}
return nil
}
// setFeeDefaults fills in default fee values for unspecified tx fields.
func (args *TransactionArgs) setFeeDefaults(ctx context.Context, b Backend) error {
head := b.CurrentHeader()
@ -507,8 +529,8 @@ func (args *TransactionArgs) ToTransaction() *types.Transaction {
Deployer: args.Deployer,
DeployerData: *args.DeployerData,
BuilderFee: (*big.Int)(args.BuilderFee),
ValidationGas: uint64(*args.ValidationGas),
PaymasterGas: uint64(*args.PaymasterGas),
ValidationGasLimit: uint64(*args.ValidationGas),
PaymasterValidationGasLimit: uint64(*args.PaymasterGas),
PostOpGas: uint64(*args.PostOpGas),
}
data = &aatx

12
tests/rip7560/deployer_test.go
View file

@ -15,7 +15,7 @@ func TestValidationFailure_deployerRevert(t *testing.T) {
withCode(DEPLOYER.Hex(), revertWithData([]byte{}), 0),
types.Rip7560AccountAbstractionTx{
Deployer: &DEPLOYER,
ValidationGas: 1000000000,
ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
}, "account deployment failed: execution reverted")
}
@ -26,7 +26,7 @@ func TestValidationFailure_deployerOOG(t *testing.T) {
withCode(DEPLOYER.Hex(), revertWithData([]byte{}), 0),
types.Rip7560AccountAbstractionTx{
Deployer: &DEPLOYER,
ValidationGas: 1,
ValidationGasLimit: 1,
GasFeeCap: big.NewInt(1000000000),
}, "account deployment failed: out of gas")
}
@ -37,7 +37,7 @@ func TestValidationFailure_senderNotDeployed(t *testing.T) {
withCode(DEPLOYER.Hex(), returnWithData([]byte{}), 0),
types.Rip7560AccountAbstractionTx{
Deployer: &DEPLOYER,
ValidationGas: 1000000000,
ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
}, "account deployment failed: sender not deployed")
}
@ -52,7 +52,7 @@ func TestValidationFailure_senderAlreadyDeployed(t *testing.T) {
types.Rip7560AccountAbstractionTx{
Sender: &sender,
Deployer: &DEPLOYER,
ValidationGas: 1000000000,
ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
}, "account deployment failed: sender already deployed")
}
@ -67,7 +67,7 @@ func TestValidationFailure_senderReverts(t *testing.T) {
types.Rip7560AccountAbstractionTx{
Sender: &sender,
Deployer: &DEPLOYER,
ValidationGas: 1000000000,
ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
}, "execution reverted")
}
@ -82,7 +82,7 @@ func TestValidation_deployer_ok(t *testing.T) {
types.Rip7560AccountAbstractionTx{
Sender: &sender,
Deployer: &DEPLOYER,
ValidationGas: 1000000000,
ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
}, "ok")
}

32
tests/rip7560/paymaster_test.go
View file

@ -15,7 +15,7 @@ func TestPaymasterValidationFailure_nobalance(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), createCode(vm.PUSH0, vm.DUP1, vm.REVERT), 1), types.Rip7560AccountAbstractionTx{
ValidationGas: 1000000000,
ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
}, "insufficient funds for gas * price + value: address 0xaaAaaAAAAAbBbbbbBbBBCCCCcCCCcCdddDDDdddd have 1 want 1000000000000000000")
@ -25,7 +25,7 @@ func TestPaymasterValidationFailure_oog(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), createCode(vm.PUSH0, vm.DUP1, vm.REVERT), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: 1000000000,
ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
}, "out of gas")
@ -34,10 +34,10 @@ func TestPaymasterValidationFailure_revert(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), createCode(vm.PUSH0, vm.DUP1, vm.REVERT), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
PaymasterGas: 1000000000,
PaymasterValidationGasLimit: 1000000000,
}, "execution reverted")
}
@ -45,8 +45,8 @@ func TestPaymasterValidationFailure_unparseable_return_value(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), createAccountCode(), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: 1000000000,
PaymasterGas: 1000000000,
ValidationGasLimit: 1000000000,
PaymasterValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
}, "paymaster return data: too short")
@ -55,8 +55,8 @@ func TestPaymasterValidationFailure_unparseable_return_value(t *testing.T) {
func TestPaymasterValidationFailure_wrong_magic(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), returnWithData(paymasterReturnValue(1, 2, 3, []byte{})), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: 1000000000,
PaymasterGas: 1000000000,
ValidationGasLimit: 1000000000,
PaymasterValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
}, "paymaster did not return correct MAGIC_VALUE")
@ -77,8 +77,8 @@ func TestPaymasterValidationFailure_contextTooLarge(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), pmCode, DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: 1000000000,
PaymasterGas: 1000000000,
ValidationGasLimit: 1000000000,
PaymasterValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
}, "paymaster return data: context too large")
@ -87,8 +87,8 @@ func TestPaymasterValidationFailure_contextTooLarge(t *testing.T) {
func TestPaymasterValidationFailure_validAfter(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), returnWithData(paymasterReturnValue(core.MAGIC_VALUE_PAYMASTER, 300, 200, []byte{})), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: 1000000000,
PaymasterGas: 1000000000,
ValidationGasLimit: 1000000000,
PaymasterValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
}, "RIP-7560 transaction validity not reached yet")
@ -97,8 +97,8 @@ func TestPaymasterValidationFailure_validAfter(t *testing.T) {
func TestPaymasterValidationFailure_validUntil(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), returnWithData(paymasterReturnValue(core.MAGIC_VALUE_PAYMASTER, 1, 0, []byte{})), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: 1000000000,
PaymasterGas: 1000000000,
ValidationGasLimit: 1000000000,
PaymasterValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
}, "RIP-7560 transaction validity expired")
@ -107,8 +107,8 @@ func TestPaymasterValidationFailure_validUntil(t *testing.T) {
func TestPaymasterValidation_ok(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 0).
withCode(DEFAULT_PAYMASTER.String(), returnWithData(paymasterReturnValue(core.MAGIC_VALUE_PAYMASTER, 0, 0, []byte{})), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: 1000000000,
PaymasterGas: 1000000000,
ValidationGasLimit: 1000000000,
PaymasterValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000),
Paymaster: &DEFAULT_PAYMASTER,
}, "ok")

2
tests/rip7560/process_test.go
View file

@ -43,7 +43,7 @@ func TestProcess1(t *testing.T) {
build(), []*types.Rip7560AccountAbstractionTx{
{
Sender: &Sender,
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
Data: []byte{1, 2, 3},
},

28
tests/rip7560/validation_test.go
View file

@ -30,7 +30,7 @@ func TestUnpackValidationData(t *testing.T) {
func TestValidationFailure_OOG(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1),
ValidationGasLimit: uint64(1),
GasFeeCap: big.NewInt(1000000000),
}, "out of gas")
}
@ -38,14 +38,14 @@ func TestValidationFailure_OOG(t *testing.T) {
func TestValidationFailure_no_balance(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), 1), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1),
ValidationGasLimit: uint64(1),
GasFeeCap: big.NewInt(1000000000),
}, "insufficient funds for gas * price + value: address 0x1111111111222222222233333333334444444444 have 1 want 1000000000")
}
func TestValidationFailure_sigerror(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, returnWithData(core.PackValidationData(core.MAGIC_VALUE_SIGFAIL, 0, 0)), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "account signature error")
}
@ -54,7 +54,7 @@ func TestValidationFailure_validAfter(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER,
returnWithData(core.PackValidationData(core.MAGIC_VALUE_SENDER, 300, 200)), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "RIP-7560 transaction validity not reached yet")
}
@ -63,7 +63,7 @@ func TestValidationFailure_validUntil(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER,
returnWithData(core.PackValidationData(core.MAGIC_VALUE_SENDER, 1, 0)), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "RIP-7560 transaction validity expired")
}
@ -71,7 +71,7 @@ func TestValidationFailure_validUntil(t *testing.T) {
func TestValidation_ok(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "ok")
}
@ -79,20 +79,20 @@ func TestValidation_ok(t *testing.T) {
func TestValidation_ok_paid(t *testing.T) {
aatx := types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}
tb := newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), DEFAULT_BALANCE)
handleTransaction(tb, aatx, "ok")
maxCost := new(big.Int).SetUint64(aatx.ValidationGas + aatx.PaymasterGas + aatx.Gas)
maxCost := new(big.Int).SetUint64(aatx.ValidationGasLimit + aatx.PaymasterValidationGasLimit + aatx.Gas)
maxCost.Mul(maxCost, aatx.GasFeeCap)
}
func TestValidationFailure_account_nonce(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER, createAccountCode(), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
Nonce: 1234,
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "nonce too high: address 0x1111111111222222222233333333334444444444, tx: 1234 state: 0")
}
@ -100,7 +100,7 @@ func TestValidationFailure_account_nonce(t *testing.T) {
func TestValidationFailure_account_revert(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER,
createCode(vm.PUSH0, vm.DUP1, vm.REVERT), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "execution reverted")
}
@ -110,7 +110,7 @@ func TestValidationFailure_account_revert_with_reason(t *testing.T) {
reason := hexutils.HexToBytes("0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000")
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER,
revertWithData(reason), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "execution reverted")
}
@ -118,7 +118,7 @@ func TestValidationFailure_account_revert_with_reason(t *testing.T) {
func TestValidationFailure_account_wrong_return_length(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER,
returnWithData([]byte{1, 2, 3}), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "invalid account return data length")
}
@ -126,7 +126,7 @@ func TestValidationFailure_account_wrong_return_length(t *testing.T) {
func TestValidationFailure_account_no_return_value(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER,
returnWithData([]byte{}), DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "invalid account return data length")
}
@ -136,7 +136,7 @@ func TestValidationFailure_account_wrong_return_value(t *testing.T) {
handleTransaction(newTestContextBuilder(t).withCode(DEFAULT_SENDER,
returnWithData(make([]byte, 32)),
DEFAULT_BALANCE), types.Rip7560AccountAbstractionTx{
ValidationGas: uint64(1000000000),
ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000),
}, "account did not return correct MAGIC_VALUE")
}