From b89406a97d0e7c1cc8cb9a24f3a9d607f6ccef8f Mon Sep 17 00:00:00 2001 From: x-senpai-x Date: Mon, 28 Oct 2024 14:34:32 +0530 Subject: [PATCH 1/4] EvmBuilder and its dependencies #1 --- execution/evm/common.go | 11 + execution/evm/context.go | 136 ++++++++++ execution/evm/evmBuilder.go | 77 ++++++ execution/evm/evm_context.go | 20 ++ execution/evm/handler.go | 397 +++++++++++++++++++++++++++++ execution/evm/inner_evm_context.go | 62 +++++ execution/evm/journal.go | 50 ++++ execution/evm/journal_entry.go | 148 +++++++++++ execution/evm/precompiles.go | 121 +++++++++ 9 files changed, 1022 insertions(+) create mode 100644 execution/evm/common.go create mode 100644 execution/evm/context.go create mode 100644 execution/evm/evmBuilder.go create mode 100644 execution/evm/evm_context.go create mode 100644 execution/evm/handler.go create mode 100644 execution/evm/inner_evm_context.go create mode 100644 execution/evm/journal.go create mode 100644 execution/evm/journal_entry.go create mode 100644 execution/evm/precompiles.go diff --git a/execution/evm/common.go b/execution/evm/common.go new file mode 100644 index 0000000..f91ce66 --- /dev/null +++ b/execution/evm/common.go @@ -0,0 +1,11 @@ +package evm +import( + "github.com/BlocSoc-iitr/selene/common" + Common "github.com/ethereum/go-ethereum/common" + "math/big" +) +type BlockTag = common.BlockTag +type U256 = *big.Int +type B256 = Common.Hash +type Address = common.Address +type Bytes=[]byte \ No newline at end of file diff --git a/execution/evm/context.go b/execution/evm/context.go new file mode 100644 index 0000000..1446b3d --- /dev/null +++ b/execution/evm/context.go @@ -0,0 +1,136 @@ +package evm +import ( + "math/big" +) +var BLOCK_HASH_HISTORY = big.NewInt(256) +type Context[EXT interface{}, DB Database] struct { + Evm EvmContext[DB] + External interface{} +} +func DefaultContext[EXT interface{}]() Context[EXT, *EmptyDB] { + return Context[EXT, *EmptyDB]{ + Evm: NewEvmContext(new(EmptyDB)), + External: nil, + } +} +func NewContext[EXT interface{}, DB Database](evm EvmContext[DB], external EXT) Context[EXT, DB] { + return Context[EXT, DB]{ + Evm: evm, + External: external, + } +} +type ContextWithHandlerCfg[EXT interface{}, DB Database] struct { + Context Context[EXT, DB] + Cfg HandlerCfg +} +func (js JournaledState) SetSpecId(spec SpecId) { + js.Spec = spec +} +//Not being used +func (c EvmContext[DB]) WithDB(db DB) EvmContext[DB] { + return EvmContext[DB]{ + Inner: c.Inner.WithDB(db), + Precompiles: DefaultContextPrecompiles[DB](), + } +} +//////////////////////////////////// +/// impl Host for Context ///////// +//////////////////////////////////// + +// func (c *Context[EXT, DB]) Env() *Env { +// return c.Evm.Inner.Env +// } + +// func (c *Context[EXT, DB]) EnvMut() *Env { +// return c.Evm.Inner.Env +// } + +// func (c *Context[EXT, DB]) LoadAccount(address Address) (LoadAccountResult, bool) { +// res, err := c.Evm.Inner.LoadAccountExist(address) +// if err != nil { +// c.Evm.Inner.Error = err +// return LoadAccountResult{}, false +// } +// return res, true +// } + +// //Get the block hash of the given block `number`. +// func (c *Context[EXT, DB]) BlockHash(number uint64) (B256, bool) { +// blockNumber := c.Evm.Inner.Env.Block.Number +// requestedNumber := big.NewInt(int64(number)) + +// diff := new(big.Int).Sub(blockNumber, requestedNumber) + +// if diff.Cmp(big.NewInt(0)) == 0 { +// return common.Hash{}, true +// } + +// if diff.Cmp(BLOCK_HASH_HISTORY) <= 0 { +// hash, err := c.Evm.Inner.DB.BlockHash(number) +// if err != nil { +// c.Evm.Inner.Error = err +// return common.Hash{}, false +// } +// return hash, true +// } + +// return common.Hash{}, true +// } + +// // Get balance of `address` and if the account is cold. +// func (c *Context[EXT, DB]) Balance(address Address) (U256, bool, bool) + +// // Get code of `address` and if the account is cold. +// func (c *Context[EXT, DB]) Code(address Address) (Bytes, bool, bool) + +// // Get code hash of `address` and if the account is cold. +// func (c *Context[EXT, DB]) CodeHash(address Address) (B256, bool, bool) + +// // Get storage value of `address` at `index` and if the account is cold. +// func (c *Context[EXT, DB]) SLoad(address Address, index U256) (U256, bool, bool) + +// // Set storage value of account address at index. +// // Returns (original, present, new, is_cold). +// func (c *Context[EXT, DB]) SStore(address Address, index U256, value U256) (SStoreResult, bool) + +// // Get the transient storage value of `address` at `index`. +// func (c *Context[EXT, DB]) TLoad(address Address, index U256) U256 + +// // Set the transient storage value of `address` at `index`. +// func (c *Context[EXT, DB]) TStore(address Address, index U256, value U256) + +// // Emit a log owned by `address` with given `LogData`. +// func (c *Context[EXT, DB]) Log(log Log [any]) + +// // Mark `address` to be deleted, with funds transferred to `target`. +// func (c *Context[EXT, DB]) SelfDestruct(address Address, target Address) (SelfDestructResult, bool) + +//////////////////////////////////// +//////////////////////////////////// +//////////////////////////////////// + +/* +func (c EvmContext[DB1]) WithNewEvmDB[DB2 Database](db DB2) *EvmContext[ DB2] { + return &EvmContext[DB2]{ + Inner: c.Inner.WithDB(db), + context: NewContext[EXT, DB2]( + eb.context.Evm.WithNewDB(db), + eb.context.External.(EXT), + ), + handler: Handler[Context[EXT, DB2], EXT, DB2]{Cfg: eb.handler.Cfg}, + phantom: struct{}{}, + } +}*/ + + + + + + + + + + + + + diff --git a/execution/evm/evmBuilder.go b/execution/evm/evmBuilder.go new file mode 100644 index 0000000..c0ec0c1 --- /dev/null +++ b/execution/evm/evmBuilder.go @@ -0,0 +1,77 @@ +package evm +type EvmBuilder[EXT interface{}, DB Database] struct { + context Context[EXT, DB] + handler Handler[Context[EXT, DB], EXT, DB] + phantom struct{} +} +func NewDefaultEvmBuilder[EXT interface{}]() *EvmBuilder[EXT, *EmptyDB] { + handlerCfg := NewHandlerCfg(LATEST) + return &EvmBuilder[EXT, *EmptyDB]{ + context: DefaultContext[EXT](), + handler: Handler[Context[EXT, *EmptyDB], EXT, *EmptyDB]{Cfg: handlerCfg}, + phantom: struct{}{}, + } +} +func WithNewDB[EXT interface{}, DB1, DB2 Database]( + eb *EvmBuilder[EXT, DB1], + db DB2, +) *EvmBuilder[EXT, DB2] { + return &EvmBuilder[EXT, DB2]{ + context: NewContext[EXT, DB2]( + WithNewEvmDB(eb.context.Evm, db), + eb.context.External.(EXT), + ), + handler: Handler[Context[EXT, DB2], EXT, DB2]{Cfg: eb.handler.Cfg}, + phantom: struct{}{}, + } +} +func (eb *EvmBuilder[EXT, DB]) WithEnv(env *Env) *EvmBuilder[EXT, DB] { + eb.context.Evm.Inner.Env = env + return eb +} + +func (eb *EvmBuilder[EXT, DB]) Build() Evm[EXT,DB] { + return NewEvm(eb.context, eb.handler) +} + +func WithContextWithHandlerCfg[EXT interface{},DB1,DB2 Database](eb *EvmBuilder[EXT, DB1],contextWithHandlerCfg ContextWithHandlerCfg[EXT, DB2]) *EvmBuilder[EXT, DB2] { + return &EvmBuilder[EXT, DB2]{ + context: contextWithHandlerCfg.Context, + handler: Handler[Context[EXT, DB2], EXT, DB2]{Cfg: contextWithHandlerCfg.Cfg}, + phantom: struct{}{}, + } +} +//Not in use +func (eb EvmBuilder[EXT, DB]) WithDB(db DB) *EvmBuilder[EXT, DB] { + return &EvmBuilder[EXT, DB]{ + context: NewContext[EXT, DB](eb.context.Evm.WithDB(db), eb.context.External.(EXT)), //Doubt + handler: Handler[Context[EXT, DB], EXT, DB]{Cfg: eb.handler.Cfg}, //Doubt + phantom: struct{}{}, + } +} +//Not in use +type PhantomData[T any] struct{} +//Not in use +/* +func WithContextWithHandlerCfg[EXT interface{}, DB Database](eb *EvmBuilder[EXT, Database], contextWithHandlerCfg ContextWithHandlerCfg[EXT, Database]) *EvmBuilder[EXT, Database] { + return &EvmBuilder[EXT, Database]{ + context: contextWithHandlerCfg.Context, + handler: Handler[Context[EXT, Database], EXT, Database]{Cfg: contextWithHandlerCfg.Cfg}, + phantom: struct{}{}, + } +}*/ +/* +func (eb EvmBuilder[EXT, DB]) WithContextWithHandlerCfg(contextWithHandlerCfg ContextWithHandlerCfg[EXT, DB]) *EvmBuilder[EXT, DB] { + return &EvmBuilder[EXT, DB]{ + context: contextWithHandlerCfg.Context, + handler: Handler[Context[EXT, DB], EXT, DB]{Cfg: contextWithHandlerCfg.Cfg}, + phantom: struct{}{}, + } +}*/ + + +// Tuple implementation in golang: + +// LogData represents the data structure of a log entry. + + diff --git a/execution/evm/evm_context.go b/execution/evm/evm_context.go new file mode 100644 index 0000000..7a8b4b3 --- /dev/null +++ b/execution/evm/evm_context.go @@ -0,0 +1,20 @@ +package evm +type EvmContext[DB Database] struct { + Inner InnerEvmContext[DB] + Precompiles ContextPrecompiles[DB] +} +func NewEvmContext[DB Database](db DB) EvmContext[DB] { + return EvmContext[DB]{ + Inner: NewInnerEvmContext[DB](db), + Precompiles: DefaultContextPrecompiles[DB](), + } +} +func WithNewEvmDB[DB1, DB2 Database]( + ec EvmContext[DB1], + db DB2, +) EvmContext[DB2] { + return EvmContext[DB2]{ + Inner: WithNewInnerDB(ec.Inner,db), + Precompiles: DefaultContextPrecompiles[DB2](), + } +} diff --git a/execution/evm/handler.go b/execution/evm/handler.go new file mode 100644 index 0000000..43694a7 --- /dev/null +++ b/execution/evm/handler.go @@ -0,0 +1,397 @@ +package evm +type Handler[H Host, EXT any, DB Database] struct { + Cfg HandlerCfg + InstructionTable InstructionTables[Context[EXT, DB]] + Registers []HandleRegisters[H, EXT, DB] + Validation ValidationHandler[EXT, DB] + PreExecution PreExecutionHandler[EXT, DB] + PostExecution PostExecutionHandler[EXT, DB] + Execution ExecutionHandler[EXT, DB] +} +func NewEvmHandler[H Host, EXT any, DB Database](cfg HandlerCfg) (*EvmHandler[H, EXT, DB], error) { + h := &EvmHandler[H, EXT, DB]{Cfg: cfg} + if h.Cfg.isOptimism { + return h.optimismWithSpec(cfg.specID) + } + return h.mainnetWithSpec(cfg.specID) +} +func (h *EvmHandler[H, EXT, DB]) optimismWithSpec(specid SpecId) (*EvmHandler[H, EXT, DB], error) { + return &EvmHandler[H, EXT, DB]{ + Cfg: HandlerCfg{ + specID: specid, + isOptimism: true, + }, + InstructionTable: NewPlainInstructionTable(InstructionTable[Context[EXT, DB]]{}), + Registers: []HandleRegisters[H, EXT, DB]{}, + Validation: ValidationHandler[EXT, DB]{}, + PreExecution: PreExecutionHandler[EXT, DB]{}, + PostExecution: PostExecutionHandler[EXT, DB]{}, + Execution: ExecutionHandler[EXT, DB]{}, + }, nil +} +func (h *EvmHandler[H, EXT, DB]) mainnetWithSpec(specid SpecId) (*EvmHandler[H, EXT, DB], error) { + return &EvmHandler[H, EXT, DB]{ + Cfg: HandlerCfg{ + specID: specid, + isOptimism: false, + }, + InstructionTable: NewPlainInstructionTable(InstructionTable[Context[EXT, DB]]{}), + Registers: []HandleRegisters[H, EXT, DB]{}, + Validation: ValidationHandler[EXT, DB]{}, + PreExecution: PreExecutionHandler[EXT, DB]{}, + PostExecution: PostExecutionHandler[EXT, DB]{}, + Execution: ExecutionHandler[EXT, DB]{}, + }, nil +} +type HandlerCfg struct { + specID SpecId + isOptimism bool +} +func NewHandlerCfg(specID SpecId) HandlerCfg { + return HandlerCfg{ + specID: specID, + isOptimism: getDefaultOptimismSetting(), + } +} +//Note there might be error in specToGeneric needs to be well tested + +/* +Enabling run time flexibility +# Run with optimism disabled (default) +go run main.go + +# Run with optimism enabled +OPTIMISM_ENABLED=true go run main.go*/ +// SpecId is the enumeration of various Ethereum hard fork specifications. + +// PhantomData is a Go struct that simulates the behavior of Rust's PhantomData. +func (s SpecId) Enabled(a SpecId, b SpecId) bool { + return uint8(a) >= uint8(b) +} +func (h *Handler[H, EXT, DB]) ExecuteFrame(frame *Frame, sharedMemory *SharedMemory, context *Context[EXT, DB]) (InterpreterAction, error) { + return h.Execution.ExecuteFrame(frame, sharedMemory, &h.InstructionTable, context) +} +func (h *EvmHandler[H, EXT, DB]) specId() SpecId { + return h.Cfg.specID +} +func (h *EvmHandler[H, EXT, DB]) IsOptimism() bool { + return isOptimismEnabled && h.Cfg.isOptimism +} + +// EvmHandler is a type alias for Handler with specific type parameters. +type EvmHandler[H Host, EXT any, DB Database] Handler[H, EXT, DB] + +// HandleRegister defines a function type that accepts a pointer to EvmHandler. +type HandleRegister[H Host, EXT any, DB Database] func(handler *EvmHandler[H, EXT, DB]) + +// HandleRegisterBox defines a function type as a boxed register. +type HandleRegisterBox[H Host, EXT any, DB Database] func(handler *EvmHandler[H, EXT, DB]) + +// HandleRegisters is an interface that defines the `Register` method. +type HandleRegisters[H Host, EXT any, DB Database] interface { + Register(handler *EvmHandler[H, EXT, DB]) +} + +// PlainRegister struct implements HandleRegisters with a plain function register. +type PlainRegister[H Host, EXT any, DB Database] struct { + RegisterFn HandleRegister[H, EXT, DB] +} + +// BoxRegister struct implements HandleRegisters with a boxed function register. +type BoxRegister[H Host, EXT any, DB Database] struct { + RegisterFn HandleRegisterBox[H, EXT, DB] +} + +// Register method for PlainRegister, to satisfy HandleRegisters interface. +func (p PlainRegister[H, EXT, DB]) Register(handler *EvmHandler[H, EXT, DB]) { + p.RegisterFn(handler) +} + +// Register method for BoxRegister, to satisfy HandleRegisters interface. +func (b BoxRegister[H, EXT, DB]) Register(handler *EvmHandler[H, EXT, DB]) { + b.RegisterFn(handler) +} +/* +func (s SpecId) IsEnabledIn(spec SpecId) bool { + return s.Enabled(s, spec) +} +*/ +// String method to provide a string representation for each CallScheme variant. +// func (cs CallScheme) String() string { +// switch cs { +// case Call_Scheme: +// return "Call" +// case CallCode: +// return "CallCode" +// case DelegateCall: +// return "DelegateCall" +// case StaticCall: +// return "StaticCall" +// case ExtCall: +// return "ExtCall" +// case ExtStaticCall: +// return "ExtStaticCall" +// case ExtDelegateCall: +// return "ExtDelegateCall" +// default: +// return "Unknown" +// } +// } + +/* +func (s Spec) SpecID() SpecId { + return s.SPEC_ID +} +*/ +// IsEnabled checks if a specific SpecId is enabled. +/*func (s Spec) IsEnabled(specId SpecId) bool { + return SpecIdEnabled(s.SpecID(), specId) +} +func SpecIdEnabled(our, other SpecId) bool { + return our >= other +}*/ +/* +func NewHandler[H Host, EXT any, DB Database](cfg HandlerCfg) Handler[H, EXT, DB] { + return createHandlerWithConfig[H, EXT, DB](cfg) +}*/ +/* +func createHandlerWithConfig[H Host, EXT any, DB Database](cfg HandlerCfg) Handler[H, EXT, DB] { + spec := GetSpecforID[H, EXT, DB](cfg.specID) + + if cfg.isOptimism { + return createOptimismHandler(spec) + } + return createMainnetHandler(spec) +} +*/ + +/* +func (h *EvmHandler[H,EXT, DB])optimism() *EvmHandler[H,EXT, DB]{ + handler:= +}*/ +//Doubt in newplaininstructiontable +/* +func (h *EvmHandler[H,EXT, DB])mainnet(spec Spec) *EvmHandler[H,EXT, DB]{ + specID := spec.SpecID() + + return &EvmHandler[H, EXT, DB]{ + Cfg: NewHandlerCfg(specID), + InstructionTable: NewPlainInstructionTable(InstructionTable[H]{}), + Registers: []HandleRegister[H, EXT, DB]{}, + + + } +}*/ +/* +func specToGeneric[H Host, EXT any, DB Database]( + specID SpecId, + h *EvmHandler[H, EXT, DB], + isOptimism bool, +) (*EvmHandler[H, EXT, DB], error) { + switch specID { + case FRONTIER, FRONTIER_THAWING: + return createSpecHandler[H, EXT, DB](h, "frontier", isOptimism) + case HOMESTEAD, DAO_FORK: + return createSpecHandler[H, EXT, DB](h, "homestead", isOptimism) + case TANGERINE: + return createSpecHandler[H, EXT, DB](h, "tangerine", isOptimism) + case SPURIOUS_DRAGON: + return createSpecHandler[H, EXT, DB](h, "spurious_dragon", isOptimism) + case BYZANTIUM: + return createSpecHandler[H, EXT, DB](h, "byzantium", isOptimism) + case PETERSBURG, CONSTANTINOPLE: + return createSpecHandler[H, EXT, DB](h, "petersburg", isOptimism) + case ISTANBUL, MUIR_GLACIER: + return createSpecHandler[H, EXT, DB](h, "istanbul", isOptimism) + case BERLIN: + return createSpecHandler[H, EXT, DB](h, "berlin", isOptimism) + case LONDON, ARROW_GLACIER, GRAY_GLACIER: + return createSpecHandler[H, EXT, DB](h, "london", isOptimism) + case MERGE: + return createSpecHandler[H, EXT, DB](h, "merge", isOptimism) + case SHANGHAI: + return createSpecHandler[H, EXT, DB](h, "shanghai", isOptimism) + case CANCUN: + return createSpecHandler[H, EXT, DB](h, "cancun", isOptimism) + case PRAGUE: + return createSpecHandler[H, EXT, DB](h, "prague", isOptimism) + case PRAGUE_EOF: + return createSpecHandler[H, EXT, DB](h, "prague_eof", isOptimism) + case LATEST: + return createSpecHandler[H, EXT, DB](h, "latest", isOptimism) + } + + // Optimism-specific specs + if isOptimism { + switch specID { + case BEDROCK: + return createSpecHandler[H, EXT, DB](h, "bedrock", true) + case REGOLITH: + return createSpecHandler[H, EXT, DB](h, "regolith", true) + case CANYON: + return createSpecHandler[H, EXT, DB](h, "canyon", true) + case ECOTONE: + return createSpecHandler[H, EXT, DB](h, "ecotone", true) + case FJORD: + return createSpecHandler[H, EXT, DB](h, "fjord", true) + } + } + + return nil, fmt.Errorf("unsupported spec ID: %d", specID) +} + +*/ +/* +// Concrete spec implementations +type FrontierSpec struct{} +type HomesteadSpec struct{} +type TangerineSpec struct{} +type SpuriousDragonSpec struct{} +type ByzantiumSpec struct{} +type PetersburgSpec struct{} +type IstanbulSpec struct{} +type BerlinSpec struct{} +type LondonSpec struct{} +type MergeSpec struct{} +type ShanghaiSpec struct{} +type CancunSpec struct{} +type PragueSpec struct{} +type PragueEofSpec struct{} +type LatestSpec struct{} + +// Optimism-specific specs +type BedrockSpec struct{} +type RegolithSpec struct{} +type CanyonSpec struct{} +type EcotoneSpec struct{} +type FjordSpec struct{} + +func (s *FrontierSpec) Name() string { return "frontier" } +func (s *FrontierSpec) Version() uint { return 1 } +func (s *HomesteadSpec) Name() string { return "homestead" } +func (s *HomesteadSpec) Version() uint { return 1 } +func (s *TangerineSpec) Name() string { return "tangerine" } +func (s *TangerineSpec) Version() uint { return 1 } +func (s *SpuriousDragonSpec) Name() string { return "spurious_dragon" } +func (s *SpuriousDragonSpec) Version() uint { return 1 } +func (s *ByzantiumSpec) Name() string { return "byzantium" } +func (s *ByzantiumSpec) Version() uint { return 1 } +func (s *PetersburgSpec) Name() string { return "petersburg" } +func (s *PetersburgSpec) Version() uint { return 1 } +func (s *IstanbulSpec) Name() string { return "istanbul" } +func (s *IstanbulSpec) Version() uint { return 1 } +func (s *BerlinSpec) Name() string { return "berlin" } +func (s *BerlinSpec) Version() uint { return 1 } +func (s *LondonSpec) Name() string { return "london" } +func (s *LondonSpec) Version() uint { return 1 } +func (s *MergeSpec) Name() string { return "merge" } +func (s *MergeSpec) Version() uint { return 1 } +func (s *ShanghaiSpec) Name() string { return "shanghai" } +func (s *ShanghaiSpec) Version() uint { return 1 } +func (s *CancunSpec) Name() string { return "cancun" } +func (s *CancunSpec) Version() uint { return 1 } +func (s *PragueSpec) Name() string { return "prague" } +func (s *PragueSpec) Version() uint { return 1 } +func (s *PragueEofSpec) Name() string { return "prague_eof" } +func (s *PragueEofSpec) Version() uint { return 1 } +func (s *LatestSpec) Name() string { return "latest" } +func (s *LatestSpec) Version() uint { return 1 } +func (s *BedrockSpec) Name() string { return "bedrock" } +func (s *BedrockSpec) Version() uint { return 1 } +func (s *RegolithSpec) Name() string { return "regolith" } +func (s *RegolithSpec) Version() uint { return 1 } +func (s *CanyonSpec) Name() string { return "canyon" } +func (s *CanyonSpec) Version() uint { return 1 } +func (s *EcotoneSpec) Name() string { return "ecotone" } +func (s *EcotoneSpec) Version() uint { return 1 } +func (s *FjordSpec) Name() string { return "fjord" } +func (s *FjordSpec) Version() uint { return 1 } +*/ +// createSpecHandler now creates the appropriate spec implementation +/* +func createSpecHandler[H Host, EXT any, DB Database]( + h *EvmHandler[H, EXT, DB], + specName string, + isOptimism bool, +) (*EvmHandler[H, EXT, DB], error) { + newHandler := *h + + var spec Spec + switch specName { + case "frontier": + spec = &FrontierSpec{} + case "homestead": + spec = &HomesteadSpec{} + case "tangerine": + spec = &TangerineSpec{} + case "spurious_dragon": + spec = &SpuriousDragonSpec{} + case "byzantium": + spec = &ByzantiumSpec{} + case "petersburg": + spec = &PetersburgSpec{} + case "istanbul": + spec = &IstanbulSpec{} + case "berlin": + spec = &BerlinSpec{} + case "london": + spec = &LondonSpec{} + case "merge": + spec = &MergeSpec{} + case "shanghai": + spec = &ShanghaiSpec{} + case "cancun": + spec = &CancunSpec{} + case "prague": + spec = &PragueSpec{} + case "prague_eof": + spec = &PragueEofSpec{} + case "latest": + spec = &LatestSpec{} + /* + case "bedrock": + spec = &BedrockSpec{} + case "regolith": + spec = &RegolithSpec{} + case "canyon": + spec = &CanyonSpec{} + case "ecotone": + spec = &EcotoneSpec{} + case "fjord": + spec = &FjordSpec{} +*/ +/* + default: + return nil, fmt.Errorf("unknown spec: %s", specName) + } + + // Add the spec to the handler + newHandler = spec + return &newHandler, nil +} +*/ +/* +func withSpec[EXT any, DB Database, S Spec](h *EVMHandler[EXT, DB]) (*EVMHandler[EXT, DB], error) { + var spec S + rules := spec.Rules() + + // Create a new handler with the specific spec configuration + newHandler := &EVMHandler[EXT, DB]{ + cfg: h.cfg, + spec: spec, + rules: *rules, + } + + return newHandler, nil +}*/ + +/* +type HandleRegister[EXT any, DB Database] func(handler *EvmHandler[EXT, DB]) +type EvmHandler[EXT any, DB Database] Handler[EXT, DB] +type HandleRegisterBox[EXT any, DB Database] interface { + Call(handler *EvmHandler[EXT, DB]) +} +type HandleRegisters[EXT any, DB Database] struct { + Plain HandleRegister[EXT, DB] // Plain function register + Box HandleRegisterBox[EXT, DB] // Boxed function register +}*/ diff --git a/execution/evm/inner_evm_context.go b/execution/evm/inner_evm_context.go new file mode 100644 index 0000000..e4fafef --- /dev/null +++ b/execution/evm/inner_evm_context.go @@ -0,0 +1,62 @@ +package evm +type InnerEvmContext[DB Database] struct { + Env *Env + JournaledState JournaledState + DB DB + Error error + ValidAuthorizations []Address + L1BlockInfo *L1BlockInfo // For optimism feature +} +func NewInnerEvmContext[DB Database](db DB) InnerEvmContext[DB] { + SpecId:=DefaultSpecId() + return InnerEvmContext[DB]{ + Env: &Env{}, + JournaledState: NewJournalState(SpecId,make(map[Address]struct{})),//to be changed + DB: db, + Error: nil, + ValidAuthorizations: nil, + L1BlockInfo: nil, + } +} +func WithNewInnerDB[DB1, DB2 Database]( + inner InnerEvmContext[DB1], + db DB2, +) InnerEvmContext[DB2] { + return InnerEvmContext[DB2]{ + Env: inner.Env, + JournaledState: inner.JournaledState, + DB: db, + Error: inner.Error, + ValidAuthorizations: nil, + L1BlockInfo: inner.L1BlockInfo, + } +} +func (i *InnerEvmContext[DB]) TakeError() EvmError { + currentError := i.Error + i.Error = nil + return EvmError{Message: currentError.Error()} +} +type L1BlockInfo struct { + L1BaseFee U256 + L1FeeOverhead *U256 + L1BaseFeeScalar U256 + L1BlobBaseFee *U256 + L1BlobBaseFeeScalar *U256 + EmptyScalars bool +} +//Not being used in the code +func (inner InnerEvmContext[DB]) WithDB(db DB) InnerEvmContext[DB] { + return InnerEvmContext[DB]{ + Env: inner.Env, + JournaledState: inner.JournaledState, + DB: db, + Error: inner.Error, + ValidAuthorizations: nil, + L1BlockInfo: inner.L1BlockInfo, + } +} +//Not being used in the code +func (inner InnerEvmContext[DB]) specId() SpecId { + return inner.JournaledState.Spec +} + diff --git a/execution/evm/journal.go b/execution/evm/journal.go new file mode 100644 index 0000000..36c9f9c --- /dev/null +++ b/execution/evm/journal.go @@ -0,0 +1,50 @@ +package evm +import ( + "github.com/BlocSoc-iitr/selene/common" +) +type JournaledState struct { + State EvmState + TransientStorage TransientStorage + Logs []Log[LogData] + Depth uint + Journal [][]JournalEntry + Spec SpecId + WarmPreloadedAddresses map[Address]struct{} +} +func NewJournalState(spec SpecId,warmPreloadedAddresses map[Address]struct{}) JournaledState { + return JournaledState{ + State: nil, + TransientStorage: nil, + Logs: []Log[LogData] {}, + Depth: 0, + Journal: [][]JournalEntry{}, + Spec: spec, + WarmPreloadedAddresses: warmPreloadedAddresses, + } +} +type JournalCheckpoint struct { + Log_i uint + Journal_i uint +} +func (j JournaledState)setSpecId(spec SpecId) { + j.Spec = spec +} +type TransientStorage map[Key]U256 +type EvmState map[common.Address]Account +type Key struct { + Account common.Address + Slot U256 +} +type Log[T any] struct { + // The address which emitted this log. + Address Address `json:"address"` + // The log data. + Data T `json:"data"` +} +type LogData struct { + // The indexed topic list. + Topics []B256 `json:"topics"` + // The plain data. + Data Bytes `json:"data"` +} + diff --git a/execution/evm/journal_entry.go b/execution/evm/journal_entry.go new file mode 100644 index 0000000..cee45bd --- /dev/null +++ b/execution/evm/journal_entry.go @@ -0,0 +1,148 @@ +package evm +import( + "encoding/json" + "math/big" + ) +type JournalEntryType uint8 +const ( + AccountWarmedType JournalEntryType = iota + AccountDestroyedType + AccountTouchedType + BalanceTransferType + NonceChangeType + AccountCreatedType + StorageChangedType + StorageWarmedType + TransientStorageChangeType + CodeChangeType +) + +// Creating a struct for JournalEntry containing all possible fields that might be needed +type JournalEntry struct { + Type JournalEntryType + Address Address + Target Address // Used for AccountDestroyed + WasDestroyed bool // Used for AccountDestroyed + HadBalance U256 // Used for AccountDestroyed + Balance U256 // Used for BalanceTransfer + From Address // Used for BalanceTransfer + To Address // Used for BalanceTransfer + Key U256 // Used for Storage operations + HadValue U256 // Used for Storage operations +} + +func NewAccountWarmedEntry(address Address) *JournalEntry { + return &JournalEntry{ + Type: AccountWarmedType, + Address: address, + } +} + +// NewAccountDestroyedEntry creates a new journal entry for destroying an account +func NewAccountDestroyedEntry(address, target Address, wasDestroyed bool, hadBalance U256) *JournalEntry { + return &JournalEntry{ + Type: AccountDestroyedType, + Address: address, + Target: target, + WasDestroyed: wasDestroyed, + HadBalance: new(big.Int).Set(hadBalance), //to avoid mutating the original value (had balance not written directly) + } +} + +// NewAccountTouchedEntry creates a new journal entry for touching an account +func NewAccountTouchedEntry(address Address) *JournalEntry { + return &JournalEntry{ + Type: AccountTouchedType, + Address: address, + } +} + +// NewBalanceTransferEntry creates a new journal entry for balance transfer +func NewBalanceTransferEntry(from, to Address, balance U256) *JournalEntry { + return &JournalEntry{ + Type: BalanceTransferType, + From: from, + To: to, + Balance: new(big.Int).Set(balance), + } +} + +// NewNonceChangeEntry creates a new journal entry for nonce change +func NewNonceChangeEntry(address Address) *JournalEntry { + return &JournalEntry{ + Type: NonceChangeType, + Address: address, + } +} + +// NewAccountCreatedEntry creates a new journal entry for account creation +func NewAccountCreatedEntry(address Address) *JournalEntry { + return &JournalEntry{ + Type: AccountCreatedType, + Address: address, + } +} + +// NewStorageChangedEntry creates a new journal entry for storage change +func NewStorageChangedEntry(address Address, key, hadValue U256) *JournalEntry { + return &JournalEntry{ + Type: StorageChangedType, + Address: address, + Key: new(big.Int).Set(key), + HadValue: new(big.Int).Set(hadValue), + } +} + +// NewStorageWarmedEntry creates a new journal entry for storage warming +func NewStorageWarmedEntry(address Address, key U256) *JournalEntry { + return &JournalEntry{ + Type: StorageWarmedType, + Address: address, + Key: new(big.Int).Set(key), + } +} + +// NewTransientStorageChangeEntry creates a new journal entry for transient storage change +func NewTransientStorageChangeEntry(address Address, key, hadValue U256) *JournalEntry { + return &JournalEntry{ + Type: TransientStorageChangeType, + Address: address, + Key: new(big.Int).Set(key), + HadValue: new(big.Int).Set(hadValue), + } +} + +// NewCodeChangeEntry creates a new journal entry for code change +func NewCodeChangeEntry(address Address) *JournalEntry { + return &JournalEntry{ + Type: CodeChangeType, + Address: address, + } +} + +// MarshalJSON implements the json.Marshaler interface +func (j JournalEntry) MarshalJSON() ([]byte, error) { + return json.Marshal(struct { + Type JournalEntryType `json:"type"` + Address Address `json:"address"` + Target Address `json:"target,omitempty"` + WasDestroyed bool `json:"was_destroyed,omitempty"` + HadBalance U256 `json:"had_balance,omitempty"` + Balance U256 `json:"balance,omitempty"` + From Address `json:"from,omitempty"` + To Address `json:"to,omitempty"` + Key U256 `json:"key,omitempty"` + HadValue U256 `json:"had_value,omitempty"` + }{ + Type: j.Type, + Address: j.Address, + Target: j.Target, + WasDestroyed: j.WasDestroyed, + HadBalance: j.HadBalance, + Balance: j.Balance, + From: j.From, + To: j.To, + Key: j.Key, + HadValue: j.HadValue, + }) +} \ No newline at end of file diff --git a/execution/evm/precompiles.go b/execution/evm/precompiles.go new file mode 100644 index 0000000..4eddd8b --- /dev/null +++ b/execution/evm/precompiles.go @@ -0,0 +1,121 @@ +package evm +import ( + "sync" +) + func (e *EvmContext[DB]) SetPrecompiles(precompiles ContextPrecompiles[DB]) { + for i, address := range precompiles.Inner.StaticRef.Addresses { + e.Inner.JournaledState.WarmPreloadedAddresses[i] = address + } + e.Precompiles = precompiles + } + type ContextPrecompiles[DB Database] struct { + Inner PrecompilesCow[DB] + } + func DefaultContextPrecompiles[DB Database]() ContextPrecompiles[DB] { + return ContextPrecompiles[DB]{ + Inner: NewPrecompilesCow[DB](), + } + } + func NewPrecompilesCow[DB Database]() PrecompilesCow[DB] { + return PrecompilesCow[DB]{ + Owned: make(map[Address]ContextPrecompile[DB]), + } + } + type PrecompilesCow[DB Database] struct { + isStatic bool + StaticRef *Precompiles + Owned map[Address]ContextPrecompile[DB] + } + type Precompiles struct { + Inner map[Address]Precompile + Addresses map[Address]struct{} + } + type Precompile struct { + precompileType string // "Standard", "Env", "Stateful", or "StatefulMut" + standard StandardPrecompileFn + env EnvPrecompileFn + stateful *StatefulPrecompileArc + statefulMut *StatefulPrecompileBox + } + type StandardPrecompileFn func(input *Bytes, gasLimit uint64) PrecompileResult + type EnvPrecompileFn func(input *Bytes, gasLimit uint64, env *Env) PrecompileResult + type StatefulPrecompile interface { + Call(bytes *Bytes, gasLimit uint64, env *Env) PrecompileResult + } + type StatefulPrecompileMut interface { + CallMut(bytes *Bytes, gasLimit uint64, env *Env) PrecompileResult + Clone() StatefulPrecompileMut + } + + // Doubt + type StatefulPrecompileArc struct { + sync.RWMutex + impl StatefulPrecompile + } + + // StatefulPrecompileBox is a mutable reference to a StatefulPrecompileMut + type StatefulPrecompileBox struct { + impl StatefulPrecompileMut + } + type ContextPrecompile[DB Database] struct { + precompileType string // "Ordinary", "ContextStateful", or "ContextStatefulMut" + ordinary *Precompile + contextStateful *ContextStatefulPrecompileArc[DB] + contextStatefulMut *ContextStatefulPrecompileBox[DB] + } + + // ContextStatefulPrecompileArc is a thread-safe reference to a ContextStatefulPrecompile + type ContextStatefulPrecompileArc[DB Database] struct { + sync.RWMutex + impl ContextStatefulPrecompile[DB] + } + + // ContextStatefulPrecompileBox is a mutable reference to a ContextStatefulPrecompileMut + type ContextStatefulPrecompileBox[DB Database] struct { + impl ContextStatefulPrecompileMut[DB] + } + type ContextStatefulPrecompile[DB Database] interface { + Call(bytes *Bytes, gasLimit uint64, evmCtx *InnerEvmContext[DB]) PrecompileResult + } + + // ContextStatefulPrecompileMut interface for mutable stateful precompiles with context + type ContextStatefulPrecompileMut[DB Database] interface { + CallMut(bytes *Bytes, gasLimit uint64, evmCtx *InnerEvmContext[DB]) PrecompileResult + Clone() ContextStatefulPrecompileMut[DB] + } + type PrecompileResult struct { + output *PrecompileOutput + err PrecompileErrorStruct //Doubt + } + type PrecompileOutput struct { + GasUsed uint64 + Bytes []byte + } + type PrecompileErrorStruct struct { + errorType string + message string + } + + const ( + ErrorOutOfGas = "OutOfGas" + ErrorBlake2WrongLength = "Blake2WrongLength" + ErrorBlake2WrongFinalFlag = "Blake2WrongFinalIndicatorFlag" + ErrorModexpExpOverflow = "ModexpExpOverflow" + ErrorModexpBaseOverflow = "ModexpBaseOverflow" + ErrorModexpModOverflow = "ModexpModOverflow" + ErrorBn128FieldPointNotMember = "Bn128FieldPointNotAMember" + ErrorBn128AffineGFailedCreate = "Bn128AffineGFailedToCreate" + ErrorBn128PairLength = "Bn128PairLength" + ErrorBlobInvalidInputLength = "BlobInvalidInputLength" + ErrorBlobMismatchedVersion = "BlobMismatchedVersion" + ErrorBlobVerifyKzgProofFailed = "BlobVerifyKzgProofFailed" + ErrorOther = "Other" + ) + + // Error implementation for PrecompileError + func (e PrecompileErrorStruct) Error() string { + if e.message != "" { + return e.message + } + return e.errorType + } \ No newline at end of file From 77a02b7c58275705912c3f6b4df539c5efa46faa Mon Sep 17 00:00:00 2001 From: x-senpai-x Date: Mon, 28 Oct 2024 15:49:03 +0530 Subject: [PATCH 2/4] evm env and handler dependencies --- execution/evm/database.go | 37 ++++++ execution/evm/env.go | 180 +++++++++++++++++++++++++++ execution/evm/evm.go | 211 ++++++++++++++++++++++++++++++++ execution/evm/execution.go | 28 +++++ execution/evm/frame.go | 87 +++++++++++++ execution/evm/post_execution.go | 20 +++ execution/evm/pre_execution.go | 17 +++ execution/evm/result.go | 60 +++++++++ 8 files changed, 640 insertions(+) create mode 100644 execution/evm/database.go create mode 100644 execution/evm/env.go create mode 100644 execution/evm/evm.go create mode 100644 execution/evm/execution.go create mode 100644 execution/evm/frame.go create mode 100644 execution/evm/post_execution.go create mode 100644 execution/evm/pre_execution.go create mode 100644 execution/evm/result.go diff --git a/execution/evm/database.go b/execution/evm/database.go new file mode 100644 index 0000000..a89b024 --- /dev/null +++ b/execution/evm/database.go @@ -0,0 +1,37 @@ +package evm +import( + "errors" + "math/big" +) + type Database interface { + Basic(address Address) (AccountInfo, error) + BlockHash(number uint64) (B256, error) + Storage(address Address, index U256) (U256, error) + CodeByHash(codeHash B256) (Bytecode, error) + } + type EmptyDB struct{} + func (db *EmptyDB) Basic(address Address) (AccountInfo, error) { + return AccountInfo{}, errors.New("EmptyDB: Basic not implemented") + } + func (db *EmptyDB) BlockHash(number uint64) (B256, error) { + return B256{}, errors.New("EmptyDB: BlockHash not implemented") + } + func (db *EmptyDB) Storage(address Address, index U256) (U256, error) { + return big.NewInt(0), errors.New("EmptyDB: Storage not implemented") + } + func (db *EmptyDB) CodeByHash(codeHash B256) (Bytecode, error) { + return Bytecode{}, errors.New("EmptyDB: CodeByHash not implemented") + } + func NewEmptyDB() *EmptyDB { + return &EmptyDB{} + } +type DatabaseError struct { + msg string + err error +} +func (e *DatabaseError) Error() string { + if e.err != nil { + return e.err.Error() + } + return e.msg +} \ No newline at end of file diff --git a/execution/evm/env.go b/execution/evm/env.go new file mode 100644 index 0000000..cd0e15b --- /dev/null +++ b/execution/evm/env.go @@ -0,0 +1,180 @@ +package evm + +import ( + "encoding/json" + "fmt" + "math/big" +) +type Env struct{ + Cfg CfgEnv + Block BlockEnv + Tx TxEnv +} +func NewEnv() *Env { + return &Env{} +} + +type AccessListItem struct { + Address Address + StorageKeys []B256 +} +type Signature struct { + V uint8 // Recovery ID + R *big.Int // R component of signature + S *big.Int // S component of signature +} +type AuthorizationListType int +const ( + Signed AuthorizationListType = iota + Recovered +) +type AuthorizationList struct { + Type AuthorizationListType + SignedAuthorizations []SignedAuthorization + RecoveredAuthorizations []RecoveredAuthorization +} +type ChainID uint64 +type OptionalNonce struct { + Nonce *uint64 // nil if no nonce is provided +} +type Authorization struct { + ChainID ChainID // The chain ID of the authorization + Address Address // The address of the authorization + Nonce OptionalNonce // The nonce for the authorization +} +type SignedAuthorization struct { + Inner Authorization // Embedded authorization data + Signature Signature // Signature associated with authorization +} + +type RecoveredAuthorization struct { + Inner Authorization // Embedded authorization data + Authority *Address // Optional authority address +} +type TransactTo = TxKind; +type TxKind struct { + Type TxKindType + Address *Address // Address is nil for Create type +} +type TxKindType int +const ( + Create2 TxKindType = iota + Call2 +) +type CfgEnv struct { + ChainID uint64 `json:"chain_id"` + KzgSettings *EnvKzgSettings `json:"kzg_settings,omitempty"` + PerfAnalyseCreatedBytecodes AnalysisKind `json:"perf_analyse_created_bytecodes"` + LimitContractCodeSize *uint64 `json:"limit_contract_code_size,omitempty"` + MemoryLimit uint64 `json:"memory_limit,omitempty"` // Consider using a pointer if optional + DisableBalanceCheck bool `json:"disable_balance_check,omitempty"` + DisableBlockGasLimit bool `json:"disable_block_gas_limit,omitempty"` + DisableEIP3607 bool `json:"disable_eip3607,omitempty"` + DisableGasRefund bool `json:"disable_gas_refund,omitempty"` + DisableBaseFee bool `json:"disable_base_fee,omitempty"` + DisableBeneficiaryReward bool `json:"disable_beneficiary_reward,omitempty"` +} +type BlockEnv struct { + Number U256 `json:"number"` + Coinbase Address `json:"coinbase"` + Timestamp U256 `json:"timestamp"` + GasLimit U256 `json:"gas_limit"` + BaseFee U256 `json:"basefee"` + Difficulty U256 `json:"difficulty"` + Prevrandao *B256 `json:"prevrandao,omitempty"` + BlobExcessGasAndPrice *BlobExcessGasAndPrice `json:"blob_excess_gas_and_price,omitempty"` +} +type BlobExcessGasAndPrice struct { + ExcessGas uint64 `json:"excess_gas"` + BlobGasPrice uint64 `json:"blob_gas_price"` +} +type EnvKzgSettings struct { + Mode string `json:"mode"` + Custom *KzgSettings `json:"custom,omitempty"` +} +// KzgSettings represents custom KZG settings. +type KzgSettings struct { + // Define fields for KzgSettings based on your requirements. +} +// AnalysisKind represents the type of analysis for created bytecodes. +type AnalysisKind int +const ( + Raw AnalysisKind = iota + Analyse +) + +// MarshalJSON customizes the JSON marshalling for AnalysisKind. +func (ak AnalysisKind) MarshalJSON() ([]byte, error) { + switch ak { + case Raw: + return json.Marshal("raw") + case Analyse: + return json.Marshal("analyse") + default: + return json.Marshal("unknown") + } +} + +// UnmarshalJSON customizes the JSON unmarshalling for AnalysisKind. +func (ak *AnalysisKind) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return err + } + switch s { + case "raw": + *ak = Raw + case "analyse": + *ak = Analyse + default: + return fmt.Errorf("unknown AnalysisKind: %s", s) + } + return nil +} +//Not in use : To be verified +func NewSignature(v uint8, r, s *big.Int) *Signature { + return &Signature{ + V: v, + R: new(big.Int).Set(r), + S: new(big.Int).Set(s), + } +} +//Not in use : To be verified +func (s *Signature) ToRawSignature() []byte { + rBytes := s.R.Bytes() + sBytes := s.S.Bytes() + signature := make([]byte, 64) + copy(signature[32-len(rBytes):32], rBytes) + copy(signature[64-len(sBytes):], sBytes) + return signature +} +//Not in use : To be verified +func FromRawSignature(data []byte, v uint8) (*Signature, error) { + if len(data) != 64 { + return nil, fmt.Errorf("invalid signature length: got %d, want 64", len(data)) + } + + r := new(big.Int).SetBytes(data[:32]) + s := new(big.Int).SetBytes(data[32:]) + + return &Signature{ + V: v, + R: r, + S: s, + }, nil +} + +// Verify verifies the signature against a message hash and public key +/* +func (s *Signature) Verify(pubKey *ecdsa.PublicKey, hash []byte) bool { + // Check if r and s are in the valid range + if s.R.Sign() <= 0 || s.S.Sign() <= 0 { + return false + } + if s.R.Cmp(pubKey.Params().N) >= 0 || s.S.Cmp(pubKey.Params().N) >= 0 { + return false + } + + // Verify the signature + return ecdsa.Verify(pubKey, hash, s.R, s.S) +}*/ diff --git a/execution/evm/evm.go b/execution/evm/evm.go new file mode 100644 index 0000000..1580e70 --- /dev/null +++ b/execution/evm/evm.go @@ -0,0 +1,211 @@ +package evm +import "bytes" +type Evm[EXT interface{}, DB Database] struct { + Context Context[EXT, DB] + Handler Handler[Context[EXT, DB], EXT, DB] +} +func NewEvm[EXT any, DB Database](context Context[EXT, DB], handler Handler[Context[EXT, DB], EXT, DB]) Evm[EXT, DB] { + context.Evm.Inner.JournaledState.SetSpecId(handler.Cfg.specID) + return Evm[EXT, DB]{ + Context: context, + Handler: handler, + } +} +func (e Evm[EXT, DB]) specId() SpecId { + return e.Handler.Cfg.specID +} +func (e Evm[EXT, DB]) IntoContextWithHandlerCfg() ContextWithHandlerCfg[EXT, DB] { + return ContextWithHandlerCfg[EXT, DB]{ + Context: e.Context, + Cfg: e.Handler.Cfg, + } +} +var EOF_MAGIC_BYTES = []byte{0xef, 0x00} +type EVMResult[D any] EVMResultGeneric[ResultAndState, D] +func (e *Evm[EXT, DB]) Transact() EVMResult[DatabaseError] { + initialGasSpend, err := e.preverifyTransactionInner() + if len(err.Message) != 0 { + e.clear() + return EVMResult[DatabaseError]{Err: err} + } + output := e.TransactPreverifiedInner(initialGasSpend) + output2, err := e.Handler.PostExecution.End(&e.Context, EVMResultGeneric[ResultAndState, EvmError](output)) + e.clear() + return EVMResult[DatabaseError]{Err: err, Value: output2} +} +func (e *Evm[EXT, DB]) preverifyTransactionInner() (uint64, EvmError) { + err := e.Handler.Validation.Env(e.Context.Evm.Inner.Env) //? + if err != nil { + return 0, EvmError{Message: err.Error()} + } + initialGasSpend, err := e.Handler.Validation.InitialTxGas(e.Context.Evm.Inner.Env) + err = e.Handler.Validation.TxAgainstState(&e.Context) + return initialGasSpend, EvmError{} +} +func (e *Evm[EXT, DB]) clear() { + e.Handler.PostExecution.Clear(&e.Context) +} +func (e *Evm[EXT, DB]) TransactPreverifiedInner(initialGasSpend uint64) EVMResult[DatabaseError] { + specId := e.Handler.Cfg.specID + ctx := &e.Context + preExec := e.Handler.PreExecution + err := preExec.LoadAccounts(ctx) + if err != nil { + return EVMResult[DatabaseError]{Err: err} + } + precompiles := preExec.LoadPrecompilesFunction() + ctx.Evm.SetPrecompiles(precompiles) + err_caller := preExec.DeductCaller(ctx) //? + if err_caller.Err != nil { + return EVMResult[DatabaseError](err_caller) + } + gasLimit := ctx.Evm.Inner.Env.Tx.GasLimit - initialGasSpend + exec := e.Handler.Execution + var firstFrameOrResult FrameOrResult + if ctx.Evm.Inner.Env.Tx.TransactTo.Type == Call2 { + result, err := exec.Call(ctx, (&CallInputs{}).NewBoxed(&ctx.Evm.Inner.Env.Tx, gasLimit)) + if len(err.Message) != 0 { + return EVMResult[DatabaseError]{Err: err} + } + firstFrameOrResult = result + } else { + if specId.IsEnabledIn(PRAGUE_EOF) && bytes.Equal(ctx.Evm.Inner.Env.Tx.Data[:2], EOF_MAGIC_BYTES) { + result, err := exec.EOFCreate(ctx, EOFCreateInputs{}.NewTx(&ctx.Evm.Inner.Env.Tx, gasLimit)) + if len(err.Message) != 0 { + return EVMResult[DatabaseError]{Err: err} + } + firstFrameOrResult = result + } else { + result, err := exec.Create(ctx, (&CreateInputs{}).NewBoxed(&ctx.Evm.Inner.Env.Tx, gasLimit)) + if len(err.Message) != 0 { + return EVMResult[DatabaseError]{Err: err} + } + firstFrameOrResult = result + } + } + var result FrameResult + if firstFrameOrResult.Type == Frame_FrameOrResult { + result_new, err_new := e.RunTheLoop(firstFrameOrResult.Frame) + if len(err_new.Message) != 0 { + return EVMResult[DatabaseError]{Err: err_new} + } + result = result_new + } else { + result = firstFrameOrResult.Result + } + ctx = &e.Context + err = e.Handler.Execution.LastFrameReturn(ctx, &result) + postExec := e.Handler.PostExecution + postExec.ReimburseCaller(ctx, result.Gas()) //! + postExec.RewardBeneficiary(ctx, result.Gas()) //! + res, err := postExec.Output(ctx, result) + return EVMResult[DatabaseError]{Value: res, Err: err} +} +func (e *Evm[EXT, DB]) RunTheLoop(firstFrame Frame) (FrameResult, EvmError) { + callStack := make([]Frame, 0, 1025) + callStack = append(callStack, firstFrame) + + var sharedMemory SharedMemory + if e.Context.Evm.Inner.Env.Cfg.MemoryLimit > 0 { + sharedMemory = SharedMemory{}.NewWithMemoryLimit(e.Context.Evm.Inner.Env.Cfg.MemoryLimit) + } else { + sharedMemory = SharedMemory{}.New() + } + sharedMemory.NewContext() + + stackFrame := &callStack[len(callStack) - 1] + + for { + nextAction, err := e.Handler.ExecuteFrame(stackFrame,&sharedMemory,&e.Context) + if err != nil { + return FrameResult{}, EvmError{Message: err.Error()} + } + // Take error from the context, if any + if err := e.Context.Evm.Inner.TakeError(); len(err.Message) != 0 { + return FrameResult{}, err + } + exec := &e.Handler.Execution + var frameOrResult FrameOrResult + { + if nextAction.actionType == ActionTypeCall { + res, err := exec.Call(&e.Context, nextAction.callInputs) + if len(err.Message) != 0 { + return FrameResult{}, err + } + frameOrResult = res + } else if nextAction.actionType == ActionTypeCreate { + res, err := exec.Create(&e.Context, nextAction.createInputs) + if len(err.Message) != 0 { + return FrameResult{},err + } + frameOrResult = res + } else if nextAction.actionType == ActionTypeEOFCreate { + res, err := exec.EOFCreate(&e.Context, *nextAction.eofCreateInputs) + if len(err.Message) != 0 { + return FrameResult{},err + } + frameOrResult = res + } else if nextAction.actionType == ActionTypeReturn { + sharedMemory.FreeContext() + returnedFrame := callStack[len(callStack) - 1] + callStack = callStack[:len(callStack) - 1] + ctx := &e.Context + + var result FrameResult + frameOrResult2 := FrameOrResult{ + Type: Result_FrameOrResult, + Result: result, + } + switch returnedFrame.Type { + case Call_Frame: + result.ResultType = Call + res, err := exec.CallReturn(ctx, returnedFrame.Call, *nextAction.result) + if len(err.Message) != 0 { + return FrameResult{}, err + } + result.Call = &res + case Create_Frame: + result.ResultType = Create + res, err := exec.CreateReturn(ctx, returnedFrame.Create, *nextAction.result) + if len(err.Message) != 0 { + return FrameResult{}, err + } + result.Create = &res + case EOFCreate_Frame: + result.ResultType = EOFCreate + res, err := exec.EOFCreateReturn(ctx, returnedFrame.EOFCreate, *nextAction.result) + if len(err.Message) != 0 { + return FrameResult{}, err + } + result.Create = &res + } + frameOrResult = frameOrResult2 + } else { + return FrameResult{}, EvmError{ + Message: "InterpreterAction::None is not expected", + } + } + } + switch frameOrResult.Type { + case Frame_FrameOrResult: + sharedMemory.NewContext() + callStack = append(callStack, frameOrResult.Frame) + stackFrame = &callStack[len(callStack) - 1] + case Result_FrameOrResult: + topFrame := &callStack[len(callStack) - 1] + if topFrame == nil { + return frameOrResult.Result, EvmError{} + } + stackFrame = topFrame + ctx := &e.Context + switch frameOrResult.Result.ResultType { + case Call: + exec.InsertCallOutcome(ctx, stackFrame, &sharedMemory, *frameOrResult.Result.Call) + case Create: + exec.InsertCreateOutcome(ctx, stackFrame, *frameOrResult.Result.Create) + case EOFCreate: + exec.InsertCreateOutcome(ctx, stackFrame, *frameOrResult.Result.Create) + } + } + } +} \ No newline at end of file diff --git a/execution/evm/execution.go b/execution/evm/execution.go new file mode 100644 index 0000000..e70114d --- /dev/null +++ b/execution/evm/execution.go @@ -0,0 +1,28 @@ +package evm + +type LastFrameReturnHandle[EXT any, DB Database] func(*Context[EXT, DB], *FrameResult) EvmError +type ExecuteFrameHandle[EXT any, DB Database] func(*Frame, *SharedMemory, *InstructionTables[Context[EXT, DB]], *Context[EXT, DB]) (InterpreterAction, EvmError) +type FrameCallHandle[EXT any, DB Database] func(*Context[EXT, DB], *CallInputs) (FrameOrResult, EvmError) +type FrameCallReturnHandle[EXT any, DB Database] func(*Context[EXT, DB], *CallFrame, InterpreterResult) (CallOutcome, EvmError) +type InsertCallOutcomeHandle[EXT any, DB Database] func(*Context[EXT, DB], *Frame, *SharedMemory, CallOutcome) EvmError +type FrameCreateHandle[EXT any, DB Database] func(*Context[EXT, DB], *CreateInputs) (FrameOrResult, EvmError) +type FrameCreateReturnHandle[EXT any, DB Database] func(*Context[EXT, DB], *CreateFrame, InterpreterResult) (CreateOutcome, EvmError) +type InsertCreateOutcomeHandle[EXT any, DB Database] func(*Context[EXT, DB], *Frame, CreateOutcome) EvmError +type FrameEOFCreateHandle[EXT any, DB Database] func(*Context[EXT, DB], EOFCreateInputs) (FrameOrResult, EvmError) +type FrameEOFCreateReturnHandle[EXT any, DB Database] func(*Context[EXT, DB], *EOFCreateFrame, InterpreterResult) (CreateOutcome, EvmError) +type InsertEOFCreateOutcomeHandle[EXT any, DB Database] func(*Context[EXT, DB], *CallFrame, InterpreterResult) (CallOutcome, EvmError) + +type ExecutionHandler[EXT interface{}, DB Database] struct { + LastFrameReturn LastFrameReturnHandle[EXT, DB] + ExecuteFrame ExecuteFrameHandle[EXT, DB] + Call FrameCallHandle[EXT, DB] + CallReturn FrameCallReturnHandle[EXT, DB] + InsertCallOutcome InsertCallOutcomeHandle[EXT, DB] + Create FrameCreateHandle[EXT, DB] + CreateReturn FrameCreateReturnHandle[EXT, DB] + InsertCreateOutcome InsertCreateOutcomeHandle[EXT, DB] + EOFCreate FrameEOFCreateHandle[EXT, DB] + EOFCreateReturn FrameEOFCreateReturnHandle[EXT, DB] + InsertEOFCreateOutcome InsertEOFCreateOutcomeHandle[EXT, DB] +} + diff --git a/execution/evm/frame.go b/execution/evm/frame.go new file mode 100644 index 0000000..71744bb --- /dev/null +++ b/execution/evm/frame.go @@ -0,0 +1,87 @@ +package evm +type CallFrame struct { + ReturnMemoryRange Range + FrameData FrameData +} +type CreateFrame struct { + CreatedAddress Address + FrameData FrameData +} + +type EOFCreateFrame struct { + CreatedAddress Address + FrameData FrameData +} + +type FrameData struct { + Checkpoint JournalCheckpoint + Interpreter Interpreter +} + +type CallOutcome struct { + Result InterpreterResult + MemoryOffset Range +} + +type CreateOutcome struct { + Result InterpreterResult + Address *Address +} + +type FrameType uint8 + +const ( + Call_Frame FrameType = iota + Create_Frame + EOFCreate_Frame +) + +type Frame struct { + Type FrameType + Call *CallFrame + Create *CreateFrame + EOFCreate *EOFCreateFrame +} + +// FrameResultType represents the type of FrameResult. +type FrameResultType int + +const ( + Call FrameResultType = iota + Create + EOFCreate +) + +// FrameResult represents the outcome of a frame, which can be Call, Create, or EOFCreate. +type FrameResult struct { + ResultType FrameResultType + Call *CallOutcome + Create *CreateOutcome +} + +type FrameOrResultType uint8 + +const ( + Frame_FrameOrResult FrameOrResultType = iota + Result_FrameOrResult +) + +type FrameOrResult struct { + Type FrameOrResultType + Frame Frame + Result FrameResult +} + +func (f *FrameResult) Gas() *Gas { + if f.ResultType == Call { + return &f.Call.Result.Gas + } else if f.ResultType == Create { + return &f.Create.Result.Gas + } else { + return &f.Create.Result.Gas + } +} +type Range struct { + Start int `json:"start"` + End int `json:"end"` +} \ No newline at end of file diff --git a/execution/evm/post_execution.go b/execution/evm/post_execution.go new file mode 100644 index 0000000..2a42398 --- /dev/null +++ b/execution/evm/post_execution.go @@ -0,0 +1,20 @@ +package evm +type PostExecutionHandler[EXT any, DB Database] struct { + ReimburseCaller ReimburseCallerHandle[EXT, DB] + RewardBeneficiary RewardBeneficiaryHandle[EXT, DB] + Output OutputHandle[EXT, DB] + End EndHandle[EXT, DB] + Clear ClearHandle[EXT, DB] +} +type ReimburseCallerHandle[EXT any, DB Database] func(ctx *Context[EXT, DB], gas *Gas) EVMResultGeneric[struct{}, any] +type RewardBeneficiaryHandle[EXT any, DB Database] ReimburseCallerHandle[EXT, DB] +type OutputHandle[EXT any, DB Database] func(ctx *Context[EXT, DB], frameResult FrameResult) (ResultAndState, EvmError) +type EndHandle[EXT any, DB Database] func(ctx *Context[EXT, DB], result EVMResultGeneric[ResultAndState, EvmError]) (ResultAndState, EvmError) +type ClearHandle[EXT any, DB Database] func(ctx *Context[EXT, DB]) +type LoadPrecompilesHandle[DB Database] func() ContextPrecompiles[DB] +type LoadAccountsHandle[EXT any, DB Database] func(ctx *Context[EXT, DB]) error +type DeductCallerHandle[EXT any, DB Database] func(ctx *Context[EXT, DB]) EVMResultGeneric[ ResultAndState, DatabaseError] +type EVMResultGeneric[T any, DBError any] struct { + Value T + Err error +} diff --git a/execution/evm/pre_execution.go b/execution/evm/pre_execution.go new file mode 100644 index 0000000..b17073d --- /dev/null +++ b/execution/evm/pre_execution.go @@ -0,0 +1,17 @@ +package evm +type PreExecutionHandler[EXT any, DB Database] struct { + LoadPrecompiles LoadPrecompilesHandle[DB] + LoadAccounts LoadAccountsHandle[EXT, DB] + DeductCaller DeductCallerHandle[EXT, DB] +} +type ValidationHandler[EXT any, DB Database] struct { + InitialTxGas ValidateInitialTxGasHandle[DB] + TxAgainstState ValidateTxEnvAgainstState[EXT, DB] + Env ValidateEnvHandle[DB] +} +type ValidateEnvHandle[DB Database] func(env *Env) error +type ValidateTxEnvAgainstState[EXT any, DB Database] func(ctx *Context[EXT, DB]) error +type ValidateInitialTxGasHandle[DB Database] func(env *Env) (uint64, error) +func (p *PreExecutionHandler[EXT, DB]) LoadPrecompilesFunction() ContextPrecompiles[DB] { + return p.LoadPrecompiles() +} diff --git a/execution/evm/result.go b/execution/evm/result.go new file mode 100644 index 0000000..776f332 --- /dev/null +++ b/execution/evm/result.go @@ -0,0 +1,60 @@ +package evm +import "github.com/ethereum/go-ethereum/core/types" +type ResultAndState struct{ + Result ExecutionResult + State EvmState +} +type ExecutionResult struct { + Type string // "Success", "Revert", or "Halt" + Reason interface{} // SuccessReason or HaltReason + GasUsed uint64 + GasRefunded uint64 // Only for Success + Logs []types.Log // Only for Success + Output Output // Only for Success and Revert +} +type SuccessReason string +const ( + SStop SuccessReason = "Stop" + SReturn SuccessReason = "Return" + SSelfDestruct SuccessReason = "SelfDestruct" + SEofReturnContract SuccessReason = "EofReturnContract" +) +type Output struct { + Type string + Data []byte + Address *Address // Only for Create type +} +type HaltReason string +const ( + HOutOfGas HaltReason = "OutOfGas" + HOpcodeNotFound HaltReason = "OpcodeNotFound" + HInvalidFEOpcode HaltReason = "InvalidFEOpcode" + HInvalidJump HaltReason = "InvalidJump" + HNotActivated HaltReason = "NotActivated" + HStackUnderflow HaltReason = "StackUnderflow" + HStackOverflow HaltReason = "StackOverflow" + HOutOfOffset HaltReason = "OutOfOffset" + HCreateCollision HaltReason = "CreateCollision" + HPrecompileError HaltReason = "PrecompileError" + HNonceOverflow HaltReason = "NonceOverflow" + HCreateContractSizeLimit HaltReason = "CreateContractSizeLimit" + HCreateContractStartingWithEF HaltReason = "CreateContractStartingWithEF" + HCreateInitCodeSizeLimit HaltReason = "CreateInitCodeSizeLimit" + HOverflowPayment HaltReason = "OverflowPayment" + HStateChangeDuringStaticCall HaltReason = "StateChangeDuringStaticCall" + HCallNotAllowedInsideStatic HaltReason = "CallNotAllowedInsideStatic" + HOutOfFunds HaltReason = "OutOfFunds" + HCallTooDeep HaltReason = "CallTooDeep" + HEofAuxDataOverflow HaltReason = "EofAuxDataOverflow" + HEofAuxDataTooSmall HaltReason = "EofAuxDataTooSmall" + HEOFFunctionStackOverflow HaltReason = "EOFFunctionStackOverflow" +) +type EvmError struct { + Message string + Data []byte +} + +// Error implements the error interface +func (e EvmError) Error() string { + return e.Message +} From 0cdc8c6079370c7feb06ac6f5fcf65c30102361f Mon Sep 17 00:00:00 2001 From: x-senpai-x Date: Mon, 28 Oct 2024 16:07:32 +0530 Subject: [PATCH 3/4] specs ,optimism build flag and dependencies for handler --- execution/evm/host.go | 72 ++++++ execution/evm/non_optimism.go | 8 + execution/evm/optimism.go | 8 + execution/evm/specs_common.go | 33 +++ execution/evm/specs_default.go | 431 ++++++++++++++++++++++++++++++++ execution/evm/specs_optimism.go | 282 +++++++++++++++++++++ execution/evm/tables.go | 35 +++ 7 files changed, 869 insertions(+) create mode 100644 execution/evm/host.go create mode 100644 execution/evm/non_optimism.go create mode 100644 execution/evm/optimism.go create mode 100644 execution/evm/specs_common.go create mode 100644 execution/evm/specs_default.go create mode 100644 execution/evm/specs_optimism.go create mode 100644 execution/evm/tables.go diff --git a/execution/evm/host.go b/execution/evm/host.go new file mode 100644 index 0000000..d73074b --- /dev/null +++ b/execution/evm/host.go @@ -0,0 +1,72 @@ +package evm + +type Host interface { + // // Returns a reference to the environment. + // Env() *Env + + // // Returns a mutable reference to the environment. + // EnvMut() *Env + + // // Load an account. + // // Returns (is_cold, is_new_account) + // LoadAccount(address Address) (LoadAccountResult, bool) + + // // Get the block hash of the given block `number`. + // BlockHash(number uint64) (B256, bool) + + // // Get balance of `address` and if the account is cold. + // Balance(address Address) (U256, bool, bool) + + // // Get code of `address` and if the account is cold. + // Code(address Address) (Bytes, bool, bool) + + // // Get code hash of `address` and if the account is cold. + // CodeHash(address Address) (B256, bool, bool) + + // // Get storage value of `address` at `index` and if the account is cold. + // SLoad(address Address, index U256) (U256, bool, bool) + + // // Set storage value of account address at index. + // // Returns (original, present, new, is_cold). + // SStore(address Address, index U256, value U256) (SStoreResult, bool) + + // // Get the transient storage value of `address` at `index`. + // TLoad(address Address, index U256) U256 + + // // Set the transient storage value of `address` at `index`. + // TStore(address Address, index U256, value U256) + + // // Emit a log owned by `address` with given `LogData`. + // Log(log Log [any]) + + // // Mark `address` to be deleted, with funds transferred to `target`. + // SelfDestruct(address Address, target Address) (SelfDestructResult, bool) +} + +// SStoreResult represents the result of an `sstore` operation. +type SStoreResult struct { + // Value of the storage when it is first read + OriginalValue U256 + // Current value of the storage + PresentValue U256 + // New value that is set + NewValue U256 + // Is storage slot loaded from database + IsCold bool +} + +// LoadAccountResult represents the result of loading an account from the journal state. +type LoadAccountResult struct { + // Is account cold loaded + IsCold bool + // Is account empty; if true, the account is not created. + IsEmpty bool +} + +// SelfDestructResult represents the result of a selfdestruct instruction. +type SelfDestructResult struct { + HadValue bool + TargetExists bool + IsCold bool + PreviouslyDestroyed bool +} \ No newline at end of file diff --git a/execution/evm/non_optimism.go b/execution/evm/non_optimism.go new file mode 100644 index 0000000..9c0a9cc --- /dev/null +++ b/execution/evm/non_optimism.go @@ -0,0 +1,8 @@ +//go:build !optimism_default_handler || negate_optimism_default_handler +// +build !optimism_default_handler negate_optimism_default_handler + +package evm + +func getDefaultOptimismSetting() bool { + return false +} \ No newline at end of file diff --git a/execution/evm/optimism.go b/execution/evm/optimism.go new file mode 100644 index 0000000..9333844 --- /dev/null +++ b/execution/evm/optimism.go @@ -0,0 +1,8 @@ +//go:build optimism_default_handler && !negate_optimism_default_handler +// +build optimism_default_handler,!negate_optimism_default_handler + +package evm + +func getDefaultOptimismSetting() bool { + return true +} \ No newline at end of file diff --git a/execution/evm/specs_common.go b/execution/evm/specs_common.go new file mode 100644 index 0000000..bd910f3 --- /dev/null +++ b/execution/evm/specs_common.go @@ -0,0 +1,33 @@ +package evm +func (s SpecId) IsEnabledIn(other SpecId) bool { + return s >= other +} +type Spec interface { + SpecID() SpecId + Enabled(specID SpecId) bool +} +type BaseSpec struct { + id SpecId +} +func (s BaseSpec) SpecID() SpecId { + return s.id +} + +func (s BaseSpec) Enabled(specID SpecId) bool { + return s.id >= specID +} +func NewSpec(id SpecId) BaseSpec { + return BaseSpec{id: id} +} +func TryFromUint8(specID uint8) (SpecId, bool) { + if specID > uint8(PRAGUE_EOF) && specID != uint8(LATEST) { + return 0, false + } + return SpecId(specID), true +} +type OptimismFields struct { + SourceHash *B256 `json:"source_hash,omitempty"` + Mint *uint64 `json:"mint,omitempty"` + IsSystemTransaction *bool `json:"is_system_transaction,omitempty"` + EnvelopedTx Bytes `json:"enveloped_tx,omitempty"` +} diff --git a/execution/evm/specs_default.go b/execution/evm/specs_default.go new file mode 100644 index 0000000..6b0f0ea --- /dev/null +++ b/execution/evm/specs_default.go @@ -0,0 +1,431 @@ +//go:build !optimism +// +build !optimism + +package evm + +import ( + "encoding/json" + "fmt" + "math/big" + +) +type TxEnv struct { + // Caller aka Author aka transaction signer + Caller Address `json:"caller"` + // The gas limit of the transaction + GasLimit uint64 `json:"gas_limit"` + // The gas price of the transaction + GasPrice *big.Int `json:"gas_price"` + // The destination of the transaction + TransactTo TxKind `json:"transact_to"` + // The value sent to TransactTo + Value *big.Int `json:"value"` + // The data of the transaction + Data Bytes `json:"data"` + // The nonce of the transaction + // If nil, nonce validation against the account's nonce is skipped + Nonce *uint64 `json:"nonce,omitempty"` + // The chain ID of the transaction + // If nil, no checks are performed (EIP-155) + ChainID *uint64 `json:"chain_id,omitempty"` + // List of addresses and storage keys that the transaction plans to access (EIP-2930) + AccessList []AccessListItem `json:"access_list"` + // The priority fee per gas (EIP-1559) + GasPriorityFee *big.Int `json:"gas_priority_fee,omitempty"` + // The list of blob versioned hashes (EIP-4844) + BlobHashes []B256 `json:"blob_hashes"` + // The max fee per blob gas (EIP-4844) + MaxFeePerBlobGas *big.Int `json:"max_fee_per_blob_gas,omitempty"` + // List of authorizations for EOA account code (EIP-7702) + AuthorizationList *AuthorizationList `json:"authorization_list,omitempty"` +} +const isOptimismEnabled = false + +// SpecId represents the specification IDs and their activation block. +type SpecId uint8 +const ( + FRONTIER SpecId = 0 // Frontier 0 + FRONTIER_THAWING SpecId = 1 // Frontier Thawing 200000 + HOMESTEAD SpecId = 2 // Homestead 1150000 + DAO_FORK SpecId = 3 // DAO Fork 1920000 + TANGERINE SpecId = 4 // Tangerine Whistle 2463000 + SPURIOUS_DRAGON SpecId = 5 // Spurious Dragon 2675000 + BYZANTIUM SpecId = 6 // Byzantium 4370000 + CONSTANTINOPLE SpecId = 7 // Constantinople 7280000 is overwritten with PETERSBURG + PETERSBURG SpecId = 8 // Petersburg 7280000 + ISTANBUL SpecId = 9 // Istanbul 9069000 + MUIR_GLACIER SpecId = 10 // Muir Glacier 9200000 + BERLIN SpecId = 11 // Berlin 12244000 + LONDON SpecId = 12 // London 12965000 + ARROW_GLACIER SpecId = 13 // Arrow Glacier 13773000 + GRAY_GLACIER SpecId = 14 // Gray Glacier 15050000 + MERGE SpecId = 15 // Paris/Merge 15537394 (TTD: 58750000000000000000000) + SHANGHAI SpecId = 16 // Shanghai 17034870 (Timestamp: 1681338455) + CANCUN SpecId = 17 // Cancun 19426587 (Timestamp: 1710338135) + PRAGUE SpecId = 18 // Prague TBD + PRAGUE_EOF SpecId = 19 // Prague+EOF TBD + LATEST SpecId = 255 // LATEST = u8::MAX +) + +// String method to convert SpecId to string +func (s SpecId) String() string { + switch s { + case FRONTIER: + return "FRONTIER" + case FRONTIER_THAWING: + return "FRONTIER_THAWING" + case HOMESTEAD: + return "HOMESTEAD" + case DAO_FORK: + return "DAO_FORK" + case TANGERINE: + return "TANGERINE" + case SPURIOUS_DRAGON: + return "SPURIOUS_DRAGON" + case BYZANTIUM: + return "BYZANTIUM" + case CONSTANTINOPLE: + return "CONSTANTINOPLE" + case PETERSBURG: + return "PETERSBURG" + case ISTANBUL: + return "ISTANBUL" + case MUIR_GLACIER: + return "MUIR_GLACIER" + case BERLIN: + return "BERLIN" + case LONDON: + return "LONDON" + case ARROW_GLACIER: + return "ARROW_GLACIER" + case GRAY_GLACIER: + return "GRAY_GLACIER" + case MERGE: + return "MERGE" + case SHANGHAI: + return "SHANGHAI" + case CANCUN: + return "CANCUN" + case PRAGUE: + return "PRAGUE" + case PRAGUE_EOF: + return "PRAGUE_EOF" + default: + return "UNKNOWN" + } +} +func DefaultSpecId() SpecId { + return LATEST +} + +type ( + FrontierSpec struct{ BaseSpec } + HomesteadSpec struct{ BaseSpec } + TangerineSpec struct{ BaseSpec } + SpuriousDragonSpec struct{ BaseSpec } + ByzantiumSpec struct{ BaseSpec } + PetersburgSpec struct{ BaseSpec } + IstanbulSpec struct{ BaseSpec } + BerlinSpec struct{ BaseSpec } + LondonSpec struct{ BaseSpec } + MergeSpec struct{ BaseSpec } + ShanghaiSpec struct{ BaseSpec } + CancunSpec struct{ BaseSpec } + PragueSpec struct{ BaseSpec } + PragueEofSpec struct{ BaseSpec } + LatestSpec struct{ BaseSpec } +) +func SpecToGeneric(specID SpecId) Spec { + switch specID { + case FRONTIER, FRONTIER_THAWING: + return FrontierSpec{NewSpec(FRONTIER)} + case HOMESTEAD, DAO_FORK: + return HomesteadSpec{NewSpec(HOMESTEAD)} + case TANGERINE: + return TangerineSpec{NewSpec(TANGERINE)} + case SPURIOUS_DRAGON: + return SpuriousDragonSpec{NewSpec(SPURIOUS_DRAGON)} + case BYZANTIUM: + return ByzantiumSpec{NewSpec(BYZANTIUM)} + case PETERSBURG, CONSTANTINOPLE: + return PetersburgSpec{NewSpec(PETERSBURG)} + case ISTANBUL, MUIR_GLACIER: + return IstanbulSpec{NewSpec(ISTANBUL)} + case BERLIN: + return BerlinSpec{NewSpec(BERLIN)} + case LONDON, ARROW_GLACIER, GRAY_GLACIER: + return LondonSpec{NewSpec(LONDON)} + case MERGE: + return MergeSpec{NewSpec(MERGE)} + case SHANGHAI: + return ShanghaiSpec{NewSpec(SHANGHAI)} + case CANCUN: + return CancunSpec{NewSpec(CANCUN)} + case PRAGUE: + return PragueSpec{NewSpec(PRAGUE)} + case PRAGUE_EOF: + return PragueEofSpec{NewSpec(PRAGUE_EOF)} + default: + return LatestSpec{NewSpec(LATEST)} + } +} + + +// MarshalJSON implements the json.Marshaler interface for SpecId. +// MarshalJSON for serialization +func (s SpecId) MarshalJSON() ([]byte, error) { + return json.Marshal(s.String()) +} + +// UnmarshalJSON for deserialization +func (s *SpecId) UnmarshalJSON(data []byte) error { + var name string + if err := json.Unmarshal(data, &name); err != nil { + return err + } + + switch name { + case "FRONTIER": + *s = FRONTIER + case "FRONTIER_THAWING": + *s = FRONTIER_THAWING + case "HOMESTEAD": + *s = HOMESTEAD + case "DAO_FORK": + *s = DAO_FORK + case "TANGERINE": + *s = TANGERINE + case "SPURIOUS_DRAGON": + *s = SPURIOUS_DRAGON + case "BYZANTIUM": + *s = BYZANTIUM + case "CONSTANTINOPLE": + *s = CONSTANTINOPLE + case "PETERSBURG": + *s = PETERSBURG + case "ISTANBUL": + *s = ISTANBUL + case "MUIR_GLACIER": + *s = MUIR_GLACIER + case "BERLIN": + *s = BERLIN + case "LONDON": + *s = LONDON + case "ARROW_GLACIER": + *s = ARROW_GLACIER + case "GRAY_GLACIER": + *s = GRAY_GLACIER + case "MERGE": + *s = MERGE + case "SHANGHAI": + *s = SHANGHAI + case "CANCUN": + *s = CANCUN + case "PRAGUE": + *s = PRAGUE + case "PRAGUE_EOF": + *s = PRAGUE_EOF + default: + return fmt.Errorf("unknown SpecId: %s", name) + } + return nil +} + +// func SpecToGeneric(specID SpecId) Spec { +// switch specID { +// case FRONTIER, FRONTIER_THAWING: +// return FrontierSpec{NewSpec(FRONTIER)} +// case HOMESTEAD, DAO_FORK: +// return HomesteadSpec{NewSpec(HOMESTEAD)} +// case TANGERINE: +// return TangerineSpec{NewSpec(TANGERINE)} +// case SPURIOUS_DRAGON: +// return SpuriousDragonSpec{NewSpec(SPURIOUS_DRAGON)} +// case BYZANTIUM: +// return ByzantiumSpec{NewSpec(BYZANTIUM)} +// case PETERSBURG, CONSTANTINOPLE: +// return PetersburgSpec{NewSpec(PETERSBURG)} +// case ISTANBUL, MUIR_GLACIER: +// return IstanbulSpec{NewSpec(ISTANBUL)} +// case BERLIN: +// return BerlinSpec{NewSpec(BERLIN)} +// case LONDON, ARROW_GLACIER, GRAY_GLACIER: +// return LondonSpec{NewSpec(LONDON)} +// case MERGE: +// return MergeSpec{NewSpec(MERGE)} +// case SHANGHAI: +// return ShanghaiSpec{NewSpec(SHANGHAI)} +// case CANCUN: +// return CancunSpec{NewSpec(CANCUN)} +// case PRAGUE: +// return PragueSpec{NewSpec(PRAGUE)} +// case PRAGUE_EOF: +// return PragueEofSpec{NewSpec(PRAGUE_EOF)} +// default: +// return LatestSpec{NewSpec(LATEST)} +// } +// } +/* + func specToGeneric[H Host, EXT any, DB Database]( + specID SpecId, + h *EvmHandler[H, EXT, DB], + isOptimism bool, + ) (*EvmHandler[H, EXT, DB], error) { + switch specID { + case FRONTIER, FRONTIER_THAWING: + return createSpecHandler[H, EXT, DB](h, "frontier", isOptimism) + case HOMESTEAD, DAO_FORK: + return createSpecHandler[H, EXT, DB](h, "homestead", isOptimism) + case TANGERINE: + return createSpecHandler[H, EXT, DB](h, "tangerine", isOptimism) + case SPURIOUS_DRAGON: + return createSpecHandler[H, EXT, DB](h, "spurious_dragon", isOptimism) + case BYZANTIUM: + return createSpecHandler[H, EXT, DB](h, "byzantium", isOptimism) + case PETERSBURG, CONSTANTINOPLE: + return createSpecHandler[H, EXT, DB](h, "petersburg", isOptimism) + case ISTANBUL, MUIR_GLACIER: + return createSpecHandler[H, EXT, DB](h, "istanbul", isOptimism) + case BERLIN: + return createSpecHandler[H, EXT, DB](h, "berlin", isOptimism) + case LONDON, ARROW_GLACIER, GRAY_GLACIER: + return createSpecHandler[H, EXT, DB](h, "london", isOptimism) + case MERGE: + return createSpecHandler[H, EXT, DB](h, "merge", isOptimism) + case SHANGHAI: + return createSpecHandler[H, EXT, DB](h, "shanghai", isOptimism) + case CANCUN: + return createSpecHandler[H, EXT, DB](h, "cancun", isOptimism) + case PRAGUE: + return createSpecHandler[H, EXT, DB](h, "prague", isOptimism) + case PRAGUE_EOF: + return createSpecHandler[H, EXT, DB](h, "prague_eof", isOptimism) + case LATEST: + return createSpecHandler[H, EXT, DB](h, "latest", isOptimism) + } + + // Optimism-specific specs + /* + if isOptimism { + switch specID { + case BEDROCK: + return createSpecHandler[H, EXT, DB](h, "bedrock", true) + case REGOLITH: + return createSpecHandler[H, EXT, DB](h, "regolith", true) + case CANYON: + return createSpecHandler[H, EXT, DB](h, "canyon", true) + case ECOTONE: + return createSpecHandler[H, EXT, DB](h, "ecotone", true) + case FJORD: + return createSpecHandler[H, EXT, DB](h, "fjord", true) + } + }*/ + + //return nil, fmt.Errorf("unsupported spec ID: %d", specID) + //}*/ + +/* +// Spec interface defining the behavior of Ethereum specs. +type Spec interface { + GetSpecID() SpecId +} + +// CreateSpec creates a new specification struct based on the provided SpecId. +func CreateSpec(specId SpecId) Spec { + switch specId { + case FRONTIER: + return &FrontierSpec{} + case FRONTIER_THAWING: + // No changes for EVM spec + return nil + case HOMESTEAD: + return &HomesteadSpec{} + case DAO_FORK: + // No changes for EVM spec + return nil + case TANGERINE: + return &TangerineSpec{} + case SPURIOUS_DRAGON: + return &SpuriousDragonSpec{} + case BYZANTIUM: + return &ByzantiumSpec{} + case PETERSBURG: + return &PetersburgSpec{} + case ISTANBUL: + return &IstanbulSpec{} + case MUIR_GLACIER: + // No changes for EVM spec + return nil + case BERLIN: + return &BerlinSpec{} + case LONDON: + return &LondonSpec{} + case ARROW_GLACIER: + // No changes for EVM spec + return nil + case GRAY_GLACIER: + // No changes for EVM spec + return nil + case MERGE: + return &MergeSpec{} + case SHANGHAI: + return &ShanghaiSpec{} + case CANCUN: + return &CancunSpec{} + case PRAGUE: + return &PragueSpec{} + case PRAGUE_EOF: + return &PragueEofSpec{} + case LATEST: + return &LatestSpec{} + default: + return nil + } +} + +// Spec structures +type FrontierSpec struct{} +func (s *FrontierSpec) GetSpecID() SpecId { return FRONTIER } + +type HomesteadSpec struct{} +func (s *HomesteadSpec) GetSpecID() SpecId { return HOMESTEAD } + +type TangerineSpec struct{} +func (s *TangerineSpec) GetSpecID() SpecId { return TANGERINE } + +type SpuriousDragonSpec struct{} +func (s *SpuriousDragonSpec) GetSpecID() SpecId { return SPURIOUS_DRAGON } + +type ByzantiumSpec struct{} +func (s *ByzantiumSpec) GetSpecID() SpecId { return BYZANTIUM } + +type PetersburgSpec struct{} +func (s *PetersburgSpec) GetSpecID() SpecId { return PETERSBURG } + +type IstanbulSpec struct{} +func (s *IstanbulSpec) GetSpecID() SpecId { return ISTANBUL } + +type BerlinSpec struct{} +func (s *BerlinSpec) GetSpecID() SpecId { return BERLIN } + +type LondonSpec struct{} +func (s *LondonSpec) GetSpecID() SpecId { return LONDON } + +type MergeSpec struct{} +func (s *MergeSpec) GetSpecID() SpecId { return MERGE } + +type ShanghaiSpec struct{} +func (s *ShanghaiSpec) GetSpecID() SpecId { return SHANGHAI } + +type CancunSpec struct{} +func (s *CancunSpec) GetSpecID() SpecId { return CANCUN } + +type PragueSpec struct{} +func (s *PragueSpec) GetSpecID() SpecId { return PRAGUE } + +type PragueEofSpec struct{} +func (s *PragueEofSpec) GetSpecID() SpecId { return PRAGUE_EOF } + +type LatestSpec struct{} +func (s *LatestSpec) GetSpecID() SpecId { return LATEST } +*/ diff --git a/execution/evm/specs_optimism.go b/execution/evm/specs_optimism.go new file mode 100644 index 0000000..34b5c68 --- /dev/null +++ b/execution/evm/specs_optimism.go @@ -0,0 +1,282 @@ +//go:build optimism +// +build optimism + +package evm + +const isOptimismEnabled = true +import ( + "encoding/json" +) +type TxEnv struct { + // Caller aka Author aka transaction signer + Caller Address `json:"caller"` + // The gas limit of the transaction + GasLimit uint64 `json:"gas_limit"` + // The gas price of the transaction + GasPrice *big.Int `json:"gas_price"` + // The destination of the transaction + TransactTo TxKind `json:"transact_to"` + // The value sent to TransactTo + Value *big.Int `json:"value"` + // The data of the transaction + Data Bytes `json:"data"` + // The nonce of the transaction + // If nil, nonce validation against the account's nonce is skipped + Nonce *uint64 `json:"nonce,omitempty"` + // The chain ID of the transaction + // If nil, no checks are performed (EIP-155) + ChainID *uint64 `json:"chain_id,omitempty"` + // List of addresses and storage keys that the transaction plans to access (EIP-2930) + AccessList []AccessListItem `json:"access_list"` + // The priority fee per gas (EIP-1559) + GasPriorityFee *big.Int `json:"gas_priority_fee,omitempty"` + // The list of blob versioned hashes (EIP-4844) + BlobHashes []B256 `json:"blob_hashes"` + // The max fee per blob gas (EIP-4844) + MaxFeePerBlobGas *big.Int `json:"max_fee_per_blob_gas,omitempty"` + // List of authorizations for EOA account code (EIP-7702) + AuthorizationList *AuthorizationList `json:"authorization_list,omitempty"` + // Optimism fields (only included when build tag is set) + Optimism OptimismFields `json:"optimism,omitempty"` +} +func TryFromUint8(specID uint8) (SpecId, bool) { + if specID > uint8(PRAGUE_EOF) && specID != uint8(LATEST) { + return 0, false + } + return SpecId(specID), true +} +type SpecId uint8 + +const ( + FRONTIER SpecId = 0 // Frontier + FRONTIER_THAWING SpecId = 1 // Frontier Thawing + HOMESTEAD SpecId = 2 // Homestead + DAO_FORK SpecId = 3 // DAO Fork + TANGERINE SpecId = 4 // Tangerine Whistle + SPURIOUS_DRAGON SpecId = 5 // Spurious Dragon + BYZANTIUM SpecId = 6 // Byzantium + CONSTANTINOPLE SpecId = 7 // Constantinople + PETERSBURG SpecId = 8 // Petersburg + ISTANBUL SpecId = 9 // Istanbul + MUIR_GLACIER SpecId = 10 // Muir Glacier + BERLIN SpecId = 11 // Berlin + LONDON SpecId = 12 // London + ARROW_GLACIER SpecId = 13 // Arrow Glacier + GRAY_GLACIER SpecId = 14 // Gray Glacier + MERGE SpecId = 15 // Paris/Merge + BEDROCK SpecId = 16 // Bedrock + REGOLITH SpecId = 17 // Regolith + SHANGHAI SpecId = 18 // Shanghai + CANYON SpecId = 19 // Canyon + CANCUN SpecId = 20 // Cancun + ECOTONE SpecId = 21 // Ecotone + FJORD SpecId = 22 // Fjord + PRAGUE SpecId = 23 // Prague + PRAGUE_EOF SpecId = 24 // Prague+EOF + LATEST SpecId = 255 // LATEST = u8::MAX +) + +// Default value for SpecId +func DefaultSpecId() SpecId { + return LATEST +} + +// String method to convert SpecId to string +func (s SpecId) String() string { + switch s { + case FRONTIER: + return "FRONTIER" + case FRONTIER_THAWING: + return "FRONTIER_THAWING" + case HOMESTEAD: + return "HOMESTEAD" + case DAO_FORK: + return "DAO_FORK" + case TANGERINE: + return "TANGERINE" + case SPURIOUS_DRAGON: + return "SPURIOUS_DRAGON" + case BYZANTIUM: + return "BYZANTIUM" + case CONSTANTINOPLE: + return "CONSTANTINOPLE" + case PETERSBURG: + return "PETERSBURG" + case ISTANBUL: + return "ISTANBUL" + case MUIR_GLACIER: + return "MUIR_GLACIER" + case BERLIN: + return "BERLIN" + case LONDON: + return "LONDON" + case ARROW_GLACIER: + return "ARROW_GLACIER" + case GRAY_GLACIER: + return "GRAY_GLACIER" + case MERGE: + return "MERGE" + case BEDROCK: + return "BEDROCK" + case REGOLITH: + return "REGOLITH" + case SHANGHAI: + return "SHANGHAI" + case CANYON: + return "CANYON" + case CANCUN: + return "CANCUN" + case ECOTONE: + return "ECOTONE" + case FJORD: + return "FJORD" + case PRAGUE: + return "PRAGUE" + case PRAGUE_EOF: + return "PRAGUE_EOF" + default: + return "UNKNOWN" + } +} +type ( + FrontierSpec struct{ BaseSpec } + FrontierThawingSpec struct{ BaseSpec } + HomesteadSpec struct{ BaseSpec } + DaoForkSpec struct{ BaseSpec } + TangerineSpec struct{ BaseSpec } + SpuriousDragonSpec struct{ BaseSpec } + ByzantiumSpec struct{ BaseSpec } + ConstantinopleSpec struct{ BaseSpec } + PetersburgSpec struct{ BaseSpec } + IstanbulSpec struct{ BaseSpec } + MuirGlacierSpec struct{ BaseSpec } + BerlinSpec struct{ BaseSpec } + LondonSpec struct{ BaseSpec } + ArrowGlacierSpec struct{ BaseSpec } + GrayGlacierSpec struct{ BaseSpec } + MergeSpec struct{ BaseSpec } + BedrockSpec struct{ BaseSpec } + RegolithSpec struct{ BaseSpec } + ShanghaiSpec struct{ BaseSpec } + CanyonSpec struct{ BaseSpec } + CancunSpec struct{ BaseSpec } + EcotoneSpec struct{ BaseSpec } + FjordSpec struct{ BaseSpec } + PragueSpec struct{ BaseSpec } + PragueEofSpec struct{ BaseSpec } + LatestSpec struct{ BaseSpec } +) +// MarshalJSON for serialization +func (s SpecId) MarshalJSON() ([]byte, error) { + return json.Marshal(s.String()) +} + + + +func SpecToGeneric(specID SpecId) interface{} { + switch specID { + case FRONTIER, FRONTIER_THAWING: + return FrontierSpec{NewSpec(FRONTIER)} + case HOMESTEAD, DAO_FORK: + return HomesteadSpec{NewSpec(HOMESTEAD)} + case TANGERINE: + return TangerineSpec{NewSpec(TANGERINE)} + case SPURIOUS_DRAGON: + return SpuriousDragonSpec{NewSpec(SPURIOUS_DRAGON)} + case BYZANTIUM: + return ByzantiumSpec{NewSpec(BYZANTIUM)} + case PETERSBURG, CONSTANTINOPLE: + return PetersburgSpec{NewSpec(PETERSBURG)} + case ISTANBUL, MUIR_GLACIER: + return IstanbulSpec{NewSpec(ISTANBUL)} + case BERLIN: + return BerlinSpec{NewSpec(BERLIN)} + case LONDON, ARROW_GLACIER, GRAY_GLACIER: + return LondonSpec{NewSpec(LONDON)} + case MERGE: + return MergeSpec{NewSpec(MERGE)} + case SHANGHAI: + return ShanghaiSpec{NewSpec(SHANGHAI)} + case CANCUN: + return CancunSpec{NewSpec(CANCUN)} + case PRAGUE: + return PragueSpec{NewSpec(PRAGUE)} + case PRAGUE_EOF: + return PragueEofSpec{NewSpec(PRAGUE_EOF)} + case BEDROCK: + return BedrockSpec{NewSpec(BEDROCK)} + case REGOLITH: + return RegolithSpec{NewSpec(REGOLITH)} + case CANYON: + return CanyonSpec{NewSpec(CANYON)} + case ECOTONE: + return EcotoneSpec{NewSpec(ECOTONE)} + case FJORD: + return FjordSpec{NewSpec(FJORD)} + default: + return LatestSpec{NewSpec(LATEST)} + } +} + +func (s *SpecId) UnmarshalJSON(data []byte) error { + var name string + if err := json.Unmarshal(data, &name); err != nil { + return err + } + + switch name { + case "FRONTIER": + *s = FRONTIER + case "FRONTIER_THAWING": + *s = FRONTIER_THAWING + case "HOMESTEAD": + *s = HOMESTEAD + case "DAO_FORK": + *s = DAO_FORK + case "TANGERINE": + *s = TANGERINE + case "SPURIOUS_DRAGON": + *s = SPURIOUS_DRAGON + case "BYZANTIUM": + *s = BYZANTIUM + case "CONSTANTINOPLE": + *s = CONSTANTINOPLE + case "PETERSBURG": + *s = PETERSBURG + case "ISTANBUL": + *s = ISTANBUL + case "MUIR_GLACIER": + *s = MUIR_GLACIER + case "BERLIN": + *s = BERLIN + case "LONDON": + *s = LONDON + case "ARROW_GLACIER": + *s = ARROW_GLACIER + case "GRAY_GLACIER": + *s = GRAY_GLACIER + case "MERGE": + *s = MERGE + case "SHANGHAI": + *s = SHANGHAI + case "CANCUN": + *s = CANCUN + case "PRAGUE": + *s = PRAGUE + case "PRAGUE_EOF": + *s = PRAGUE_EOF + case "BEDROCK": + *s = BEDROCK + case "REGOLITH": + *s = REGOLITH + case "CANYON": + *s = CANYON + case "ECOTONE": + *s = ECOTONE + case "FJORD": + *s = FJORD + default: + return fmt.Errorf("unknown SpecId: %s", name) + } + return nil +} \ No newline at end of file diff --git a/execution/evm/tables.go b/execution/evm/tables.go new file mode 100644 index 0000000..4e35584 --- /dev/null +++ b/execution/evm/tables.go @@ -0,0 +1,35 @@ +package evm +// Instruction is a function type that takes an Interpreter and a generic type H. +type Instruction[H any] func(interpreter *Interpreter, h *H) + +// InstructionTable is a list of 256 instructions mapped to EVM opcodes. +type InstructionTable[H any] [256]Instruction[H] + +// DynInstruction is a function type signature for dynamic instructions. +type DynInstruction[H any] func(interpreter *Interpreter, h *H) + +// BoxedInstruction wraps a DynInstruction in a pointer, enabling dynamic dispatch. +type BoxedInstruction[H any] *DynInstruction[H] + +// BoxedInstructionTable is an array of 256 boxed instructions. +type BoxedInstructionTable[H any] [256]BoxedInstruction[H] + +const ( + PlainTableMode = iota + BoxedTableMode +) +type InstructionTables[H any] struct { + PlainTable *InstructionTable[H] + BoxedTable *BoxedInstructionTable[H] + Mode int // Indicates which table is in use (Plain or Boxed) +} +//Mode contains 0 and 1 +// NewPlainInstructionTable creates an InstructionTables instance with a PlainTable. +func NewPlainInstructionTable[H any](table InstructionTable[H]) InstructionTables[H] { + return InstructionTables[H]{PlainTable: &table} +} + +// NewBoxedInstructionTable creates an InstructionTables instance with a BoxedTable. +func NewBoxedInstructionTable[H any](table BoxedInstructionTable[H]) InstructionTables[H] { + return InstructionTables[H]{BoxedTable: &table} +} From 88bd7e0fca41a94c77297b72d6963a23e5631217 Mon Sep 17 00:00:00 2001 From: x-senpai-x Date: Mon, 28 Oct 2024 16:24:28 +0530 Subject: [PATCH 4/4] dependencies for journal.go and evm.go and handler.go --- execution/evm/account.go | 185 ++++++++++++++++++++++ execution/evm/call_inputs.go | 170 +++++++++++++++++++++ execution/evm/interpreter.go | 228 ++++++++++++++++++++++++++++ execution/evm/interpreter_action.go | 141 +++++++++++++++++ 4 files changed, 724 insertions(+) create mode 100644 execution/evm/account.go create mode 100644 execution/evm/call_inputs.go create mode 100644 execution/evm/interpreter.go create mode 100644 execution/evm/interpreter_action.go diff --git a/execution/evm/account.go b/execution/evm/account.go new file mode 100644 index 0000000..c21efd9 --- /dev/null +++ b/execution/evm/account.go @@ -0,0 +1,185 @@ +package evm +import( + "sync" + "fmt" + "encoding/json" + "reflect") +type Account struct { + Info AccountInfo + Storage EvmStorage + Status AccountStatus +} +type AccountInfo struct { + Balance U256 + Nonce uint64 + CodeHash B256 + Code *Bytecode +} +func NewAccountInfo(balance U256, nonce uint64, codeHash B256, code Bytecode) AccountInfo { + return AccountInfo{ + Balance: balance, + Nonce: nonce, + CodeHash: codeHash, + Code: &code, + } +} +type EvmStorage map[U256]EvmStorageSlot +type EvmStorageSlot struct { + OriginalValue U256 + PresentValue U256 + IsCold bool +} +type AccountStatus uint8 +const ( + Loaded AccountStatus = 0b00000000 // Account is loaded but not interacted with + Created AccountStatus = 0b00000001 // Account is newly created, no DB fetch required + SelfDestructed AccountStatus = 0b00000010 // Account is marked for self-destruction + Touched AccountStatus = 0b00000100 // Account is touched and will be saved to DB + LoadedAsNotExisting AccountStatus = 0b0001000 // Pre-spurious state; account loaded but marked as non-existing + Cold AccountStatus = 0b0010000 // Account is marked as cold (not frequently accessed) +) +type BytecodeKind int +const ( + LegacyRawKind BytecodeKind = iota + LegacyAnalyzedKind + EofKind +) +// BytecodeKind serves as discriminator for Bytecode to identify which variant of enum is being used +// 1 , 2 or 3 in this case +type Bytecode struct { + Kind BytecodeKind + LegacyRaw []byte // For LegacyRaw variant + LegacyAnalyzed *LegacyAnalyzedBytecode // For LegacyAnalyzed variant + Eof *Eof // For Eof variant +} +type LegacyAnalyzedBytecode struct { + Bytecode []byte + OriginalLen uint64 + JumpTable JumpTable +} + +// JumpTable equivalent in Go, using a sync.Once pointer to simulate Arc and BitVec. +type JumpTable struct { + BitVector *Bitvector // Simulating BitVec as []byte + once sync.Once // Lazy initialization if needed +} +type Bitvector struct { + bits []uint8 + size int // Total number of bits represented +} +type Opcode struct { + InitCode Eof `json:"initcode"` + Input Bytes `json:"input"` + CreatedAddress Address `json:"created_address"` +} +type Eof struct { + Header EofHeader `json:"header"` + Body EofBody `json:"body"` + Raw Bytes `json:"raw"` +} + +// EofHeader represents the header of the EOF. +type EofHeader struct { + TypesSize uint16 `json:"types_size"` + CodeSizes []uint16 `json:"code_sizes"` + ContainerSizes []uint16 `json:"container_sizes"` + DataSize uint16 `json:"data_size"` + SumCodeSizes int `json:"sum_code_sizes"` + SumContainerSizes int `json:"sum_container_sizes"` +} + +// Marshaler interface for custom marshaling +type Marshaler interface { + MarshalType(val reflect.Value, b []byte, lastWrittenIdx uint64) (nextIdx uint64, err error) +} + +// Unmarshaler interface for custom unmarshaling +type Unmarshaler interface { + UnmarshalType(target reflect.Value, b []byte, lastReadIdx uint64) (nextIdx uint64, err error) +} + +// Implement Marshaler for EOFCreateInputs +func (eci EOFCreateInputs) MarshalType(val reflect.Value, b []byte, lastWrittenIdx uint64) (nextIdx uint64, err error) { + jsonData, err := json.Marshal(eci) + if err != nil { + return lastWrittenIdx, err + } + + return uint64(len(jsonData)), nil +} + +// Implement Unmarshaler for EOFCreateInputs +func (eci *EOFCreateInputs) UnmarshalType(target reflect.Value, b []byte, lastReadIdx uint64) (nextIdx uint64, err error) { + err = json.Unmarshal(b, eci) + if err != nil { + return lastReadIdx, err + } + + return lastReadIdx + uint64(len(b)), nil +} + +type EofBody struct { + TypesSection []TypesSection `json:"types_section"` + CodeSection []Bytes `json:"code_section"` // Using [][]byte for Vec + ContainerSection []Bytes `json:"container_section"` // Using [][]byte for Vec + DataSection Bytes `json:"data_section"` // Using []byte for Bytes + IsDataFilled bool `json:"is_data_filled"` +} + +// TypesSection represents a section describing the types used in the EOF body. +type TypesSection struct { + Inputs uint8 `json:"inputs"` // 1 byte + Outputs uint8 `json:"outputs"` // 1 byte + MaxStackSize uint16 `json:"max_stack_size"` // 2 bytes +} + +// MarshalJSON customizes the JSON marshalling for EOFCreateKind. +func (e *EOFCreateKind) MarshalJSON() ([]byte, error) { + switch e.Kind { + case TxK: + return json.Marshal(map[string]interface{}{ + "type": "Tx", + "data": e.Data, + }) + case OpcodeK: + return json.Marshal(map[string]interface{}{ + "type": "Opcode", + "data": e.Data, + }) + default: + return nil, fmt.Errorf("unknown EOFCreateKind type") + } +} + +// UnmarshalJSON customizes the JSON unmarshalling for EOFCreateKind. +func (e *EOFCreateKind) UnmarshalJSON(data []byte) error { + var aux struct { + Type string `json:"type"` + Data json.RawMessage `json:"data"` + } + + if err := json.Unmarshal(data, &aux); err != nil { + return err + } + + switch aux.Type { + case "Tx": + var tx Tx + if err := json.Unmarshal(aux.Data, &tx); err != nil { + return err + } + e.Kind = TxK + e.Data = tx + case "Opcode": + var opcode Opcode + if err := json.Unmarshal(aux.Data, &opcode); err != nil { + return err + } + e.Kind = OpcodeK + e.Data = opcode + default: + return fmt.Errorf("unknown EOFCreateKind type: %s", aux.Type) + } + + return nil +} diff --git a/execution/evm/call_inputs.go b/execution/evm/call_inputs.go new file mode 100644 index 0000000..871b312 --- /dev/null +++ b/execution/evm/call_inputs.go @@ -0,0 +1,170 @@ +package evm +import( + "encoding/json" +) +func (c *CallInputs) New(txEnv *TxEnv, gasLimit uint64) *CallInputs { + // Check if the transaction kind is Call and extract the target address. + if txEnv.TransactTo.Type != Call2 { + return nil + } + targetAddress := txEnv.TransactTo.Address + // Create and return the CallInputs instance. + return &CallInputs{ + Input: txEnv.Data, + GasLimit: gasLimit, + TargetAddress: *targetAddress, + BytecodeAddress: *targetAddress, // Set to target_address as in Rust code. + Caller: txEnv.Caller, + Value: CallValue{ValueType: "transfer", Amount: txEnv.Value}, + Scheme: ICall, // Assuming CallScheme.Call is represented by Call. + IsStatic: false, + IsEof: false, + ReturnMemoryOffset: Range{Start: 0, End: 0}, + } +} +func (c *CallInputs) NewBoxed(txEnv *TxEnv, gasLimit uint64) *CallInputs { + return c.New(txEnv, gasLimit) // Returns a pointer or nil, similar to Option> in Rust. +} + +func (e EOFCreateInputs) NewTx(tx *TxEnv, gasLimit uint64) EOFCreateInputs { + return EOFCreateInputs{ + Caller: tx.Caller, + Value: tx.Value, + GasLimit: gasLimit, + Kind: EOFCreateKind{ + Kind: TxK, + Data: tx.Data, + }, + } +} + +func (c *CreateInputs) New(txEnv *TxEnv, gasLimit uint64) *CreateInputs { + if txEnv.TransactTo.Type != Create2 { + return nil + } + return &CreateInputs{ + Caller: txEnv.Caller, + Scheme: CreateScheme{ + SchemeType: SchemeTypeCreate, + }, + Value: txEnv.Value, + InitCode: txEnv.Data, + GasLimit: gasLimit, + } +} + +func (c *CreateInputs) NewBoxed(txEnv *TxEnv, gasLimit uint64) *CreateInputs { + return c.New(txEnv, gasLimit) +} + +type CallValue struct { + ValueType string `json:"value_type"` + Amount U256 `json:"amount,omitempty"` +} + +// Transfer creates a CallValue representing a transfer. +func Transfer(amount U256) CallValue { + return CallValue{ValueType: "transfer", Amount: amount} +} + +// Apparent creates a CallValue representing an apparent value. +func Apparent(amount U256) CallValue { + return CallValue{ValueType: "apparent", Amount: amount} +} + +type CallScheme int +const ( + ICall CallScheme = iota + ICallCode + IDelegateCall + IStaticCall + IExtCall + IExtStaticCall + IExtDelegateCall +) +type CallInputs struct { + Input Bytes `json:"input"` + ReturnMemoryOffset Range `json:"return_memory_offset"` + GasLimit uint64 `json:"gas_limit"` + BytecodeAddress Address `json:"bytecode_address"` + TargetAddress Address `json:"target_address"` + Caller Address `json:"caller"` + Value CallValue `json:"value"` + Scheme CallScheme `json:"scheme"` + IsStatic bool `json:"is_static"` + IsEof bool `json:"is_eof"` +} + +// JSON serialization for CallValue +func (cv CallValue) MarshalJSON() ([]byte, error) { + return json.Marshal(struct { + ValueType string `json:"value_type"` + Amount *U256 `json:"amount,omitempty"` + }{ + ValueType: cv.ValueType, + Amount: &cv.Amount, + }) +} + +// JSON deserialization for CallValue +func (cv *CallValue) UnmarshalJSON(data []byte) error { + var aux struct { + ValueType string `json:"value_type"` + Amount *U256 `json:"amount,omitempty"` + } + if err := json.Unmarshal(data, &aux); err != nil { + return err + } + cv.ValueType = aux.ValueType + if aux.ValueType == "transfer" { + cv.Amount = *aux.Amount + } else if aux.ValueType == "apparent" { + cv.Amount = *aux.Amount + } + return nil +} + +type CreateInputs struct { + Caller Address `json:"caller"` + Scheme CreateScheme `json:"scheme"` + Value U256 `json:"value"` + InitCode Bytes `json:"init_code"` + GasLimit uint64 `json:"gas_limit"` +} +type CreateScheme struct { + SchemeType SchemeType `json:"scheme_type"` // can be "create" or "create2" + Salt *U256 `json:"salt,omitempty"` // salt is optional for Create +} + +// SchemeType represents the type of creation scheme +type SchemeType int + +const ( + SchemeTypeCreate SchemeType = iota + SchemeTypeCreate2 +) + +type EOFCreateKindType int + +const ( + TxK EOFCreateKindType = iota + OpcodeK +) + +// / Inputs for EOF create call. +type EOFCreateInputs struct { + Caller Address `json:"caller"` + Value U256 `json:"value"` + GasLimit uint64 `json:"gas_limit"` + Kind EOFCreateKind `json:"kind"` +} + +type EOFCreateKind struct { + Kind EOFCreateKindType + Data interface{} // Use an interface to hold the associated data (Tx or Opcode) +} + +// TxKind represents a transaction-based EOF create kind. +type Tx struct { + InitData Bytes `json:"initdata"` +} diff --git a/execution/evm/interpreter.go b/execution/evm/interpreter.go new file mode 100644 index 0000000..05288ce --- /dev/null +++ b/execution/evm/interpreter.go @@ -0,0 +1,228 @@ +package evm +import ( + "encoding/json" + "math" +) +type Interpreter struct { + InstructionPointer *byte // Using *byte as equivalent to *const u8 in Rust + Gas Gas + Contract Contract + InstructionResult InstructionResult + Bytecode Bytes + IsEof bool + // Is init flag for eof create + IsEofInit bool + // Shared memory. + // Note: This field is only set while running the interpreter loop. + // Otherwise, it is taken and replaced with empty shared memory. + SharedMemory SharedMemory + // Stack. + Stack Stack + // EOF function stack. + FunctionStack FunctionStack + // The return data buffer for internal calls. + // It has multi usage: + // - It contains the output bytes of call sub call. + // - When this interpreter finishes execution it contains the output bytes of this contract. + ReturnDataBuffer Bytes + // Whether the interpreter is in "staticcall" mode, meaning no state changes can happen. + IsStatic bool + // Actions that the EVM should do. + // Set inside CALL or CREATE instructions and RETURN or REVERT instructions. + // Additionally, those instructions will set InstructionResult to CallOrCreate/Return/Revert so we know the reason. + NextAction InterpreterAction +} +type Gas struct { + Limit uint64 + Remaining uint64 + Refunded int64 +} +type Contract struct { + Input Bytes + Bytecode Bytecode + Hash *B256 + TargetAddress Address + BytecodeAddress *Address + Caller Address + CallValue U256 +} +type InstructionResult uint8 +const ( + // Success codes + Continue InstructionResult = iota // 0x00 + Stop + Return + SelfDestruct + ReturnContract + + // Revert codes + Revert = 0x10 // revert opcode + CallTooDeep + OutOfFunds + CreateInitCodeStartingEF00 + InvalidEOFInitCode + InvalidExtDelegateCallTarget + + // Actions + CallOrCreate = 0x20 + + // Error codes + OutOfGas = 0x50 + MemoryOOG + MemoryLimitOOG + PrecompileOOG + InvalidOperandOOG + OpcodeNotFound + CallNotAllowedInsideStatic + StateChangeDuringStaticCall + InvalidFEOpcode + InvalidJump + NotActivated + StackUnderflow + StackOverflow + OutOfOffset + CreateCollision + OverflowPayment + PrecompileError + NonceOverflow + CreateContractSizeLimit + CreateContractStartingWithEF + CreateInitCodeSizeLimit + FatalExternalError + ReturnContractInNotInitEOF + EOFOpcodeDisabledInLegacy + EOFFunctionStackOverflow + EofAuxDataOverflow + EofAuxDataTooSmall + InvalidEXTCALLTarget +) +// MarshalJSON customizes the JSON serialization of InstructionResult. +func (ir InstructionResult) MarshalJSON() ([]byte, error) { + return json.Marshal(uint8(ir)) +} + +// UnmarshalJSON customizes the JSON deserialization of InstructionResult. +func (ir *InstructionResult) UnmarshalJSON(data []byte) error { + var value uint8 + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *ir = InstructionResult(value) + return nil +} +type SharedMemory struct { + Buffer []byte + Checkpoints []int + LastCheckpoint int + MemoryLimit uint64 //although implemented as feature memory_limit but kept p=optional for now +} +func (s *SharedMemory) NewContext() { + newCheckpoint := len(s.Buffer) + s.Checkpoints = append(s.Checkpoints, newCheckpoint) + s.LastCheckpoint = newCheckpoint +} +func (s SharedMemory) New() SharedMemory { + return s.WithCapacity(4 * 1024) +} +func (s SharedMemory) WithCapacity(capacity uint) SharedMemory { + return SharedMemory{ + Buffer: make([]byte, capacity), + Checkpoints: make([]int, 32), + LastCheckpoint: 0, + MemoryLimit: math.MaxUint64, + } +} + +func (s SharedMemory) NewWithMemoryLimit(memoryLimit uint64) SharedMemory { + return SharedMemory{ + Buffer: make([]byte, 4 * 1024), + Checkpoints: make([]int, 32), + LastCheckpoint: 0, + MemoryLimit: memoryLimit, + } +} +func (s *SharedMemory) FreeContext() { + if len(s.Checkpoints) > 0 { + // Pop the last element from Checkpoints + oldCheckpoint := s.Checkpoints[len(s.Checkpoints)-1] + s.Checkpoints = s.Checkpoints[:len(s.Checkpoints)-1] + + // Update LastCheckpoint to the last value in Checkpoints, or 0 if empty + if len(s.Checkpoints) > 0 { + s.LastCheckpoint = s.Checkpoints[len(s.Checkpoints)-1] + } else { + s.LastCheckpoint = 0 // default value if no checkpoints are left + } + + // Safely resize Buffer to the old checkpoint length + if oldCheckpoint < len(s.Buffer) { + s.Buffer = s.Buffer[:oldCheckpoint] + } + } +} +type Stack struct { + Data []U256 +} +type FunctionStack struct { + ReturnStack []FunctionReturnFrame `json:"return_stack"` + CurrentCodeIdx uint64 `json:"current_code_idx"` // Changed to uint64 to match Rust's usize +} + +// MarshalJSON customizes the JSON serialization of FunctionStack. +func (fs FunctionStack) MarshalJSON() ([]byte, error) { + return json.Marshal(struct { + ReturnStack []FunctionReturnFrame `json:"return_stack"` + CurrentCodeIdx uint64 `json:"current_code_idx"` + }{ + ReturnStack: fs.ReturnStack, + CurrentCodeIdx: fs.CurrentCodeIdx, + }) +} + +// UnmarshalJSON customizes the JSON deserialization of FunctionStack. +func (fs *FunctionStack) UnmarshalJSON(data []byte) error { + var temp struct { + ReturnStack []FunctionReturnFrame `json:"return_stack"` + CurrentCodeIdx uint64 `json:"current_code_idx"` + } + if err := json.Unmarshal(data, &temp); err != nil { + return err + } + fs.ReturnStack = temp.ReturnStack + fs.CurrentCodeIdx = temp.CurrentCodeIdx + return nil +} + +// FunctionReturnFrame represents a frame in the function return stack for the EVM interpreter. +type FunctionReturnFrame struct { + // The index of the code container that this frame is executing. + Idx uint64 `json:"idx"` // Changed to uint64 to match Rust's usize + // The program counter where frame execution should continue. + PC uint64 `json:"pc"` // Changed to uint64 to match Rust's usize +} + +// MarshalJSON customizes the JSON serialization of FunctionReturnFrame. +func (frf FunctionReturnFrame) MarshalJSON() ([]byte, error) { + return json.Marshal(struct { + Idx uint64 `json:"idx"` + PC uint64 `json:"pc"` + }{ + Idx: frf.Idx, + PC: frf.PC, + }) +} + +// UnmarshalJSON customizes the JSON deserialization of FunctionReturnFrame. +func (frf *FunctionReturnFrame) UnmarshalJSON(data []byte) error { + var temp struct { + Idx uint64 `json:"idx"` + PC uint64 `json:"pc"` + } + if err := json.Unmarshal(data, &temp); err != nil { + return err + } + frf.Idx = temp.Idx + frf.PC = temp.PC + return nil +} + diff --git a/execution/evm/interpreter_action.go b/execution/evm/interpreter_action.go new file mode 100644 index 0000000..26ff9bb --- /dev/null +++ b/execution/evm/interpreter_action.go @@ -0,0 +1,141 @@ +package evm +import( + "fmt" + "encoding/json" + +) +type InterpreterAction struct { + // We use a type field to distinguish between different actions + actionType ActionType + callInputs *CallInputs + createInputs *CreateInputs + eofCreateInputs *EOFCreateInputs + result *InterpreterResult +} +type InterpreterResult struct { + // The result of the execution. + Result InstructionResult + Output Bytes + Gas Gas +} +//Check marshal unmarshal remove if not required +type jsonInterpreterAction struct { + Type string `json:"type"` + CallInputs *CallInputs `json:"call_inputs,omitempty"` + CreateInputs *CreateInputs `json:"create_inputs,omitempty"` + EOFInputs *EOFCreateInputs `json:"eof_inputs,omitempty"` + Result *InterpreterResult `json:"result,omitempty"` +} + +// MarshalJSON implements the json.Marshaler interface +func (a *InterpreterAction) MarshalJSON() ([]byte, error) { + var jsonAction jsonInterpreterAction + + switch a.actionType { + case ActionTypeCall: + jsonAction.Type = "Call" + jsonAction.CallInputs = a.callInputs + case ActionTypeCreate: + jsonAction.Type = "Create" + jsonAction.CreateInputs = a.createInputs + case ActionTypeEOFCreate: + jsonAction.Type = "EOFCreate" + jsonAction.EOFInputs = a.eofCreateInputs + case ActionTypeReturn: + jsonAction.Type = "Return" + jsonAction.Result = a.result + case ActionTypeNone: + jsonAction.Type = "None" + default: + return nil, fmt.Errorf("unknown action type: %v", a.actionType) + } + + return json.Marshal(jsonAction) +} + +// UnmarshalJSON implements the json.Unmarshaler interface +func (a *InterpreterAction) UnmarshalJSON(data []byte) error { + var jsonAction jsonInterpreterAction + if err := json.Unmarshal(data, &jsonAction); err != nil { + return err + } + + switch jsonAction.Type { + case "Call": + if jsonAction.CallInputs == nil { + return fmt.Errorf("Call action missing inputs") + } + *a = *NewCallAction(jsonAction.CallInputs) + case "Create": + if jsonAction.CreateInputs == nil { + return fmt.Errorf("Create action missing inputs") + } + *a = *NewCreateAction(jsonAction.CreateInputs) + case "EOFCreate": + if jsonAction.EOFInputs == nil { + return fmt.Errorf("EOFCreate action missing inputs") + } + *a = *NewEOFCreateAction(jsonAction.EOFInputs) + case "Return": + if jsonAction.Result == nil { + return fmt.Errorf("Return action missing result") + } + *a = *NewReturnAction(jsonAction.Result) + case "None": + *a = *NewNoneAction() + default: + return fmt.Errorf("unknown action type: %s", jsonAction.Type) + } + + return nil +} + +// ActionType represents the type of interpreter action +type ActionType int + +const ( + ActionTypeNone ActionType = iota + ActionTypeCall + ActionTypeCreate + ActionTypeEOFCreate + ActionTypeReturn +) + +// NewCallAction creates a new Call action +func NewCallAction(inputs *CallInputs) *InterpreterAction { + return &InterpreterAction{ + actionType: ActionTypeCall, + callInputs: inputs, + } +} + +// NewCreateAction creates a new Create action +func NewCreateAction(inputs *CreateInputs) *InterpreterAction { + return &InterpreterAction{ + actionType: ActionTypeCreate, + createInputs: inputs, + } +} + +// NewEOFCreateAction creates a new EOFCreate action +func NewEOFCreateAction(inputs *EOFCreateInputs) *InterpreterAction { + return &InterpreterAction{ + actionType: ActionTypeEOFCreate, + eofCreateInputs: inputs, + } +} + +// NewReturnAction creates a new Return action +func NewReturnAction(result *InterpreterResult) *InterpreterAction { + return &InterpreterAction{ + actionType: ActionTypeReturn, + result: result, + } +} + +// NewNoneAction creates a new None action +func NewNoneAction() *InterpreterAction { + return &InterpreterAction{ + actionType: ActionTypeNone, + } +} \ No newline at end of file