From cd1382ffba6d6a3526f2379fc21982cef74617a5 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Mon, 9 Sep 2024 19:13:32 -0600 Subject: [PATCH 01/19] turn max arbos versions to constants --- arbos/arbosState/arbosstate.go | 55 ++++++++++++++-------------------- cmd/nitro/init.go | 8 ++--- 2 files changed, 27 insertions(+), 36 deletions(-) diff --git a/arbos/arbosState/arbosstate.go b/arbos/arbosState/arbosstate.go index 91c2207aae..0b9810a4b2 100644 --- a/arbos/arbosState/arbosstate.go +++ b/arbos/arbosState/arbosstate.go @@ -41,28 +41,29 @@ import ( // persisted beyond the end of the test.) type ArbosState struct { - arbosVersion uint64 // version of the ArbOS storage format and semantics - maxArbosVersionSupported uint64 // maximum ArbOS version supported by this code - maxDebugArbosVersionSupported uint64 // maximum ArbOS version supported by this code in debug mode - upgradeVersion storage.StorageBackedUint64 // version we're planning to upgrade to, or 0 if not planning to upgrade - upgradeTimestamp storage.StorageBackedUint64 // when to do the planned upgrade - networkFeeAccount storage.StorageBackedAddress - l1PricingState *l1pricing.L1PricingState - l2PricingState *l2pricing.L2PricingState - retryableState *retryables.RetryableState - addressTable *addressTable.AddressTable - chainOwners *addressSet.AddressSet - sendMerkle *merkleAccumulator.MerkleAccumulator - programs *programs.Programs - blockhashes *blockhash.Blockhashes - chainId storage.StorageBackedBigInt - chainConfig storage.StorageBackedBytes - genesisBlockNum storage.StorageBackedUint64 - infraFeeAccount storage.StorageBackedAddress - brotliCompressionLevel storage.StorageBackedUint64 // brotli compression level used for pricing - backingStorage *storage.Storage - Burner burn.Burner -} + arbosVersion uint64 // version of the ArbOS storage format and semantics + upgradeVersion storage.StorageBackedUint64 // version we're planning to upgrade to, or 0 if not planning to upgrade + upgradeTimestamp storage.StorageBackedUint64 // when to do the planned upgrade + networkFeeAccount storage.StorageBackedAddress + l1PricingState *l1pricing.L1PricingState + l2PricingState *l2pricing.L2PricingState + retryableState *retryables.RetryableState + addressTable *addressTable.AddressTable + chainOwners *addressSet.AddressSet + sendMerkle *merkleAccumulator.MerkleAccumulator + programs *programs.Programs + blockhashes *blockhash.Blockhashes + chainId storage.StorageBackedBigInt + chainConfig storage.StorageBackedBytes + genesisBlockNum storage.StorageBackedUint64 + infraFeeAccount storage.StorageBackedAddress + brotliCompressionLevel storage.StorageBackedUint64 // brotli compression level used for pricing + backingStorage *storage.Storage + Burner burn.Burner +} + +const MaxArbosVersionSupported uint64 = params.ArbosVersion_StylusFixes +const MaxDebugArbosVersionSupported uint64 = params.ArbosVersion_StylusFixes var ErrUninitializedArbOS = errors.New("ArbOS uninitialized") var ErrAlreadyInitialized = errors.New("ArbOS is already initialized") @@ -78,8 +79,6 @@ func OpenArbosState(stateDB vm.StateDB, burner burn.Burner) (*ArbosState, error) } return &ArbosState{ arbosVersion, - 31, - 31, backingStorage.OpenStorageBackedUint64(uint64(upgradeVersionOffset)), backingStorage.OpenStorageBackedUint64(uint64(upgradeTimestampOffset)), backingStorage.OpenStorageBackedAddress(uint64(networkFeeAccountOffset)), @@ -416,14 +415,6 @@ func (state *ArbosState) RetryableState() *retryables.RetryableState { return state.retryableState } -func (state *ArbosState) MaxArbosVersionSupported() uint64 { - return state.maxArbosVersionSupported -} - -func (state *ArbosState) MaxDebugArbosVersionSupported() uint64 { - return state.maxDebugArbosVersionSupported -} - func (state *ArbosState) L1PricingState() *l1pricing.L1PricingState { return state.l1PricingState } diff --git a/cmd/nitro/init.go b/cmd/nitro/init.go index fc59f2d231..07c74cb802 100644 --- a/cmd/nitro/init.go +++ b/cmd/nitro/init.go @@ -354,12 +354,12 @@ func validateBlockChain(blockChain *core.BlockChain, chainConfig *params.ChainCo } // Make sure we don't allow accidentally downgrading ArbOS if chainConfig.DebugMode() { - if currentArbosState.ArbOSVersion() > currentArbosState.MaxDebugArbosVersionSupported() { - return fmt.Errorf("attempted to launch node in debug mode with ArbOS version %v on ArbOS state with version %v", currentArbosState.MaxDebugArbosVersionSupported(), currentArbosState.ArbOSVersion()) + if currentArbosState.ArbOSVersion() > arbosState.MaxDebugArbosVersionSupported { + return fmt.Errorf("attempted to launch node in debug mode with ArbOS version %v on ArbOS state with version %v", arbosState.MaxDebugArbosVersionSupported, currentArbosState.ArbOSVersion()) } } else { - if currentArbosState.ArbOSVersion() > currentArbosState.MaxArbosVersionSupported() { - return fmt.Errorf("attempted to launch node with ArbOS version %v on ArbOS state with version %v", currentArbosState.MaxArbosVersionSupported(), currentArbosState.ArbOSVersion()) + if currentArbosState.ArbOSVersion() > arbosState.MaxArbosVersionSupported { + return fmt.Errorf("attempted to launch node with ArbOS version %v on ArbOS state with version %v", arbosState.MaxArbosVersionSupported, currentArbosState.ArbOSVersion()) } } From 6e29462972b8a5fe5e21ae7a191e110e7b7b6838 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 20:49:05 -0600 Subject: [PATCH 02/19] geth pin: add stylus_chargingfixes --- go-ethereum | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go-ethereum b/go-ethereum index ad31b75098..fded6f642b 160000 --- a/go-ethereum +++ b/go-ethereum @@ -1 +1 @@ -Subproject commit ad31b75098f874c7124e7b29b47db8662d47b9ff +Subproject commit fded6f642b62797d53389c54e994085578d6711a From 36af58b988d53aeb97b14113859c1295ef879787 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 20:52:06 -0600 Subject: [PATCH 03/19] support arbos32 for debug chains --- arbos/arbosState/arbosstate.go | 5 ++++- cmd/chaininfo/arbitrum_chain_info.json | 4 ++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/arbos/arbosState/arbosstate.go b/arbos/arbosState/arbosstate.go index 0b9810a4b2..8318f8eb98 100644 --- a/arbos/arbosState/arbosstate.go +++ b/arbos/arbosState/arbosstate.go @@ -63,7 +63,7 @@ type ArbosState struct { } const MaxArbosVersionSupported uint64 = params.ArbosVersion_StylusFixes -const MaxDebugArbosVersionSupported uint64 = params.ArbosVersion_StylusFixes +const MaxDebugArbosVersionSupported uint64 = params.ArbosVersion_StylusChargingFixes var ErrUninitializedArbOS = errors.New("ArbOS uninitialized") var ErrAlreadyInitialized = errors.New("ArbOS is already initialized") @@ -331,6 +331,9 @@ func (state *ArbosState) UpgradeArbosVersion( ensure(params.UpgradeToVersion(2)) ensure(params.Save()) + case 32: + // no change state needed + default: return fmt.Errorf( "the chain is upgrading to unsupported ArbOS version %v, %w", diff --git a/cmd/chaininfo/arbitrum_chain_info.json b/cmd/chaininfo/arbitrum_chain_info.json index 524433a7b5..f862c6dfbf 100644 --- a/cmd/chaininfo/arbitrum_chain_info.json +++ b/cmd/chaininfo/arbitrum_chain_info.json @@ -164,7 +164,7 @@ "EnableArbOS": true, "AllowDebugPrecompiles": true, "DataAvailabilityCommittee": false, - "InitialArbOSVersion": 31, + "InitialArbOSVersion": 32, "InitialChainOwner": "0x0000000000000000000000000000000000000000", "GenesisBlockNum": 0 } @@ -196,7 +196,7 @@ "EnableArbOS": true, "AllowDebugPrecompiles": true, "DataAvailabilityCommittee": true, - "InitialArbOSVersion": 31, + "InitialArbOSVersion": 32, "InitialChainOwner": "0x0000000000000000000000000000000000000000", "GenesisBlockNum": 0 } From 21ee5c54245ce4ee2b82353dc57ff3b23bd00656 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 21:02:44 -0600 Subject: [PATCH 04/19] revert mininitgas before arbos32 --- precompiles/ArbWasm.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/precompiles/ArbWasm.go b/precompiles/ArbWasm.go index 9f42cacb5a..d122ed6037 100644 --- a/precompiles/ArbWasm.go +++ b/precompiles/ArbWasm.go @@ -5,6 +5,8 @@ package precompiles import ( "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/vm" + gethparams "github.com/ethereum/go-ethereum/params" "github.com/offchainlabs/nitro/arbos/programs" "github.com/offchainlabs/nitro/arbos/util" "github.com/offchainlabs/nitro/util/arbmath" @@ -133,6 +135,9 @@ func (con ArbWasm) MinInitGas(c ctx, _ mech) (uint64, uint64, error) { params, err := c.State.Programs().Params() init := uint64(params.MinInitGas) * programs.MinInitGasUnits cached := uint64(params.MinCachedInitGas) * programs.MinCachedGasUnits + if c.State.ArbOSVersion() < gethparams.ArbosVersion_StylusChargingFixes { + return 0, 0, vm.ErrExecutionReverted + } return init, cached, err } From f70829a92077bc0eb366685248a7b6ebefdea121 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 21:05:09 -0600 Subject: [PATCH 05/19] contracts: take arbwasm fix --- contracts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contracts b/contracts index 23fc796282..7396313311 160000 --- a/contracts +++ b/contracts @@ -1 +1 @@ -Subproject commit 23fc79628292aa5d604d449fed48937ae7faeb2f +Subproject commit 7396313311ab17cb30e2eef27cccf96f0a9e8f7f From 95160fbf0e9115d604594daa188fd6db95041905 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 21:24:31 -0600 Subject: [PATCH 06/19] arbitrator: add constant for arbos version for stylus charging fixes --- arbitrator/prover/src/programs/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs index a5df2e31a8..5c02e9c11a 100644 --- a/arbitrator/prover/src/programs/mod.rs +++ b/arbitrator/prover/src/programs/mod.rs @@ -39,6 +39,7 @@ pub mod prelude; pub mod start; pub const STYLUS_ENTRY_POINT: &str = "user_entrypoint"; +pub const ARBOS_VERSION_STYLUS_CHARGING_FIXES: u64 = 32; pub trait ModuleMod { fn add_global(&mut self, name: &str, ty: Type, init: GlobalInit) -> Result; From 71685cb7ffe381d3c9ae45b29c4e6bcda2cfa58a Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Tue, 3 Sep 2024 16:47:22 -0600 Subject: [PATCH 07/19] stylus: charge for wasm length in arbos v32 --- arbitrator/jit/src/program.rs | 5 +++-- arbitrator/prover/src/programs/mod.rs | 11 ++++++++--- arbitrator/stylus/src/lib.rs | 5 +++-- arbitrator/stylus/src/native.rs | 5 +++-- .../wasm-libraries/user-host/src/link.rs | 5 +++-- arbos/programs/native.go | 18 +++++++++++++----- arbos/programs/programs.go | 4 ++-- arbos/programs/wasm.go | 9 ++++++--- arbos/programs/wasmstorehelper.go | 9 ++++++--- precompiles/ArbWasm.go | 3 ++- 10 files changed, 49 insertions(+), 25 deletions(-) diff --git a/arbitrator/jit/src/program.rs b/arbitrator/jit/src/program.rs index c608a3cf85..22c4e418cb 100644 --- a/arbitrator/jit/src/program.rs +++ b/arbitrator/jit/src/program.rs @@ -25,7 +25,8 @@ pub fn activate( asm_estimate_ptr: GuestPtr, init_cost_ptr: GuestPtr, cached_init_cost_ptr: GuestPtr, - version: u16, + stylus_version: u16, + arbos_version: u64, debug: u32, codehash: GuestPtr, module_hash_ptr: GuestPtr, @@ -40,7 +41,7 @@ pub fn activate( let page_limit = mem.read_u16(pages_ptr); let gas_left = &mut mem.read_u64(gas_ptr); - match Module::activate(&wasm, codehash, version, page_limit, debug, gas_left) { + match Module::activate(&wasm, codehash, stylus_version, arbos_version, page_limit, debug, gas_left) { Ok((module, data)) => { mem.write_u64(gas_ptr, *gas_left); mem.write_u16(pages_ptr, data.footprint); diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs index 5c02e9c11a..6873cf9f50 100644 --- a/arbitrator/prover/src/programs/mod.rs +++ b/arbitrator/prover/src/programs/mod.rs @@ -28,6 +28,8 @@ use { wasmer_types::{MemoryIndex, ModuleInfo}, }; +const ARBOS_VERSION_CHARGE_WASM_LEN: u64 = 32; + pub mod config; pub mod counter; pub mod depth; @@ -419,7 +421,8 @@ impl Module { pub fn activate( wasm: &[u8], codehash: &Bytes32, - version: u16, + stylus_version: u16, + arbos_version: u64, page_limit: u16, debug: bool, gas: &mut u64, @@ -446,9 +449,11 @@ impl Module { // pay for wasm let wasm_len = wasm.len() as u64; - pay!(wasm_len.saturating_mul(31_733 / 100_000)); + if arbos_version >= ARBOS_VERSION_CHARGE_WASM_LEN { + pay!(wasm_len.saturating_mul(31_733) / 100_000); + } - let compile = CompileConfig::version(version, debug); + let compile = CompileConfig::version(stylus_version, debug); let (bin, stylus_data) = WasmBinary::parse_user(wasm, page_limit, &compile, codehash) .wrap_err("failed to parse wasm")?; diff --git a/arbitrator/stylus/src/lib.rs b/arbitrator/stylus/src/lib.rs index a252b60a01..b3876affe7 100644 --- a/arbitrator/stylus/src/lib.rs +++ b/arbitrator/stylus/src/lib.rs @@ -139,7 +139,8 @@ impl RustBytes { pub unsafe extern "C" fn stylus_activate( wasm: GoSliceData, page_limit: u16, - version: u16, + stylus_version: u16, + arbos_version: u64, debug: bool, output: *mut RustBytes, codehash: *const Bytes32, @@ -153,7 +154,7 @@ pub unsafe extern "C" fn stylus_activate( let codehash = &*codehash; let gas = &mut *gas; - let (module, info) = match native::activate(wasm, codehash, version, page_limit, debug, gas) { + let (module, info) = match native::activate(wasm, codehash, stylus_version, arbos_version, page_limit, debug, gas) { Ok(val) => val, Err(err) => return output.write_err(err), }; diff --git a/arbitrator/stylus/src/native.rs b/arbitrator/stylus/src/native.rs index 7a82314fbc..55cee9fce0 100644 --- a/arbitrator/stylus/src/native.rs +++ b/arbitrator/stylus/src/native.rs @@ -351,13 +351,14 @@ pub fn module(wasm: &[u8], compile: CompileConfig, target: Target) -> Result Result<(ProverModule, StylusData)> { let (module, stylus_data) = - ProverModule::activate(wasm, codehash, version, page_limit, debug, gas)?; + ProverModule::activate(wasm, codehash, stylus_version, arbos_version, page_limit, debug, gas)?; Ok((module, stylus_data)) } diff --git a/arbitrator/wasm-libraries/user-host/src/link.rs b/arbitrator/wasm-libraries/user-host/src/link.rs index 428611167d..8e98f1d5a6 100644 --- a/arbitrator/wasm-libraries/user-host/src/link.rs +++ b/arbitrator/wasm-libraries/user-host/src/link.rs @@ -44,7 +44,8 @@ pub unsafe extern "C" fn programs__activate( asm_estimate_ptr: GuestPtr, init_cost_ptr: GuestPtr, cached_init_cost_ptr: GuestPtr, - version: u16, + stylus_version: u16, + arbos_version: u64, debug: u32, codehash: GuestPtr, module_hash_ptr: GuestPtr, @@ -58,7 +59,7 @@ pub unsafe extern "C" fn programs__activate( let page_limit = STATIC_MEM.read_u16(pages_ptr); let gas_left = &mut STATIC_MEM.read_u64(gas_ptr); - match Module::activate(&wasm, codehash, version, page_limit, debug, gas_left) { + match Module::activate(&wasm, codehash, stylus_version, arbos_version, page_limit, debug, gas_left) { Ok((module, data)) => { STATIC_MEM.write_u64(gas_ptr, *gas_left); STATIC_MEM.write_u16(pages_ptr, data.footprint); diff --git a/arbos/programs/native.go b/arbos/programs/native.go index 377e25a31e..d143c41879 100644 --- a/arbos/programs/native.go +++ b/arbos/programs/native.go @@ -29,6 +29,7 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" "github.com/offchainlabs/nitro/arbos/burn" "github.com/offchainlabs/nitro/arbos/util" "github.com/offchainlabs/nitro/arbutil" @@ -51,11 +52,12 @@ func activateProgram( codehash common.Hash, wasm []byte, page_limit uint16, - version uint16, + stylusVersion uint16, + arbosVersion uint64, debug bool, burner burn.Burner, ) (*activationInfo, error) { - info, asmMap, err := activateProgramInternal(db, program, codehash, wasm, page_limit, version, debug, burner.GasLeft()) + info, asmMap, err := activateProgramInternal(db, program, codehash, wasm, page_limit, stylusVersion, arbosVersion, debug, burner.GasLeft()) if err != nil { return nil, err } @@ -69,7 +71,8 @@ func activateProgramInternal( codehash common.Hash, wasm []byte, page_limit uint16, - version uint16, + stylusVersion uint16, + arbosVersion uint64, debug bool, gasLeft *uint64, ) (*activationInfo, map[ethdb.WasmTarget][]byte, error) { @@ -81,7 +84,8 @@ func activateProgramInternal( status_mod := userStatus(C.stylus_activate( goSlice(wasm), u16(page_limit), - u16(version), + u16(stylusVersion), + u64(arbosVersion), cbool(debug), output, &codeHash, @@ -168,9 +172,13 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err) } + // gas used for activation charging, which doesn't matter here unlimitedGas := uint64(0xffffffffffff) + // arbosVersion used only for charging, which won't happen here so doesn't matter + arbosVersion := params.ArbosVersion_StylusActivationFix + // we know program is activated, so it must be in correct version and not use too much memory - info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, debugMode, &unlimitedGas) + info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, arbosVersion, debugMode, &unlimitedGas) if err != nil { log.Error("failed to reactivate program", "address", addressForLogging, "expected moduleHash", moduleHash, "err", err) return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err) diff --git a/arbos/programs/programs.go b/arbos/programs/programs.go index 12102bac84..f397b67783 100644 --- a/arbos/programs/programs.go +++ b/arbos/programs/programs.go @@ -82,7 +82,7 @@ func (p Programs) CacheManagers() *addressSet.AddressSet { return p.cacheManagers } -func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode core.MessageRunMode, debugMode bool) ( +func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, arbosVersion uint64, runMode core.MessageRunMode, debugMode bool) ( uint16, common.Hash, common.Hash, *big.Int, bool, error, ) { statedb := evm.StateDB @@ -116,7 +116,7 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode c // require the program's footprint not exceed the remaining memory budget pageLimit := am.SaturatingUSub(params.PageLimit, statedb.GetStylusPagesOpen()) - info, err := activateProgram(statedb, address, codeHash, wasm, pageLimit, stylusVersion, debugMode, burner) + info, err := activateProgram(statedb, address, codeHash, wasm, pageLimit, stylusVersion, arbosVersion, debugMode, burner) if err != nil { return 0, codeHash, common.Hash{}, nil, true, err } diff --git a/arbos/programs/wasm.go b/arbos/programs/wasm.go index f7191dca8f..a3209d9ac5 100644 --- a/arbos/programs/wasm.go +++ b/arbos/programs/wasm.go @@ -44,7 +44,8 @@ func programActivate( asm_estimation_ptr unsafe.Pointer, init_gas_ptr unsafe.Pointer, cached_init_gas_ptr unsafe.Pointer, - version uint32, + stylusVersion uint32, + arbosVersion uint64, debug uint32, codehash unsafe.Pointer, module_hash_ptr unsafe.Pointer, @@ -59,7 +60,8 @@ func activateProgram( codehash common.Hash, wasm []byte, pageLimit u16, - version u16, + stylusVersion u16, + arbosVersion uint64, debug bool, burner burn.Burner, ) (*activationInfo, error) { @@ -79,7 +81,8 @@ func activateProgram( unsafe.Pointer(&asmEstimate), unsafe.Pointer(&initGas), unsafe.Pointer(&cachedInitGas), - uint32(version), + uint32(stylusVersion), + arbosVersion, debugMode, arbutil.SliceToUnsafePointer(codehash[:]), arbutil.SliceToUnsafePointer(moduleHash[:]), diff --git a/arbos/programs/wasmstorehelper.go b/arbos/programs/wasmstorehelper.go index 434820dd9c..15a4c8f31b 100644 --- a/arbos/programs/wasmstorehelper.go +++ b/arbos/programs/wasmstorehelper.go @@ -13,16 +13,17 @@ import ( "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" ) // SaveActiveProgramToWasmStore is used to save active stylus programs to wasm store during rebuilding func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash common.Hash, code []byte, time uint64, debugMode bool, rebuildingStartBlockTime uint64) error { - params, err := p.Params() + progParams, err := p.Params() if err != nil { return err } - program, err := p.getActiveProgram(codeHash, time, params) + program, err := p.getActiveProgram(codeHash, time, progParams) if err != nil { // The program is not active so return early log.Info("program is not active, getActiveProgram returned error, hence do not include in rebuilding", "err", err) @@ -56,10 +57,12 @@ func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err) } + // nothing is charged, so gas and arbosVersion don't matter unlimitedGas := uint64(0xffffffffffff) + arbosVersion := params.ArbosVersion_StylusActivationFix // We know program is activated, so it must be in correct version and not use too much memory // Empty program address is supplied because we dont have access to this during rebuilding of wasm store - info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, params.PageLimit, program.version, debugMode, &unlimitedGas) + info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, arbosVersion, debugMode, &unlimitedGas) if err != nil { log.Error("failed to reactivate program while rebuilding wasm store", "expected moduleHash", moduleHash, "err", err) return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err) diff --git a/precompiles/ArbWasm.go b/precompiles/ArbWasm.go index 9f42cacb5a..36093f58db 100644 --- a/precompiles/ArbWasm.go +++ b/precompiles/ArbWasm.go @@ -32,12 +32,13 @@ func (con ArbWasm) ActivateProgram(c ctx, evm mech, value huge, program addr) (u debug := evm.ChainConfig().DebugMode() runMode := c.txProcessor.RunMode() programs := c.State.Programs() + arbosVersion := c.State.ArbOSVersion() // charge a fixed cost up front to begin activation if err := c.Burn(1659168); err != nil { return 0, nil, err } - version, codeHash, moduleHash, dataFee, takeAllGas, err := programs.ActivateProgram(evm, program, runMode, debug) + version, codeHash, moduleHash, dataFee, takeAllGas, err := programs.ActivateProgram(evm, program, arbosVersion, runMode, debug) if takeAllGas { _ = c.BurnOut() } From 92ff55fc06155fab68b81ad0f7df83dafe8f97fb Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Tue, 3 Sep 2024 17:22:24 -0600 Subject: [PATCH 08/19] rename arbos_version param in activate and accept zero --- arbitrator/jit/src/program.rs | 4 +- arbitrator/prover/src/programs/mod.rs | 46 ++++++++++--------- arbitrator/stylus/src/lib.rs | 4 +- arbitrator/stylus/src/native.rs | 4 +- .../wasm-libraries/user-host/src/link.rs | 4 +- arbos/programs/native.go | 13 ++---- arbos/programs/wasmstorehelper.go | 5 +- 7 files changed, 39 insertions(+), 41 deletions(-) diff --git a/arbitrator/jit/src/program.rs b/arbitrator/jit/src/program.rs index 22c4e418cb..47227f117f 100644 --- a/arbitrator/jit/src/program.rs +++ b/arbitrator/jit/src/program.rs @@ -26,7 +26,7 @@ pub fn activate( init_cost_ptr: GuestPtr, cached_init_cost_ptr: GuestPtr, stylus_version: u16, - arbos_version: u64, + arbos_version_for_gas: u64, debug: u32, codehash: GuestPtr, module_hash_ptr: GuestPtr, @@ -41,7 +41,7 @@ pub fn activate( let page_limit = mem.read_u16(pages_ptr); let gas_left = &mut mem.read_u64(gas_ptr); - match Module::activate(&wasm, codehash, stylus_version, arbos_version, page_limit, debug, gas_left) { + match Module::activate(&wasm, codehash, stylus_version, arbos_version_for_gas, page_limit, debug, gas_left) { Ok((module, data)) => { mem.write_u64(gas_ptr, *gas_left); mem.write_u16(pages_ptr, data.footprint); diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs index 6873cf9f50..5f314dbf87 100644 --- a/arbitrator/prover/src/programs/mod.rs +++ b/arbitrator/prover/src/programs/mod.rs @@ -422,7 +422,7 @@ impl Module { wasm: &[u8], codehash: &Bytes32, stylus_version: u16, - arbos_version: u64, + arbos_version_for_gas: u64, // must only be used for activation gas page_limit: u16, debug: bool, gas: &mut u64, @@ -447,35 +447,37 @@ impl Module { }; } - // pay for wasm - let wasm_len = wasm.len() as u64; - if arbos_version >= ARBOS_VERSION_CHARGE_WASM_LEN { - pay!(wasm_len.saturating_mul(31_733) / 100_000); - } - let compile = CompileConfig::version(stylus_version, debug); let (bin, stylus_data) = WasmBinary::parse_user(wasm, page_limit, &compile, codehash) .wrap_err("failed to parse wasm")?; - // pay for funcs - let funcs = bin.functions.len() as u64; - pay!(funcs.saturating_mul(17_263) / 100_000); + // pay for wasm + if arbos_version_for_gas >= ARBOS_VERSION_CHARGE_WASM_LEN { + let wasm_len = wasm.len() as u64; + pay!(wasm_len.saturating_mul(31_733) / 100_000); + } - // pay for data - let data = bin.datas.iter().map(|x| x.data.len()).saturating_sum() as u64; - pay!(data.saturating_mul(17_376) / 100_000); + if arbos_version_for_gas > 0 { + // pay for funcs + let funcs = bin.functions.len() as u64; + pay!(funcs.saturating_mul(17_263) / 100_000); - // pay for elements - let elems = bin.elements.iter().map(|x| x.range.len()).saturating_sum() as u64; - pay!(elems.saturating_mul(17_376) / 100_000); + // pay for data + let data = bin.datas.iter().map(|x| x.data.len()).saturating_sum() as u64; + pay!(data.saturating_mul(17_376) / 100_000); - // pay for memory - let mem = bin.memories.first().map(|x| x.initial).unwrap_or_default(); - pay!(mem.saturating_mul(2217)); + // pay for elements + let elems = bin.elements.iter().map(|x| x.range.len()).saturating_sum() as u64; + pay!(elems.saturating_mul(17_376) / 100_000); - // pay for code - let code = bin.codes.iter().map(|x| x.expr.len()).saturating_sum() as u64; - pay!(code.saturating_mul(535) / 1_000); + // pay for memory + let mem = bin.memories.first().map(|x| x.initial).unwrap_or_default(); + pay!(mem.saturating_mul(2217)); + + // pay for code + let code = bin.codes.iter().map(|x| x.expr.len()).saturating_sum() as u64; + pay!(code.saturating_mul(535) / 1_000); + } let module = Self::from_user_binary(&bin, compile.debug.debug_funcs, Some(stylus_data)) .wrap_err("failed to build user module")?; diff --git a/arbitrator/stylus/src/lib.rs b/arbitrator/stylus/src/lib.rs index b3876affe7..c53d1a663b 100644 --- a/arbitrator/stylus/src/lib.rs +++ b/arbitrator/stylus/src/lib.rs @@ -140,7 +140,7 @@ pub unsafe extern "C" fn stylus_activate( wasm: GoSliceData, page_limit: u16, stylus_version: u16, - arbos_version: u64, + arbos_version_for_gas: u64, debug: bool, output: *mut RustBytes, codehash: *const Bytes32, @@ -154,7 +154,7 @@ pub unsafe extern "C" fn stylus_activate( let codehash = &*codehash; let gas = &mut *gas; - let (module, info) = match native::activate(wasm, codehash, stylus_version, arbos_version, page_limit, debug, gas) { + let (module, info) = match native::activate(wasm, codehash, stylus_version, arbos_version_for_gas, page_limit, debug, gas) { Ok(val) => val, Err(err) => return output.write_err(err), }; diff --git a/arbitrator/stylus/src/native.rs b/arbitrator/stylus/src/native.rs index 55cee9fce0..f2f63fe216 100644 --- a/arbitrator/stylus/src/native.rs +++ b/arbitrator/stylus/src/native.rs @@ -352,13 +352,13 @@ pub fn activate( wasm: &[u8], codehash: &Bytes32, stylus_version: u16, - arbos_version: u64, + arbos_version_for_gas: u64, page_limit: u16, debug: bool, gas: &mut u64, ) -> Result<(ProverModule, StylusData)> { let (module, stylus_data) = - ProverModule::activate(wasm, codehash, stylus_version, arbos_version, page_limit, debug, gas)?; + ProverModule::activate(wasm, codehash, stylus_version, arbos_version_for_gas, page_limit, debug, gas)?; Ok((module, stylus_data)) } diff --git a/arbitrator/wasm-libraries/user-host/src/link.rs b/arbitrator/wasm-libraries/user-host/src/link.rs index 8e98f1d5a6..6c2d3c6c62 100644 --- a/arbitrator/wasm-libraries/user-host/src/link.rs +++ b/arbitrator/wasm-libraries/user-host/src/link.rs @@ -45,7 +45,7 @@ pub unsafe extern "C" fn programs__activate( init_cost_ptr: GuestPtr, cached_init_cost_ptr: GuestPtr, stylus_version: u16, - arbos_version: u64, + arbos_version_for_gas: u64, debug: u32, codehash: GuestPtr, module_hash_ptr: GuestPtr, @@ -59,7 +59,7 @@ pub unsafe extern "C" fn programs__activate( let page_limit = STATIC_MEM.read_u16(pages_ptr); let gas_left = &mut STATIC_MEM.read_u64(gas_ptr); - match Module::activate(&wasm, codehash, stylus_version, arbos_version, page_limit, debug, gas_left) { + match Module::activate(&wasm, codehash, stylus_version, arbos_version_for_gas, page_limit, debug, gas_left) { Ok((module, data)) => { STATIC_MEM.write_u64(gas_ptr, *gas_left); STATIC_MEM.write_u16(pages_ptr, data.footprint); diff --git a/arbos/programs/native.go b/arbos/programs/native.go index d143c41879..2c39e96652 100644 --- a/arbos/programs/native.go +++ b/arbos/programs/native.go @@ -29,7 +29,6 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/params" "github.com/offchainlabs/nitro/arbos/burn" "github.com/offchainlabs/nitro/arbos/util" "github.com/offchainlabs/nitro/arbutil" @@ -53,11 +52,11 @@ func activateProgram( wasm []byte, page_limit uint16, stylusVersion uint16, - arbosVersion uint64, + arbosVersionForGas uint64, debug bool, burner burn.Burner, ) (*activationInfo, error) { - info, asmMap, err := activateProgramInternal(db, program, codehash, wasm, page_limit, stylusVersion, arbosVersion, debug, burner.GasLeft()) + info, asmMap, err := activateProgramInternal(db, program, codehash, wasm, page_limit, stylusVersion, arbosVersionForGas, debug, burner.GasLeft()) if err != nil { return nil, err } @@ -72,7 +71,7 @@ func activateProgramInternal( wasm []byte, page_limit uint16, stylusVersion uint16, - arbosVersion uint64, + arbosVersionForGas uint64, debug bool, gasLeft *uint64, ) (*activationInfo, map[ethdb.WasmTarget][]byte, error) { @@ -85,7 +84,7 @@ func activateProgramInternal( goSlice(wasm), u16(page_limit), u16(stylusVersion), - u64(arbosVersion), + u64(arbosVersionForGas), cbool(debug), output, &codeHash, @@ -174,11 +173,9 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c // gas used for activation charging, which doesn't matter here unlimitedGas := uint64(0xffffffffffff) - // arbosVersion used only for charging, which won't happen here so doesn't matter - arbosVersion := params.ArbosVersion_StylusActivationFix // we know program is activated, so it must be in correct version and not use too much memory - info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, arbosVersion, debugMode, &unlimitedGas) + info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, 0, debugMode, &unlimitedGas) if err != nil { log.Error("failed to reactivate program", "address", addressForLogging, "expected moduleHash", moduleHash, "err", err) return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err) diff --git a/arbos/programs/wasmstorehelper.go b/arbos/programs/wasmstorehelper.go index 15a4c8f31b..d7bafe7fbc 100644 --- a/arbos/programs/wasmstorehelper.go +++ b/arbos/programs/wasmstorehelper.go @@ -13,7 +13,6 @@ import ( "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/params" ) // SaveActiveProgramToWasmStore is used to save active stylus programs to wasm store during rebuilding @@ -59,10 +58,10 @@ func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash // nothing is charged, so gas and arbosVersion don't matter unlimitedGas := uint64(0xffffffffffff) - arbosVersion := params.ArbosVersion_StylusActivationFix + // We know program is activated, so it must be in correct version and not use too much memory // Empty program address is supplied because we dont have access to this during rebuilding of wasm store - info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, arbosVersion, debugMode, &unlimitedGas) + info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, 0, debugMode, &unlimitedGas) if err != nil { log.Error("failed to reactivate program while rebuilding wasm store", "expected moduleHash", moduleHash, "err", err) return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err) From c909f75dbdc6a587fd3180f1f52f2da052b11b3b Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 20:11:55 -0600 Subject: [PATCH 09/19] tempfix: stylus_version --- arbos/programs/native.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arbos/programs/native.go b/arbos/programs/native.go index 2c39e96652..7ac96baf5e 100644 --- a/arbos/programs/native.go +++ b/arbos/programs/native.go @@ -119,7 +119,7 @@ func activateProgramInternal( output := &rustBytes{} status_asm := C.stylus_compile( goSlice(wasm), - u16(version), + u16(stylusVersion), cbool(debug), goSlice([]byte(target)), output, From 8cd3a85954b65d71d979fbc089a67742b7fc9aa2 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 20:16:16 -0600 Subject: [PATCH 10/19] lint and reviewer input --- arbitrator/jit/src/program.rs | 10 +++- arbitrator/prover/src/programs/mod.rs | 52 +++++++++---------- arbitrator/stylus/src/lib.rs | 10 +++- arbitrator/stylus/src/native.rs | 11 +++- .../wasm-libraries/user-host/src/link.rs | 10 +++- arbos/programs/native.go | 7 +-- arbos/programs/wasmstorehelper.go | 7 +-- 7 files changed, 70 insertions(+), 37 deletions(-) diff --git a/arbitrator/jit/src/program.rs b/arbitrator/jit/src/program.rs index 47227f117f..72c7541c0d 100644 --- a/arbitrator/jit/src/program.rs +++ b/arbitrator/jit/src/program.rs @@ -41,7 +41,15 @@ pub fn activate( let page_limit = mem.read_u16(pages_ptr); let gas_left = &mut mem.read_u64(gas_ptr); - match Module::activate(&wasm, codehash, stylus_version, arbos_version_for_gas, page_limit, debug, gas_left) { + match Module::activate( + &wasm, + codehash, + stylus_version, + arbos_version_for_gas, + page_limit, + debug, + gas_left, + ) { Ok((module, data)) => { mem.write_u64(gas_ptr, *gas_left); mem.write_u16(pages_ptr, data.footprint); diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs index 5f314dbf87..c03fbf8248 100644 --- a/arbitrator/prover/src/programs/mod.rs +++ b/arbitrator/prover/src/programs/mod.rs @@ -427,37 +427,37 @@ impl Module { debug: bool, gas: &mut u64, ) -> Result<(Self, StylusData)> { - // converts a number of microseconds to gas - // TODO: collapse to a single value after finalizing factors - let us_to_gas = |us: u64| { - let fudge = 2; - let sync_rate = 1_000_000 / 2; - let speed = 7_000_000; - us.saturating_mul(fudge * speed) / sync_rate - }; - - macro_rules! pay { - ($us:expr) => { - let amount = us_to_gas($us); - if *gas < amount { - *gas = 0; - bail!("out of gas"); - } - *gas -= amount; - }; - } - let compile = CompileConfig::version(stylus_version, debug); let (bin, stylus_data) = WasmBinary::parse_user(wasm, page_limit, &compile, codehash) .wrap_err("failed to parse wasm")?; - // pay for wasm - if arbos_version_for_gas >= ARBOS_VERSION_CHARGE_WASM_LEN { - let wasm_len = wasm.len() as u64; - pay!(wasm_len.saturating_mul(31_733) / 100_000); - } - if arbos_version_for_gas > 0 { + // converts a number of microseconds to gas + // TODO: collapse to a single value after finalizing factors + let us_to_gas = |us: u64| { + let fudge = 2; + let sync_rate = 1_000_000 / 2; + let speed = 7_000_000; + us.saturating_mul(fudge * speed) / sync_rate + }; + + macro_rules! pay { + ($us:expr) => { + let amount = us_to_gas($us); + if *gas < amount { + *gas = 0; + bail!("out of gas"); + } + *gas -= amount; + }; + } + + // pay for wasm + if arbos_version_for_gas >= ARBOS_VERSION_CHARGE_WASM_LEN { + let wasm_len = wasm.len() as u64; + pay!(wasm_len.saturating_mul(31_733) / 100_000); + } + // pay for funcs let funcs = bin.functions.len() as u64; pay!(funcs.saturating_mul(17_263) / 100_000); diff --git a/arbitrator/stylus/src/lib.rs b/arbitrator/stylus/src/lib.rs index c53d1a663b..052bfc7229 100644 --- a/arbitrator/stylus/src/lib.rs +++ b/arbitrator/stylus/src/lib.rs @@ -154,7 +154,15 @@ pub unsafe extern "C" fn stylus_activate( let codehash = &*codehash; let gas = &mut *gas; - let (module, info) = match native::activate(wasm, codehash, stylus_version, arbos_version_for_gas, page_limit, debug, gas) { + let (module, info) = match native::activate( + wasm, + codehash, + stylus_version, + arbos_version_for_gas, + page_limit, + debug, + gas, + ) { Ok(val) => val, Err(err) => return output.write_err(err), }; diff --git a/arbitrator/stylus/src/native.rs b/arbitrator/stylus/src/native.rs index f2f63fe216..7507d27467 100644 --- a/arbitrator/stylus/src/native.rs +++ b/arbitrator/stylus/src/native.rs @@ -357,8 +357,15 @@ pub fn activate( debug: bool, gas: &mut u64, ) -> Result<(ProverModule, StylusData)> { - let (module, stylus_data) = - ProverModule::activate(wasm, codehash, stylus_version, arbos_version_for_gas, page_limit, debug, gas)?; + let (module, stylus_data) = ProverModule::activate( + wasm, + codehash, + stylus_version, + arbos_version_for_gas, + page_limit, + debug, + gas, + )?; Ok((module, stylus_data)) } diff --git a/arbitrator/wasm-libraries/user-host/src/link.rs b/arbitrator/wasm-libraries/user-host/src/link.rs index 6c2d3c6c62..f6e7dfad39 100644 --- a/arbitrator/wasm-libraries/user-host/src/link.rs +++ b/arbitrator/wasm-libraries/user-host/src/link.rs @@ -59,7 +59,15 @@ pub unsafe extern "C" fn programs__activate( let page_limit = STATIC_MEM.read_u16(pages_ptr); let gas_left = &mut STATIC_MEM.read_u64(gas_ptr); - match Module::activate(&wasm, codehash, stylus_version, arbos_version_for_gas, page_limit, debug, gas_left) { + match Module::activate( + &wasm, + codehash, + stylus_version, + arbos_version_for_gas, + page_limit, + debug, + gas_left, + ) { Ok((module, data)) => { STATIC_MEM.write_u64(gas_ptr, *gas_left); STATIC_MEM.write_u16(pages_ptr, data.footprint); diff --git a/arbos/programs/native.go b/arbos/programs/native.go index 7ac96baf5e..acc0ad41e6 100644 --- a/arbos/programs/native.go +++ b/arbos/programs/native.go @@ -171,11 +171,12 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err) } - // gas used for activation charging, which doesn't matter here - unlimitedGas := uint64(0xffffffffffff) + // don't charge gas + zeroArbosVersion := uint64(0) + zeroGas := uint64(0) // we know program is activated, so it must be in correct version and not use too much memory - info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, 0, debugMode, &unlimitedGas) + info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, zeroArbosVersion, debugMode, &zeroGas) if err != nil { log.Error("failed to reactivate program", "address", addressForLogging, "expected moduleHash", moduleHash, "err", err) return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err) diff --git a/arbos/programs/wasmstorehelper.go b/arbos/programs/wasmstorehelper.go index d7bafe7fbc..c2d1aa65b0 100644 --- a/arbos/programs/wasmstorehelper.go +++ b/arbos/programs/wasmstorehelper.go @@ -56,12 +56,13 @@ func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err) } - // nothing is charged, so gas and arbosVersion don't matter - unlimitedGas := uint64(0xffffffffffff) + // don't charge gas + zeroArbosVersion := uint64(0) + zeroGas := uint64(0) // We know program is activated, so it must be in correct version and not use too much memory // Empty program address is supplied because we dont have access to this during rebuilding of wasm store - info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, 0, debugMode, &unlimitedGas) + info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, zeroArbosVersion, debugMode, &zeroGas) if err != nil { log.Error("failed to reactivate program while rebuilding wasm store", "expected moduleHash", moduleHash, "err", err) return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err) From 48e447038e5ca7b65fe1ef49d5f4f3191a273384 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 21:26:30 -0600 Subject: [PATCH 11/19] stylus: use new constant for arbos version --- arbitrator/prover/src/programs/mod.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs index c03fbf8248..cd1a6d4214 100644 --- a/arbitrator/prover/src/programs/mod.rs +++ b/arbitrator/prover/src/programs/mod.rs @@ -28,8 +28,6 @@ use { wasmer_types::{MemoryIndex, ModuleInfo}, }; -const ARBOS_VERSION_CHARGE_WASM_LEN: u64 = 32; - pub mod config; pub mod counter; pub mod depth; @@ -453,7 +451,7 @@ impl Module { } // pay for wasm - if arbos_version_for_gas >= ARBOS_VERSION_CHARGE_WASM_LEN { + if arbos_version_for_gas >= ARBOS_VERSION_STYLUS_CHARGING_FIXES { let wasm_len = wasm.len() as u64; pay!(wasm_len.saturating_mul(31_733) / 100_000); } From d9bcf83b0bd357da83461106518791289bd88ee7 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Fri, 13 Sep 2024 15:02:35 -0600 Subject: [PATCH 12/19] move stylus arbos constant to arbutil/evm --- arbitrator/arbutil/src/evm/mod.rs | 2 ++ arbitrator/prover/src/programs/mod.rs | 1 - 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/arbitrator/arbutil/src/evm/mod.rs b/arbitrator/arbutil/src/evm/mod.rs index 1671e67072..e7defa1c43 100644 --- a/arbitrator/arbutil/src/evm/mod.rs +++ b/arbitrator/arbutil/src/evm/mod.rs @@ -74,6 +74,8 @@ pub const GASPRICE_GAS: u64 = GAS_QUICK_STEP; // vm.GasQuickStep (see jump_table.go) pub const ORIGIN_GAS: u64 = GAS_QUICK_STEP; +pub const ARBOS_VERSION_STYLUS_CHARGING_FIXES: u64 = 32; + #[derive(Clone, Copy, Debug, Default)] #[repr(C)] pub struct EvmData { diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs index 5c02e9c11a..a5df2e31a8 100644 --- a/arbitrator/prover/src/programs/mod.rs +++ b/arbitrator/prover/src/programs/mod.rs @@ -39,7 +39,6 @@ pub mod prelude; pub mod start; pub const STYLUS_ENTRY_POINT: &str = "user_entrypoint"; -pub const ARBOS_VERSION_STYLUS_CHARGING_FIXES: u64 = 32; pub trait ModuleMod { fn add_global(&mut self, name: &str, ty: Type, init: GlobalInit) -> Result; From 42e69a6109d13e151326ff47bea127da8a5a37f0 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Fri, 13 Sep 2024 15:08:24 -0600 Subject: [PATCH 13/19] compilatio fix for constant change --- arbitrator/prover/src/programs/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs index cec8d6ec6e..e83b1359fa 100644 --- a/arbitrator/prover/src/programs/mod.rs +++ b/arbitrator/prover/src/programs/mod.rs @@ -8,7 +8,7 @@ use crate::{ programs::config::CompileConfig, value::{FunctionType as ArbFunctionType, Value}, }; -use arbutil::{math::SaturatingSum, Bytes32, Color}; +use arbutil::{math::SaturatingSum, Bytes32, Color, evm::ARBOS_VERSION_STYLUS_CHARGING_FIXES}; use eyre::{bail, eyre, Report, Result, WrapErr}; use fnv::FnvHashMap as HashMap; use std::fmt::Debug; From c5bff799993deab44faec3b1e6586f3a2058da9c Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Fri, 13 Sep 2024 15:17:29 -0600 Subject: [PATCH 14/19] cargo fmt --- arbitrator/prover/src/programs/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs index e83b1359fa..d8717c9f7d 100644 --- a/arbitrator/prover/src/programs/mod.rs +++ b/arbitrator/prover/src/programs/mod.rs @@ -8,7 +8,7 @@ use crate::{ programs::config::CompileConfig, value::{FunctionType as ArbFunctionType, Value}, }; -use arbutil::{math::SaturatingSum, Bytes32, Color, evm::ARBOS_VERSION_STYLUS_CHARGING_FIXES}; +use arbutil::{evm::ARBOS_VERSION_STYLUS_CHARGING_FIXES, math::SaturatingSum, Bytes32, Color}; use eyre::{bail, eyre, Report, Result, WrapErr}; use fnv::FnvHashMap as HashMap; use std::fmt::Debug; From a219e3e19cf6447384b95540356719dfb03b2bd3 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Thu, 12 Sep 2024 21:50:54 -0600 Subject: [PATCH 15/19] stylus: pass arbos_version in EvmData --- arbitrator/arbutil/src/evm/mod.rs | 1 + arbitrator/jit/src/program.rs | 2 ++ .../wasm-libraries/user-host/src/link.rs | 2 ++ arbos/programs/native.go | 1 + arbos/programs/programs.go | 22 +++++++++++++++++++ arbos/programs/testcompile.go | 2 +- arbos/programs/wasm_api.go | 2 ++ 7 files changed, 31 insertions(+), 1 deletion(-) diff --git a/arbitrator/arbutil/src/evm/mod.rs b/arbitrator/arbutil/src/evm/mod.rs index e7defa1c43..36dadd906a 100644 --- a/arbitrator/arbutil/src/evm/mod.rs +++ b/arbitrator/arbutil/src/evm/mod.rs @@ -79,6 +79,7 @@ pub const ARBOS_VERSION_STYLUS_CHARGING_FIXES: u64 = 32; #[derive(Clone, Copy, Debug, Default)] #[repr(C)] pub struct EvmData { + pub arbos_version: u64, pub block_basefee: Bytes32, pub chainid: u64, pub block_coinbase: Bytes20, diff --git a/arbitrator/jit/src/program.rs b/arbitrator/jit/src/program.rs index c608a3cf85..05a17b3f9a 100644 --- a/arbitrator/jit/src/program.rs +++ b/arbitrator/jit/src/program.rs @@ -225,6 +225,7 @@ pub fn create_stylus_config( /// Creates an `EvmData` handler from its component parts. pub fn create_evm_data( mut env: WasmEnvMut, + arbos_version: u64, block_basefee_ptr: GuestPtr, chainid: u64, block_coinbase_ptr: GuestPtr, @@ -243,6 +244,7 @@ pub fn create_evm_data( let (mut mem, _) = env.jit_env(); let evm_data = EvmData { + arbos_version, block_basefee: mem.read_bytes32(block_basefee_ptr), cached: cached != 0, chainid, diff --git a/arbitrator/wasm-libraries/user-host/src/link.rs b/arbitrator/wasm-libraries/user-host/src/link.rs index 428611167d..4f7955055f 100644 --- a/arbitrator/wasm-libraries/user-host/src/link.rs +++ b/arbitrator/wasm-libraries/user-host/src/link.rs @@ -243,6 +243,7 @@ pub unsafe extern "C" fn programs__create_stylus_config( /// #[no_mangle] pub unsafe extern "C" fn programs__create_evm_data( + arbos_version: u64, block_basefee_ptr: GuestPtr, chainid: u64, block_coinbase_ptr: GuestPtr, @@ -259,6 +260,7 @@ pub unsafe extern "C" fn programs__create_evm_data( reentrant: u32, ) -> u64 { let evm_data = EvmData { + arbos_version, block_basefee: read_bytes32(block_basefee_ptr), cached: cached != 0, chainid, diff --git a/arbos/programs/native.go b/arbos/programs/native.go index 377e25a31e..fccbeced93 100644 --- a/arbos/programs/native.go +++ b/arbos/programs/native.go @@ -391,6 +391,7 @@ func (params *ProgParams) encode() C.StylusConfig { func (data *EvmData) encode() C.EvmData { return C.EvmData{ + arbos_version: u64(data.arbosVersion), block_basefee: hashToBytes32(data.blockBasefee), chainid: u64(data.chainId), block_coinbase: addressToBytes20(data.blockCoinbase), diff --git a/arbos/programs/programs.go b/arbos/programs/programs.go index 12102bac84..8422d9f7e5 100644 --- a/arbos/programs/programs.go +++ b/arbos/programs/programs.go @@ -222,6 +222,7 @@ func (p Programs) CallProgram( } evmData := &EvmData{ + arbosVersion: evm.Context.ArbOSVersion, blockBasefee: common.BigToHash(evm.Context.BaseFee), chainId: evm.ChainConfig().ChainID.Uint64(), blockCoinbase: evm.Context.Coinbase, @@ -516,7 +517,9 @@ func (p Programs) progParams(version uint16, debug bool, params *StylusParams) * } } +// lint:require-exhaustive-initialization type EvmData struct { + arbosVersion uint64 blockBasefee common.Hash chainId uint64 blockCoinbase common.Address @@ -534,6 +537,25 @@ type EvmData struct { tracing bool } +var EmptyEvmData EvmData = EvmData{ + arbosVersion: 0, + blockBasefee: common.Hash{}, + chainId: 0, + blockCoinbase: common.Address{}, + blockGasLimit: 0, + blockNumber: 0, + blockTimestamp: 0, + contractAddress: common.Address{}, + moduleHash: common.Hash{}, + msgSender: common.Address{}, + msgValue: common.Hash{}, + txGasPrice: common.Hash{}, + txOrigin: common.Address{}, + reentrant: 0, + cached: false, + tracing: false, +} + type activationInfo struct { moduleHash common.Hash initGas uint16 diff --git a/arbos/programs/testcompile.go b/arbos/programs/testcompile.go index 1daf470620..07493d0179 100644 --- a/arbos/programs/testcompile.go +++ b/arbos/programs/testcompile.go @@ -222,7 +222,7 @@ func testCompileLoad() error { calldata := []byte{} - evmData := EvmData{} + evmData := EmptyEvmData progParams := ProgParams{ MaxDepth: 10000, InkPrice: 1, diff --git a/arbos/programs/wasm_api.go b/arbos/programs/wasm_api.go index d7bac056c0..42b58e39c5 100644 --- a/arbos/programs/wasm_api.go +++ b/arbos/programs/wasm_api.go @@ -22,6 +22,7 @@ type evmDataHandler uint64 //go:wasmimport programs create_evm_data func createEvmData( + arbosVersion uint64, blockBaseFee unsafe.Pointer, chainid uint64, blockCoinbase unsafe.Pointer, @@ -45,6 +46,7 @@ func (params *ProgParams) createHandler() stylusConfigHandler { func (data *EvmData) createHandler() evmDataHandler { return createEvmData( + data.arbosVersion, arbutil.SliceToUnsafePointer(data.blockBasefee[:]), data.chainId, arbutil.SliceToUnsafePointer(data.blockCoinbase[:]), From 0ca2aeb7550c7daeceace906e2334784dcb01a5c Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Fri, 13 Sep 2024 16:02:23 -0600 Subject: [PATCH 16/19] stylus: fix gas overcharging in get_bytes32 for new arbos --- arbitrator/arbutil/src/evm/api.rs | 2 +- arbitrator/arbutil/src/evm/req.rs | 5 ++--- arbitrator/stylus/src/test/api.rs | 2 +- arbitrator/stylus/src/test/native.rs | 4 ++-- .../wasm-libraries/user-host-trait/src/lib.rs | 15 ++++++++++++--- 5 files changed, 18 insertions(+), 10 deletions(-) diff --git a/arbitrator/arbutil/src/evm/api.rs b/arbitrator/arbutil/src/evm/api.rs index 093e7f2984..9d4c78c0de 100644 --- a/arbitrator/arbutil/src/evm/api.rs +++ b/arbitrator/arbutil/src/evm/api.rs @@ -77,7 +77,7 @@ pub trait EvmApi: Send + 'static { /// Reads the 32-byte value in the EVM state trie at offset `key`. /// Returns the value and the access cost in gas. /// Analogous to `vm.SLOAD`. - fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64); + fn get_bytes32(&mut self, key: Bytes32, evm_api_gas_to_use: u64) -> (Bytes32, u64); /// Stores the given value at the given key in Stylus VM's cache of the EVM state trie. /// Note that the actual values only get written after calls to `set_trie_slots`. diff --git a/arbitrator/arbutil/src/evm/req.rs b/arbitrator/arbutil/src/evm/req.rs index 287db357f3..1cfceda6b7 100644 --- a/arbitrator/arbutil/src/evm/req.rs +++ b/arbitrator/arbutil/src/evm/req.rs @@ -7,7 +7,6 @@ use crate::{ storage::{StorageCache, StorageWord}, user::UserOutcomeKind, }, - pricing::EVM_API_INK, Bytes20, Bytes32, }; use eyre::{bail, eyre, Result}; @@ -99,13 +98,13 @@ impl> EvmApiRequestor { } impl> EvmApi for EvmApiRequestor { - fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) { + fn get_bytes32(&mut self, key: Bytes32, evm_api_gas_to_use: u64) -> (Bytes32, u64) { let cache = &mut self.storage_cache; let mut cost = cache.read_gas(); let value = cache.entry(key).or_insert_with(|| { let (res, _, gas) = self.handler.request(EvmApiMethod::GetBytes32, key); - cost = cost.saturating_add(gas).saturating_add(EVM_API_INK); + cost = cost.saturating_add(gas).saturating_add(evm_api_gas_to_use); StorageWord::known(res.try_into().unwrap()) }); (value.value, cost) diff --git a/arbitrator/stylus/src/test/api.rs b/arbitrator/stylus/src/test/api.rs index 5d9f625e5e..66d600a6f7 100644 --- a/arbitrator/stylus/src/test/api.rs +++ b/arbitrator/stylus/src/test/api.rs @@ -68,7 +68,7 @@ impl TestEvmApi { } impl EvmApi for TestEvmApi { - fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) { + fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: u64) -> (Bytes32, u64) { let storage = &mut self.storage.lock(); let storage = storage.get_mut(&self.program).unwrap(); let value = storage.get(&key).cloned().unwrap_or_default(); diff --git a/arbitrator/stylus/src/test/native.rs b/arbitrator/stylus/src/test/native.rs index 503e5875fe..9669932a03 100644 --- a/arbitrator/stylus/src/test/native.rs +++ b/arbitrator/stylus/src/test/native.rs @@ -381,7 +381,7 @@ fn test_storage() -> Result<()> { let (mut native, mut evm) = TestInstance::new_with_evm(filename, &compile, config)?; run_native(&mut native, &store_args, ink)?; - assert_eq!(evm.get_bytes32(key.into()).0, Bytes32(value)); + assert_eq!(evm.get_bytes32(key.into(), 0).0, Bytes32(value)); assert_eq!(run_native(&mut native, &load_args, ink)?, value); let mut machine = Machine::from_user_path(Path::new(filename), &compile)?; @@ -465,7 +465,7 @@ fn test_calls() -> Result<()> { run_native(&mut native, &args, ink)?; for (key, value) in slots { - assert_eq!(evm.get_bytes32(key).0, value); + assert_eq!(evm.get_bytes32(key, 0).0, value); } Ok(()) } diff --git a/arbitrator/wasm-libraries/user-host-trait/src/lib.rs b/arbitrator/wasm-libraries/user-host-trait/src/lib.rs index 37af85c382..9665d8bbbf 100644 --- a/arbitrator/wasm-libraries/user-host-trait/src/lib.rs +++ b/arbitrator/wasm-libraries/user-host-trait/src/lib.rs @@ -8,7 +8,7 @@ use arbutil::{ api::{DataReader, EvmApi}, storage::StorageCache, user::UserOutcomeKind, - EvmData, + EvmData, ARBOS_VERSION_STYLUS_CHARGING_FIXES, }, pricing::{self, EVM_API_INK, HOSTIO_INK, PTR_INK}, Bytes20, Bytes32, @@ -143,11 +143,20 @@ pub trait UserHost: GasMeteredMachine { /// [`SLOAD`]: https://www.evm.codes/#54 fn storage_load_bytes32(&mut self, key: GuestPtr, dest: GuestPtr) -> Result<(), Self::Err> { self.buy_ink(HOSTIO_INK + 2 * PTR_INK)?; - self.require_gas(evm::COLD_SLOAD_GAS + EVM_API_INK + StorageCache::REQUIRED_ACCESS_GAS)?; // cache-miss case + let arbos_version = self.evm_data().arbos_version; + // require for cache-miss case, preserve wrong behavior for old arbos + let evm_api_gas_to_use = if arbos_version < ARBOS_VERSION_STYLUS_CHARGING_FIXES { + EVM_API_INK + } else { + self.pricing().ink_to_gas(EVM_API_INK) + }; + self.require_gas( + evm::COLD_SLOAD_GAS + StorageCache::REQUIRED_ACCESS_GAS + evm_api_gas_to_use, + )?; let key = self.read_bytes32(key)?; - let (value, gas_cost) = self.evm_api().get_bytes32(key); + let (value, gas_cost) = self.evm_api().get_bytes32(key, evm_api_gas_to_use); self.buy_gas(gas_cost)?; self.write_bytes32(dest, value)?; trace!("storage_load_bytes32", self, key, value) From f6fcf75a7364d5c5a9dbe38f3df089f60c580093 Mon Sep 17 00:00:00 2001 From: Tsahi Zidenberg Date: Fri, 13 Sep 2024 16:55:13 -0600 Subject: [PATCH 17/19] user-test build fix --- arbitrator/wasm-libraries/user-test/src/program.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arbitrator/wasm-libraries/user-test/src/program.rs b/arbitrator/wasm-libraries/user-test/src/program.rs index c56ea52ad0..85b522ee74 100644 --- a/arbitrator/wasm-libraries/user-test/src/program.rs +++ b/arbitrator/wasm-libraries/user-test/src/program.rs @@ -102,7 +102,7 @@ impl Program { pub struct MockEvmApi; impl EvmApi for MockEvmApi { - fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) { + fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: u64) -> (Bytes32, u64) { let value = KEYS.lock().get(&key).cloned().unwrap_or_default(); (value, 2100) // pretend worst case } From 70a24c32911561fa7384bbd054ae79a28f7f8fc8 Mon Sep 17 00:00:00 2001 From: Lee Bousfield Date: Thu, 19 Sep 2024 21:40:01 -0500 Subject: [PATCH 18/19] Add JIT backwards compatibility test --- system_tests/block_validator_test.go | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/system_tests/block_validator_test.go b/system_tests/block_validator_test.go index cca5572f4e..9125c3921e 100644 --- a/system_tests/block_validator_test.go +++ b/system_tests/block_validator_test.go @@ -284,6 +284,20 @@ func TestBlockValidatorSimpleOnchain(t *testing.T) { testBlockValidatorSimple(t, opts) } +func TestBlockValidatorSimpleJITOnchainWithPublishedMachine(t *testing.T) { + cr, err := github.LatestConsensusRelease(context.Background()) + Require(t, err) + machPath := populateMachineDir(t, cr) + opts := Options{ + dasModeString: "onchain", + workloadLoops: 1, + workload: ethSend, + arbitrator: false, + wasmRootDir: machPath, + } + testBlockValidatorSimple(t, opts) +} + func TestBlockValidatorSimpleOnchainWithPublishedMachine(t *testing.T) { cr, err := github.LatestConsensusRelease(context.Background()) Require(t, err) From 17834b0ea4082c1fcde06e9039a80260bb7cdf46 Mon Sep 17 00:00:00 2001 From: Lee Bousfield Date: Thu, 19 Sep 2024 21:35:42 -0500 Subject: [PATCH 19/19] JIT validation backwards compatibility --- arbitrator/jit/src/machine.rs | 2 + arbitrator/jit/src/program.rs | 62 ++++++++++++++++++- .../wasm-libraries/user-host/src/link.rs | 4 +- arbos/programs/wasm.go | 2 +- arbos/programs/wasm_api.go | 2 +- 5 files changed, 66 insertions(+), 6 deletions(-) diff --git a/arbitrator/jit/src/machine.rs b/arbitrator/jit/src/machine.rs index 2a3c5c5616..02523f740a 100644 --- a/arbitrator/jit/src/machine.rs +++ b/arbitrator/jit/src/machine.rs @@ -129,7 +129,9 @@ pub fn create(opts: &Opts, env: WasmEnv) -> (Instance, FunctionEnv, Sto "send_response" => func!(program::send_response), "create_stylus_config" => func!(program::create_stylus_config), "create_evm_data" => func!(program::create_evm_data), + "create_evm_data_v2" => func!(program::create_evm_data_v2), "activate" => func!(program::activate), + "activate_v2" => func!(program::activate_v2), }, }; diff --git a/arbitrator/jit/src/program.rs b/arbitrator/jit/src/program.rs index 145e1f6daf..72ffce1a59 100644 --- a/arbitrator/jit/src/program.rs +++ b/arbitrator/jit/src/program.rs @@ -16,8 +16,29 @@ use prover::{ programs::{config::PricingParams, prelude::*}, }; -/// activates a user program +const DEFAULT_STYLUS_ARBOS_VERSION: u64 = 31; + pub fn activate( + env: WasmEnvMut, + wasm_ptr: GuestPtr, + wasm_size: u32, + pages_ptr: GuestPtr, + asm_estimate_ptr: GuestPtr, + init_cost_ptr: GuestPtr, + cached_init_cost_ptr: GuestPtr, + stylus_version: u16, + debug: u32, + codehash: GuestPtr, + module_hash_ptr: GuestPtr, + gas_ptr: GuestPtr, + err_buf: GuestPtr, + err_buf_len: u32, +) -> Result { + activate_v2(env, wasm_ptr, wasm_size, pages_ptr, asm_estimate_ptr, init_cost_ptr, cached_init_cost_ptr, stylus_version, DEFAULT_STYLUS_ARBOS_VERSION, debug, codehash, module_hash_ptr, gas_ptr, err_buf, err_buf_len) +} + +/// activates a user program +pub fn activate_v2( mut env: WasmEnvMut, wasm_ptr: GuestPtr, wasm_size: u32, @@ -231,8 +252,45 @@ pub fn create_stylus_config( Ok(res as u64) } -/// Creates an `EvmData` handler from its component parts. pub fn create_evm_data( + env: WasmEnvMut, + block_basefee_ptr: GuestPtr, + chainid: u64, + block_coinbase_ptr: GuestPtr, + block_gas_limit: u64, + block_number: u64, + block_timestamp: u64, + contract_address_ptr: GuestPtr, + module_hash_ptr: GuestPtr, + msg_sender_ptr: GuestPtr, + msg_value_ptr: GuestPtr, + tx_gas_price_ptr: GuestPtr, + tx_origin_ptr: GuestPtr, + cached: u32, + reentrant: u32, +) -> Result { + create_evm_data_v2( + env, + DEFAULT_STYLUS_ARBOS_VERSION, + block_basefee_ptr, + chainid, + block_coinbase_ptr, + block_gas_limit, + block_number, + block_timestamp, + contract_address_ptr, + module_hash_ptr, + msg_sender_ptr, + msg_value_ptr, + tx_gas_price_ptr, + tx_origin_ptr, + cached, + reentrant, + ) +} + +/// Creates an `EvmData` handler from its component parts. +pub fn create_evm_data_v2( mut env: WasmEnvMut, arbos_version: u64, block_basefee_ptr: GuestPtr, diff --git a/arbitrator/wasm-libraries/user-host/src/link.rs b/arbitrator/wasm-libraries/user-host/src/link.rs index 145d796ac1..f4c402fd97 100644 --- a/arbitrator/wasm-libraries/user-host/src/link.rs +++ b/arbitrator/wasm-libraries/user-host/src/link.rs @@ -37,7 +37,7 @@ struct MemoryLeaf([u8; 32]); /// /// pages_ptr: starts pointing to max allowed pages, returns number of pages used #[no_mangle] -pub unsafe extern "C" fn programs__activate( +pub unsafe extern "C" fn programs__activate_v2( wasm_ptr: GuestPtr, wasm_size: usize, pages_ptr: GuestPtr, @@ -251,7 +251,7 @@ pub unsafe extern "C" fn programs__create_stylus_config( /// Creates an `EvmData` handler from its component parts. /// #[no_mangle] -pub unsafe extern "C" fn programs__create_evm_data( +pub unsafe extern "C" fn programs__create_evm_data_v2( arbos_version: u64, block_basefee_ptr: GuestPtr, chainid: u64, diff --git a/arbos/programs/wasm.go b/arbos/programs/wasm.go index a3209d9ac5..8f79944fbe 100644 --- a/arbos/programs/wasm.go +++ b/arbos/programs/wasm.go @@ -36,7 +36,7 @@ type rustConfig byte type rustModule byte type rustEvmData byte -//go:wasmimport programs activate +//go:wasmimport programs activate_v2 func programActivate( wasm_ptr unsafe.Pointer, wasm_size uint32, diff --git a/arbos/programs/wasm_api.go b/arbos/programs/wasm_api.go index 42b58e39c5..a4ebc1f778 100644 --- a/arbos/programs/wasm_api.go +++ b/arbos/programs/wasm_api.go @@ -20,7 +20,7 @@ func createStylusConfig(version uint32, max_depth uint32, ink_price uint32, debu type evmDataHandler uint64 -//go:wasmimport programs create_evm_data +//go:wasmimport programs create_evm_data_v2 func createEvmData( arbosVersion uint64, blockBaseFee unsafe.Pointer,