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

Renaming, Adding tstore/tload support

Browse source
This commit is contained in:
shahafn 2024-07-21 21:24:35 +03:00
parent 9bb4fb0328
commit fb55ee2446
9 changed files with 166 additions and 158 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
core/state_processor_rip7560.go
View file

@ -136,7 +136,7 @@ func handleRip7560Transactions(transactions []*types.Transaction, index int, sta
// todo: move to a suitable interface, whatever that is // todo: move to a suitable interface, whatever that is
// todo 2: maybe handle the "shared gas pool" situation instead of just overriding it completely? // todo 2: maybe handle the "shared gas pool" situation instead of just overriding it completely?
func BuyGasRip7560Transaction(st *types.Rip7560AccountAbstractionTx, state vm.StateDB) error { 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) mgval := new(uint256.Int).SetUint64(gasLimit)
gasFeeCap, _ := uint256.FromBig(st.GasFeeCap) gasFeeCap, _ := uint256.FromBig(st.GasFeeCap)
mgval = mgval.Mul(mgval, gasFeeCap) mgval = mgval.Mul(mgval, gasFeeCap)
@ -358,7 +358,7 @@ func prepareDeployerMessage(baseTx *types.Transaction, config *params.ChainConfi
From: config.DeployerCallerAddress, From: config.DeployerCallerAddress,
To: tx.Deployer, To: tx.Deployer,
Value: big.NewInt(0), Value: big.NewInt(0),
GasLimit: tx.ValidationGas, GasLimit: tx.ValidationGasLimit,
GasPrice: tx.GasFeeCap, GasPrice: tx.GasFeeCap,
GasFeeCap: tx.GasFeeCap, GasFeeCap: tx.GasFeeCap,
GasTipCap: tx.GasTipCap, GasTipCap: tx.GasTipCap,
@ -385,7 +385,7 @@ func prepareAccountValidationMessage(baseTx *types.Transaction, chainConfig *par
From: chainConfig.EntryPointAddress, From: chainConfig.EntryPointAddress,
To: tx.Sender, To: tx.Sender,
Value: big.NewInt(0), Value: big.NewInt(0),
GasLimit: tx.ValidationGas - deploymentUsedGas, GasLimit: tx.ValidationGasLimit - deploymentUsedGas,
GasPrice: tx.GasFeeCap, GasPrice: tx.GasFeeCap,
GasFeeCap: tx.GasFeeCap, GasFeeCap: tx.GasFeeCap,
GasTipCap: tx.GasTipCap, GasTipCap: tx.GasTipCap,
@ -416,7 +416,7 @@ func preparePaymasterValidationMessage(baseTx *types.Transaction, config *params
From: config.EntryPointAddress, From: config.EntryPointAddress,
To: tx.Paymaster, To: tx.Paymaster,
Value: big.NewInt(0), Value: big.NewInt(0),
GasLimit: tx.PaymasterGas, GasLimit: tx.PaymasterValidationGasLimit,
GasPrice: tx.GasFeeCap, GasPrice: tx.GasFeeCap,
GasFeeCap: tx.GasFeeCap, GasFeeCap: tx.GasFeeCap,
GasTipCap: tx.GasTipCap, GasTipCap: tx.GasTipCap,
@ -465,7 +465,7 @@ func preparePostOpMessage(vpr *ValidationPhaseResult, chainConfig *params.ChainC
From: chainConfig.EntryPointAddress, From: chainConfig.EntryPointAddress,
To: tx.Paymaster, To: tx.Paymaster,
Value: big.NewInt(0), Value: big.NewInt(0),
GasLimit: tx.PaymasterGas - executionResult.UsedGas, GasLimit: tx.PaymasterValidationGasLimit - executionResult.UsedGas,
GasPrice: tx.GasFeeCap, GasPrice: tx.GasFeeCap,
GasFeeCap: tx.GasFeeCap, GasFeeCap: tx.GasFeeCap,
GasTipCap: tx.GasTipCap, 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.PaymasterData,
aatx.DeployerData, aatx.DeployerData,
aatx.BuilderFee, aatx.BuilderFee,
aatx.ValidationGas, aatx.ValidationGasLimit,
aatx.PaymasterGas, aatx.PaymasterValidationGasLimit,
}) })
} }

