Account abstraction

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "tests"]
 	path = tests/testdata
-	url = https://github.com/ethereum/tests
+	url = ../tests

accounts/abi/bind/backends/simulated.go

@@ -650,6 +650,14 @@ func (m callmsg) GasPrice() *big.Int   { return m.CallMsg.GasPrice }
 func (m callmsg) Gas() uint64          { return m.CallMsg.Gas }
 func (m callmsg) Value() *big.Int      { return m.CallMsg.Value }
 func (m callmsg) Data() []byte         { return m.CallMsg.Data }
+func (m callmsg) IsAA() bool           { return m.CallMsg.IsAA }
+func (m callmsg) Sponsor() common.Address {
+	if !m.CallMsg.IsAA {
+		return m.CallMsg.From
+	} else {
+		return *m.CallMsg.To
+	}
+}
 
 // filterBackend implements filters.Backend to support filtering for logs without
 // taking bloom-bits acceleration structures into account.

common/types.go

@@ -175,6 +175,15 @@ func (h UnprefixedHash) MarshalText() ([]byte, error) {
 // Address represents the 20 byte address of an Ethereum account.
 type Address [AddressLength]byte
 
+// NewEntryPointAddress returns an ENTRY_POINT Address.
+func NewEntryPointAddress() Address {
+	var a Address
+	for i := range a {
+		a[i] = 0xFF
+	}
+	return a
+}
+
 // BytesToAddress returns Address with value b.
 // If b is larger than len(h), b will be cropped from the left.
 func BytesToAddress(b []byte) Address {
@@ -200,6 +209,16 @@ func IsHexAddress(s string) bool {
 	return len(s) == 2*AddressLength && isHex(s)
 }
 
+// IsEntryPointAddress returns true if the Address is the ENTRY_POINT Address.
+func (a Address) IsEntryPoint() bool {
+	for i := range a {
+		if a[i] != 0xFF {
+			return false
+		}
+	}
+	return true
+}
+
 // Bytes gets the string representation of the underlying address.
 func (a Address) Bytes() []byte { return a[:] }
 

core/aa_transaction_test.go

@@ -0,0 +1,167 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"encoding/binary"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/consensus/ethash"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+const (
+	contractCode = "3373ffffffffffffffffffffffffffffffffffffffff1460245736601f57005b600080fd5b60016000355b81900380602a57602035603957005b604035aa00"
+)
+
+// aaTransaction creates a new AA transaction to a deployed instance of the test contract.
+// Parameters are the contract address, the transaction gas limit,
+// the number of loops to run inside the contract (minimum: 1, gas per loop: 26),
+// whether to call PAYGAS at the end, the gas price to be returned from PAYGAS (if called).
+func aaTransaction(to common.Address, gaslimit uint64, loops uint64, callPaygas bool, gasPrice *big.Int) *types.Transaction {
+	data := make([]byte, 0x60)
+	if loops == 0 {
+		loops = 1
+	}
+	binary.BigEndian.PutUint64(data[0x18:0x20], loops)
+	if callPaygas {
+		data[0x3f] = 1
+	}
+	gasPriceBytes := gasPrice.Bytes()
+	copy(data[0x60-len(gasPriceBytes):], gasPriceBytes)
+
+	return types.NewTransaction(0, to, big.NewInt(0), gaslimit, big.NewInt(0), data).WithAASignature()
+}
+
+func setupBlockchain(blockGasLimit uint64) *BlockChain {
+	genesis := Genesis{Config: params.AllEthashProtocolChanges, GasLimit: blockGasLimit}
+	database := rawdb.NewMemoryDatabase()
+	genesis.MustCommit(database)
+	blockchain, _ := NewBlockChain(database, nil, genesis.Config, ethash.NewFaker(), vm.Config{}, nil)
+	return blockchain
+}
+
+func testValidate(blockchain *BlockChain, statedb *state.StateDB, transaction *types.Transaction, validationGasLimit uint64, expectedErr error, t *testing.T) {
+	var (
+		snapshotRevisionId = statedb.Snapshot()
+		context            = NewEVMContext(types.AAEntryMessage, blockchain.CurrentHeader(), blockchain, &common.Address{})
+		vmenv              = vm.NewEVM(context, statedb, blockchain.Config(), vm.Config{PaygasMode: vm.PaygasHalt})
+		err                = Validate(transaction, types.HomesteadSigner{}, vmenv, validationGasLimit)
+	)
+	if err != expectedErr {
+		t.Error("\n\texpected:", expectedErr, "\n\tgot:", err)
+	}
+	statedb.RevertToSnapshot(snapshotRevisionId)
+}
+
+func TestTransactionValidation(t *testing.T) {
+	var (
+		blockchain = setupBlockchain(10000000)
+		statedb, _ = blockchain.State()
+
+		key, _          = crypto.GenerateKey()
+		contractCreator = crypto.PubkeyToAddress(key.PublicKey)
+		contractAddress = crypto.CreateAddress(contractCreator, 0)
+		tx              = &types.Transaction{}
+	)
+	statedb.SetBalance(contractAddress, big.NewInt(100000))
+	statedb.SetCode(contractAddress, common.FromHex(contractCode))
+
+	// test: invalid, no PAYGAS
+	tx = aaTransaction(contractAddress, 100000, 1, false, big.NewInt(1))
+	testValidate(blockchain, statedb, tx, 400000, ErrNoPaygas, t)
+
+	// test: invalid, insufficient funds
+	tx = aaTransaction(contractAddress, 100000, 1, true, big.NewInt(2))
+	testValidate(blockchain, statedb, tx, 400000, vm.ErrPaygasInsufficientFunds, t)
+
+	// test: invalid, gasLimit too low for intrinsic gas cost
+	tx = aaTransaction(contractAddress, 1, 1, true, big.NewInt(1))
+	testValidate(blockchain, statedb, tx, 400000, ErrIntrinsicGas, t)
+
+	// test: invalid, gasLimit too low for loops
+	tx = aaTransaction(contractAddress, 100000, 100000, true, big.NewInt(1))
+	testValidate(blockchain, statedb, tx, 400000, vm.ErrOutOfGas, t)
+
+	// test: valid, gasLimit < validationGasLimit
+	tx = aaTransaction(contractAddress, 100000, 1, true, big.NewInt(1))
+	testValidate(blockchain, statedb, tx, 400000, nil, t)
+
+	// test: valid, validationGasLimit < gasLimit
+	tx = aaTransaction(contractAddress, 100000, 1, true, big.NewInt(1))
+	testValidate(blockchain, statedb, tx, 50000, nil, t)
+
+	// test: invalid, validationGasLimit too low for intrinsic gas cost
+	tx = aaTransaction(contractAddress, 100000, 1, true, big.NewInt(1))
+	testValidate(blockchain, statedb, tx, 1, ErrIntrinsicGas, t)
+
+	// test: invalid, validationGasLimit too low for loops
+	tx = aaTransaction(contractAddress, 100000, 100000, true, big.NewInt(1))
+	testValidate(blockchain, statedb, tx, 50000, vm.ErrOutOfGas, t)
+
+	statedb.SetBalance(contractAddress, big.NewInt(0))
+
+	// test: invalid, insufficient funds
+	tx = aaTransaction(contractAddress, 100000, 1, true, big.NewInt(1))
+	testValidate(blockchain, statedb, tx, 400000, vm.ErrPaygasInsufficientFunds, t)
+
+	// test: valid, gasPrice 0
+	tx = aaTransaction(contractAddress, 100000, 1, true, big.NewInt(0))
+	testValidate(blockchain, statedb, tx, 400000, nil, t)
+}
+
+func TestInvalidEVMConfig(t *testing.T) {
+	var (
+		blockchain = setupBlockchain(10000000)
+		statedb, _ = blockchain.State()
+
+		context = NewEVMContext(types.AAEntryMessage, blockchain.CurrentHeader(), blockchain, &common.Address{})
+		vmenv   = vm.NewEVM(context, statedb, blockchain.Config(), vm.Config{})
+
+		tx          = &types.Transaction{}
+		err         = Validate(tx, types.HomesteadSigner{}, vmenv, 400000)
+		expectedErr = ErrIncorrectAAConfig
+	)
+	if err != expectedErr {
+		t.Error("\n\texpected:", expectedErr, "\n\tgot:", err)
+	}
+}
+
+func TestMalformedTransaction(t *testing.T) {
+	var (
+		blockchain = setupBlockchain(10000000)
+		statedb, _ = blockchain.State()
+
+		context = NewEVMContext(types.AAEntryMessage, blockchain.CurrentHeader(), blockchain, &common.Address{})
+		vmenv   = vm.NewEVM(context, statedb, blockchain.Config(), vm.Config{PaygasMode: vm.PaygasHalt})
+
+		key, _      = crypto.GenerateKey()
+		tx          = pricedTransaction(0, 100000, big.NewInt(0), key)
+		err         = Validate(tx, types.HomesteadSigner{}, vmenv, 400000)
+		expectedErr = ErrMalformedAATransaction
+	)
+	if err != expectedErr {
+		t.Error("\n\texpected:", expectedErr, "\n\tgot:", err)
+	}
+}

core/error.go

@@ -63,4 +63,10 @@ var (
 	// ErrIntrinsicGas is returned if the transaction is specified to use less gas
 	// than required to start the invocation.
 	ErrIntrinsicGas = errors.New("intrinsic gas too low")
+
+	ErrInvalidAATransaction = errors.New("invalid account abstraction transaction")
+
+	ErrInvalidAAPrefix = errors.New("invalid account abstraction prefix")
+
+	ErrNoPaygas = errors.New("account abstraction transaction did not call PAYGAS")
 )

core/state_transition.go

@@ -25,6 +25,11 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
+var aaPrefix = [...]byte{
+	0x33, 0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0x14, 0x60, 0x24, 0x57, 0x36, 0x60, 0x1f, 0x57, 0x00, 0x5b, 0x60, 0x00, 0x80, 0xfd, 0x5b,
+}
+
 /*
 The State Transitioning Model
 
@@ -66,6 +71,9 @@ type Message interface {
 	Nonce() uint64
 	CheckNonce() bool
 	Data() []byte
+
+	IsAA() bool
+	Sponsor() common.Address
 }
 
 // ExecutionResult includes all output after executing given evm
@@ -173,17 +181,23 @@ func (st *StateTransition) to() common.Address {
 }
 
 func (st *StateTransition) buyGas() error {
-	mgval := new(big.Int).Mul(new(big.Int).SetUint64(st.msg.Gas()), st.gasPrice)
-	if st.state.GetBalance(st.msg.From()).Cmp(mgval) < 0 {
-		return ErrInsufficientFunds
+	var mgval *big.Int
+	if !st.msg.IsAA() {
+		mgval = new(big.Int).Mul(new(big.Int).SetUint64(st.msg.Gas()), st.gasPrice)
+		if st.state.GetBalance(st.msg.Sponsor()).Cmp(mgval) < 0 {
+			return ErrInsufficientFunds
+		}
 	}
 	if err := st.gp.SubGas(st.msg.Gas()); err != nil {
 		return err
 	}
 	st.gas += st.msg.Gas()
 
 	st.initialGas = st.msg.Gas()
-	st.state.SubBalance(st.msg.From(), mgval)
+	if !st.msg.IsAA() {
+		st.state.SubBalance(st.msg.Sponsor(), mgval)
+	}
+
 	return nil
 }
 
@@ -224,6 +238,28 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	// 5. there is no overflow when calculating intrinsic gas
 	// 6. caller has enough balance to cover asset transfer for **topmost** call
 
+	if st.msg.IsAA() {
+		if st.msg.Nonce() != 0 || st.msg.GasPrice().Sign() != 0 || st.msg.Value().Sign() != 0 {
+			return nil, ErrInvalidAATransaction
+		}
+
+		code := st.evm.StateDB.GetCode(st.to())
+		if code == nil || len(code) < len(aaPrefix) {
+			return nil, ErrInvalidAAPrefix
+		}
+		for i := range aaPrefix {
+			if code[i] != aaPrefix[i] {
+				return nil, ErrInvalidAAPrefix
+			}
+		}
+		if st.evm.PaygasMode() == vm.PaygasNoOp {
+			st.evm.SetPaygasMode(vm.PaygasContinue)
+		}
+		if st.evm.PaygasLimit() == 0 {
+			st.evm.SetPaygasLimit(st.msg.Gas())
+		}
+	}
+
 	// Check clauses 1-3, buy gas if everything is correct
 	if err := st.preCheck(); err != nil {
 		return nil, err
@@ -255,9 +291,21 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	if contractCreation {
 		ret, _, st.gas, vmerr = st.evm.Create(sender, st.data, st.gas, st.value)
 	} else {
-		// Increment the nonce for the next transaction
-		st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
+		if !msg.IsAA() {
+			// Increment the nonce for the next transaction
+			st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
+		}
 		ret, st.gas, vmerr = st.evm.Call(sender, st.to(), st.data, st.gas, st.value)
+		if msg.IsAA() && st.evm.PaygasMode() != vm.PaygasNoOp {
+			if vmerr != nil {
+				return nil, vmerr
+			} else {
+				return nil, ErrNoPaygas
+			}
+		}
+	}
+	if st.msg.IsAA() {
+		st.gasPrice = st.evm.PaygasPrice()
 	}
 	st.refundGas()
 	st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.gasPrice))
@@ -279,7 +327,7 @@ func (st *StateTransition) refundGas() {
 
 	// Return ETH for remaining gas, exchanged at the original rate.
 	remaining := new(big.Int).Mul(new(big.Int).SetUint64(st.gas), st.gasPrice)
-	st.state.AddBalance(st.msg.From(), remaining)
+	st.state.AddBalance(st.msg.Sponsor(), remaining)
 
 	// Also return remaining gas to the block gas counter so it is
 	// available for the next transaction.

core/transaction_validator.go

@@ -0,0 +1,53 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package core
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+)
+
+var (
+	ErrIncorrectAAConfig      = errors.New("incorrect AA config for EVM")
+	ErrMalformedAATransaction = errors.New("AA transaction malformed")
+)
+
+func Validate(tx *types.Transaction, s types.Signer, evm *vm.EVM, gasLimit uint64) error {
+	if evm.PaygasMode() != vm.PaygasHalt {
+		return ErrIncorrectAAConfig
+	}
+	evm.SetPaygasLimit(tx.Gas())
+	if gasLimit > tx.Gas() {
+		gasLimit = tx.Gas()
+	}
+	msg, err := tx.AsMessage(s)
+	if err != nil {
+		return err
+	} else if !msg.IsAA() {
+		return ErrMalformedAATransaction
+	}
+	msg.SetGas(gasLimit)
+	gp := new(GasPool).AddGas(gasLimit)
+	_, err = ApplyMessage(evm, msg, gp)
+	if err != nil {
+		return err
+	}
+	tx.SetAAGasPrice(evm.PaygasPrice())
+	return nil
+}