96
core/types/tx_rip7560.go
View file

@ -35,16 +35,16 @@ type Rip7560AccountAbstractionTx struct {
AccessList AccessList AccessList AccessList
// extra fields // extra fields
Sender *common.Address Sender *common.Address
Signature []byte Signature []byte
Paymaster *common.Address `rlp:"nil"` Paymaster *common.Address `rlp:"nil"`
PaymasterData []byte PaymasterData []byte
Deployer *common.Address `rlp:"nil"` Deployer *common.Address `rlp:"nil"`
DeployerData []byte DeployerData []byte
BuilderFee *big.Int BuilderFee *big.Int
ValidationGas uint64 ValidationGasLimit uint64
PaymasterGas uint64 PaymasterValidationGasLimit uint64
PostOpGas uint64 PostOpGas uint64
// removed fields // removed fields
To *common.Address `rlp:"nil"` To *common.Address `rlp:"nil"`
@ -66,16 +66,16 @@ func (tx *Rip7560AccountAbstractionTx) copy() TxData {
GasTipCap: new(big.Int), GasTipCap: new(big.Int),
GasFeeCap: new(big.Int), GasFeeCap: new(big.Int),
Sender: copyAddressPtr(tx.Sender), Sender: copyAddressPtr(tx.Sender),
Signature: common.CopyBytes(tx.Signature), Signature: common.CopyBytes(tx.Signature),
Paymaster: copyAddressPtr(tx.Paymaster), Paymaster: copyAddressPtr(tx.Paymaster),
PaymasterData: common.CopyBytes(tx.PaymasterData), PaymasterData: common.CopyBytes(tx.PaymasterData),
Deployer: copyAddressPtr(tx.Deployer), Deployer: copyAddressPtr(tx.Deployer),
DeployerData: common.CopyBytes(tx.DeployerData), DeployerData: common.CopyBytes(tx.DeployerData),
BuilderFee: new(big.Int), BuilderFee: new(big.Int),
ValidationGas: tx.ValidationGas, ValidationGasLimit: tx.ValidationGasLimit,
PaymasterGas: tx.PaymasterGas, PaymasterValidationGasLimit: tx.PaymasterValidationGasLimit,
PostOpGas: tx.PostOpGas, PostOpGas: tx.PostOpGas,
} }
copy(cpy.AccessList, tx.AccessList) copy(cpy.AccessList, tx.AccessList)
if tx.Value != nil { if tx.Value != nil {
@ -140,21 +140,21 @@ func (tx *Rip7560AccountAbstractionTx) decode(input []byte) error {
// Rip7560Transaction an equivalent of a solidity struct only used to encode the 'transaction' parameter // Rip7560Transaction an equivalent of a solidity struct only used to encode the 'transaction' parameter
type Rip7560Transaction struct { type Rip7560Transaction struct {
Sender common.Address Sender common.Address
Nonce *big.Int Nonce *big.Int
ValidationGasLimit *big.Int ValidationGasLimit *big.Int
PaymasterGasLimit *big.Int PaymasterValidationGasLimit *big.Int
PostOpGasLimit *big.Int PostOpGasLimit *big.Int
CallGasLimit *big.Int CallGasLimit *big.Int
MaxFeePerGas *big.Int MaxFeePerGas *big.Int
MaxPriorityFeePerGas *big.Int MaxPriorityFeePerGas *big.Int
BuilderFee *big.Int BuilderFee *big.Int
Paymaster *common.Address Paymaster *common.Address
PaymasterData []byte PaymasterData []byte
Deployer *common.Address Deployer *common.Address
DeployerData []byte DeployerData []byte
CallData []byte CallData []byte
Signature []byte Signature []byte
} }
func (tx *Rip7560AccountAbstractionTx) AbiEncode() ([]byte, error) { func (tx *Rip7560AccountAbstractionTx) AbiEncode() ([]byte, error) {
@ -162,7 +162,7 @@ func (tx *Rip7560AccountAbstractionTx) AbiEncode() ([]byte, error) {
{Name: "sender", Type: "address"}, {Name: "sender", Type: "address"},
{Name: "nonce", Type: "uint256"}, {Name: "nonce", Type: "uint256"},
{Name: "validationGasLimit", Type: "uint256"}, {Name: "validationGasLimit", Type: "uint256"},
{Name: "paymasterGasLimit", Type: "uint256"}, {Name: "paymasterValidationGasLimit", Type: "uint256"},
{Name: "callGasLimit", Type: "uint256"}, {Name: "callGasLimit", Type: "uint256"},
{Name: "maxFeePerGas", Type: "uint256"}, {Name: "maxFeePerGas", Type: "uint256"},
{Name: "maxPriorityFeePerGas", Type: "uint256"}, {Name: "maxPriorityFeePerGas", Type: "uint256"},
@ -177,18 +177,18 @@ func (tx *Rip7560AccountAbstractionTx) AbiEncode() ([]byte, error) {
{Type: structThing, Name: "param_one"}, {Type: structThing, Name: "param_one"},
} }
record := &Rip7560Transaction{ record := &Rip7560Transaction{
Sender: *tx.Sender, Sender: *tx.Sender,
Nonce: big.NewInt(int64(tx.Nonce)), Nonce: big.NewInt(int64(tx.Nonce)),
ValidationGasLimit: big.NewInt(int64(tx.ValidationGas)), ValidationGasLimit: big.NewInt(int64(tx.ValidationGasLimit)),
PaymasterGasLimit: big.NewInt(int64(tx.PaymasterGas)), PaymasterValidationGasLimit: big.NewInt(int64(tx.PaymasterValidationGasLimit)),
CallGasLimit: big.NewInt(int64(tx.Gas)), CallGasLimit: big.NewInt(int64(tx.Gas)),
MaxFeePerGas: tx.GasFeeCap, MaxFeePerGas: tx.GasFeeCap,
MaxPriorityFeePerGas: tx.GasTipCap, MaxPriorityFeePerGas: tx.GasTipCap,
BuilderFee: tx.BuilderFee, BuilderFee: tx.BuilderFee,
PaymasterData: tx.PaymasterData, PaymasterData: tx.PaymasterData,
DeployerData: tx.DeployerData, DeployerData: tx.DeployerData,
CallData: tx.Data, CallData: tx.Data,
Signature: tx.Signature, Signature: tx.Signature,
} }
packed, err := args.Pack(&record) packed, err := args.Pack(&record)
return packed, err return packed, err

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

@ -33,8 +33,10 @@ type contractSizeVal struct {
} }
type access struct { type access struct {
Reads map[string]string `json:"reads"` Reads map[string]string `json:"reads"`
Writes map[string]uint64 `json:"writes"` 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) // note - this means an individual 'frame' in 7560 (validate, execute, postOp)
@ -251,14 +253,16 @@ func (b *rip7560ValidationTracer) OnOpcode(pc uint64, op byte, gas, cost uint64,
} }
b.lastOp = opcode 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()) slot := common.BytesToHash(StackBack(scope.StackData(), 0).Bytes())
slotHex := slot.Hex() slotHex := slot.Hex()
addr := scope.Address() addr := scope.Address()
if _, ok := b.CurrentLevel.Access[addr]; !ok { if _, ok := b.CurrentLevel.Access[addr]; !ok {
b.CurrentLevel.Access[addr] = &access{ b.CurrentLevel.Access[addr] = &access{
Reads: map[string]string{}, Reads: map[string]string{},
Writes: map[string]uint64{}, Writes: map[string]uint64{},
TransientReads: map[string]uint64{},
TransientWrites: map[string]uint64{},
} }
} }
access := *b.CurrentLevel.Access[addr] access := *b.CurrentLevel.Access[addr]
@ -271,8 +275,12 @@ func (b *rip7560ValidationTracer) OnOpcode(pc uint64, op byte, gas, cost uint64,
if !rOk && !wOk { if !rOk && !wOk {
access.Reads[slotHex] = b.env.StateDB.GetState(addr, slot).Hex() access.Reads[slotHex] = b.env.StateDB.GetState(addr, slot).Hex()
} }
} else { } else if opcode == "STORE" {
b.incrementCount(access.Writes, slotHex) b.incrementCount(access.Writes, slotHex)
} else if opcode == "TLOAD" {
b.incrementCount(access.TransientReads, slotHex)
} else if opcode == "TSTORE" {
b.incrementCount(access.TransientWrites, slotHex)
} }
} }

20
internal/ethapi/transaction_args.go
View file

@ -500,16 +500,16 @@ func (args *TransactionArgs) ToTransaction() *types.Transaction {
Data: args.data(), Data: args.data(),
AccessList: al, AccessList: al,
// RIP-7560 parameters // RIP-7560 parameters
Sender: args.Sender, Sender: args.Sender,
Signature: *args.Signature, Signature: *args.Signature,
Paymaster: args.Paymaster, Paymaster: args.Paymaster,
PaymasterData: *args.PaymasterData, PaymasterData: *args.PaymasterData,
Deployer: args.Deployer, Deployer: args.Deployer,
DeployerData: *args.DeployerData, DeployerData: *args.DeployerData,
BuilderFee: (*big.Int)(args.BuilderFee), BuilderFee: (*big.Int)(args.BuilderFee),
ValidationGas: uint64(*args.ValidationGas), ValidationGasLimit: uint64(*args.ValidationGas),
PaymasterGas: uint64(*args.PaymasterGas), PaymasterValidationGasLimit: uint64(*args.PaymasterGas),
PostOpGas: uint64(*args.PostOpGas), PostOpGas: uint64(*args.PostOpGas),
} }
data = &aatx data = &aatx
hash := types.NewTx(data).Hash() hash := types.NewTx(data).Hash()

42
tests/rip7560/deployer_test.go
View file

@ -14,9 +14,9 @@ func TestValidationFailure_deployerRevert(t *testing.T) {
withCode(DEFAULT_SENDER, []byte{}, DEFAULT_BALANCE). withCode(DEFAULT_SENDER, []byte{}, DEFAULT_BALANCE).
withCode(DEPLOYER.Hex(), revertWithData([]byte{}), 0), withCode(DEPLOYER.Hex(), revertWithData([]byte{}), 0),
types.Rip7560AccountAbstractionTx{ types.Rip7560AccountAbstractionTx{
Deployer: &DEPLOYER, Deployer: &DEPLOYER,
ValidationGas: 1000000000, ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000), GasFeeCap: big.NewInt(1000000000),
}, "account deployment failed: execution reverted") }, "account deployment failed: execution reverted")
} }
@ -25,9 +25,9 @@ func TestValidationFailure_deployerOOG(t *testing.T) {
withCode(DEFAULT_SENDER, []byte{}, DEFAULT_BALANCE). withCode(DEFAULT_SENDER, []byte{}, DEFAULT_BALANCE).
withCode(DEPLOYER.Hex(), revertWithData([]byte{}), 0), withCode(DEPLOYER.Hex(), revertWithData([]byte{}), 0),
types.Rip7560AccountAbstractionTx{ types.Rip7560AccountAbstractionTx{
Deployer: &DEPLOYER, Deployer: &DEPLOYER,
ValidationGas: 1, ValidationGasLimit: 1,
GasFeeCap: big.NewInt(1000000000), GasFeeCap: big.NewInt(1000000000),
}, "account deployment failed: out of gas") }, "account deployment failed: out of gas")
} }
@ -36,9 +36,9 @@ func TestValidationFailure_senderNotDeployed(t *testing.T) {
withCode(DEFAULT_SENDER, []byte{}, DEFAULT_BALANCE). withCode(DEFAULT_SENDER, []byte{}, DEFAULT_BALANCE).
withCode(DEPLOYER.Hex(), returnWithData([]byte{}), 0), withCode(DEPLOYER.Hex(), returnWithData([]byte{}), 0),
types.Rip7560AccountAbstractionTx{ types.Rip7560AccountAbstractionTx{
Deployer: &DEPLOYER, Deployer: &DEPLOYER,
ValidationGas: 1000000000, ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000), GasFeeCap: big.NewInt(1000000000),
}, "account deployment failed: sender not deployed") }, "account deployment failed: sender not deployed")
} }
@ -50,10 +50,10 @@ func TestValidationFailure_senderAlreadyDeployed(t *testing.T) {
withCode(sender.Hex(), accountCode, DEFAULT_BALANCE). withCode(sender.Hex(), accountCode, DEFAULT_BALANCE).
withCode(DEPLOYER.Hex(), deployerCode, 0), withCode(DEPLOYER.Hex(), deployerCode, 0),
types.Rip7560AccountAbstractionTx{ types.Rip7560AccountAbstractionTx{
Sender: &sender, Sender: &sender,
Deployer: &DEPLOYER, Deployer: &DEPLOYER,
ValidationGas: 1000000000, ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000), GasFeeCap: big.NewInt(1000000000),
}, "account deployment failed: sender already deployed") }, "account deployment failed: sender already deployed")
} }
@ -65,10 +65,10 @@ func TestValidationFailure_senderReverts(t *testing.T) {
withCode(sender.Hex(), []byte{}, DEFAULT_BALANCE). withCode(sender.Hex(), []byte{}, DEFAULT_BALANCE).
withCode(DEPLOYER.Hex(), deployerCode, 0), withCode(DEPLOYER.Hex(), deployerCode, 0),
types.Rip7560AccountAbstractionTx{ types.Rip7560AccountAbstractionTx{
Sender: &sender, Sender: &sender,
Deployer: &DEPLOYER, Deployer: &DEPLOYER,
ValidationGas: 1000000000, ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000), GasFeeCap: big.NewInt(1000000000),
}, "execution reverted") }, "execution reverted")
} }
@ -80,9 +80,9 @@ func TestValidation_deployer_ok(t *testing.T) {
withCode(sender.Hex(), []byte{}, DEFAULT_BALANCE). withCode(sender.Hex(), []byte{}, DEFAULT_BALANCE).
withCode(DEPLOYER.Hex(), deployerCode, 0), withCode(DEPLOYER.Hex(), deployerCode, 0),
types.Rip7560AccountAbstractionTx{ types.Rip7560AccountAbstractionTx{
Sender: &sender, Sender: &sender,
Deployer: &DEPLOYER, Deployer: &DEPLOYER,
ValidationGas: 1000000000, ValidationGasLimit: 1000000000,
GasFeeCap: big.NewInt(1000000000), GasFeeCap: big.NewInt(1000000000),
}, "ok") }, "ok")
} }

68
tests/rip7560/paymaster_test.go
View file

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

8
tests/rip7560/process_test.go
View file

@ -42,10 +42,10 @@ func TestProcess1(t *testing.T) {
withCode(DEFAULT_SENDER, createAccountCode(), 1000000000000000000). withCode(DEFAULT_SENDER, createAccountCode(), 1000000000000000000).
build(), []*types.Rip7560AccountAbstractionTx{ build(), []*types.Rip7560AccountAbstractionTx{
{ {
Sender: &Sender, Sender: &Sender,
ValidationGas: uint64(1000000000), ValidationGasLimit: uint64(1000000000),
GasFeeCap: big.NewInt(1000000000), GasFeeCap: big.NewInt(1000000000),
Data: []byte{1, 2, 3}, Data: []byte{1, 2, 3},
}, },
}) })
assert.NoError(t, err) assert.NoError(t, err)

56
tests/rip7560/validation_test.go
View file

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