From 564ef9d18273a926b0cc8da304842f9434838108 Mon Sep 17 00:00:00 2001 From: Ammar Arif Date: Thu, 13 Feb 2025 13:31:02 -0500 Subject: [PATCH 1/3] explicitly set call's run resources --- crates/katana/contracts/Scarb.lock | 7 + crates/katana/contracts/Scarb.toml | 2 +- crates/katana/contracts/misc/Scarb.toml | 14 + crates/katana/contracts/misc/src/lib.cairo | 16 + crates/katana/executor/src/abstraction/mod.rs | 2 +- .../src/implementation/blockifier/call.rs | 162 ++++++++ .../src/implementation/blockifier/mod.rs | 3 +- .../src/implementation/blockifier/utils.rs | 58 +-- .../executor/tests/fixtures/call_test.json | 372 ++++++++++++++++++ crates/katana/executor/tests/fixtures/mod.rs | 6 +- 10 files changed, 583 insertions(+), 59 deletions(-) create mode 100644 crates/katana/contracts/misc/Scarb.toml create mode 100644 crates/katana/contracts/misc/src/lib.cairo create mode 100644 crates/katana/executor/src/implementation/blockifier/call.rs create mode 100644 crates/katana/executor/tests/fixtures/call_test.json diff --git a/crates/katana/contracts/Scarb.lock b/crates/katana/contracts/Scarb.lock index ccff40fa32..4e315e0480 100644 --- a/crates/katana/contracts/Scarb.lock +++ b/crates/katana/contracts/Scarb.lock @@ -12,6 +12,13 @@ dependencies = [ name = "katana_messaging" version = "0.1.0" +[[package]] +name = "katana_misc" +version = "0.1.0" +dependencies = [ + "openzeppelin", +] + [[package]] name = "openzeppelin" version = "0.17.0" diff --git a/crates/katana/contracts/Scarb.toml b/crates/katana/contracts/Scarb.toml index 1b08cfd995..fbc35d9f6d 100644 --- a/crates/katana/contracts/Scarb.toml +++ b/crates/katana/contracts/Scarb.toml @@ -1,5 +1,5 @@ [workspace] -members = [ "account", "messaging/cairo" ] +members = [ "account", "messaging/cairo", "misc"] [workspace.package] version = "0.1.0" diff --git a/crates/katana/contracts/misc/Scarb.toml b/crates/katana/contracts/misc/Scarb.toml new file mode 100644 index 0000000000..88e11e0dc5 --- /dev/null +++ b/crates/katana/contracts/misc/Scarb.toml @@ -0,0 +1,14 @@ +[package] +name = "katana_misc" +version.workspace = true +edition.workspace = true + +# See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html + +[dependencies] +starknet.workspace = true +openzeppelin.workspace = true + +[[target.starknet-contract]] +sierra = true +casm = true diff --git a/crates/katana/contracts/misc/src/lib.cairo b/crates/katana/contracts/misc/src/lib.cairo new file mode 100644 index 0000000000..94fc5203da --- /dev/null +++ b/crates/katana/contracts/misc/src/lib.cairo @@ -0,0 +1,16 @@ +#[starknet::contract] +pub mod CallTest { + #[storage] + struct Storage { } + + #[external(v0)] + fn bounded_call(self: @ContractState, iterations: u64) { + let mut i = 0; + loop { + if i >= iterations { + break; + } + i += 1; + } + } +} diff --git a/crates/katana/executor/src/abstraction/mod.rs b/crates/katana/executor/src/abstraction/mod.rs index 5ef42990f1..9a0aee4889 100644 --- a/crates/katana/executor/src/abstraction/mod.rs +++ b/crates/katana/executor/src/abstraction/mod.rs @@ -103,7 +103,7 @@ pub struct ExecutionOutput { pub transactions: Vec<(TxWithHash, ExecutionResult)>, } -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct EntryPointCall { /// The address of the contract whose function you're calling. pub contract_address: ContractAddress, diff --git a/crates/katana/executor/src/implementation/blockifier/call.rs b/crates/katana/executor/src/implementation/blockifier/call.rs new file mode 100644 index 0000000000..c9c6226326 --- /dev/null +++ b/crates/katana/executor/src/implementation/blockifier/call.rs @@ -0,0 +1,162 @@ +use std::sync::Arc; + +use blockifier::context::{BlockContext, TransactionContext}; +use blockifier::execution::call_info::CallInfo; +use blockifier::execution::entry_point::{ + CallEntryPoint, EntryPointExecutionContext, EntryPointExecutionResult, +}; +use blockifier::state::cached_state::CachedState; +use blockifier::state::state_api::StateReader; +use blockifier::transaction::objects::{DeprecatedTransactionInfo, TransactionInfo}; +use katana_cairo::cairo_vm::vm::runners::cairo_runner::{ExecutionResources, RunResources}; +use katana_cairo::starknet_api::core::EntryPointSelector; +use katana_cairo::starknet_api::transaction::{Calldata, Fee}; +use katana_primitives::Felt; + +use super::utils::to_blk_address; +use crate::{EntryPointCall, ExecutionError}; + +/// Perform a function call on a contract and retrieve the return values. +pub fn execute_call( + request: EntryPointCall, + state: S, + block_context: &BlockContext, + max_gas: u64, +) -> Result, ExecutionError> { + let mut state = CachedState::new(state); + let res = execute_call_inner(request, &mut state, block_context, max_gas)?; + Ok(res.execution.retdata.0) +} + +fn execute_call_inner( + request: EntryPointCall, + state: &mut CachedState, + block_context: &BlockContext, + max_gas: u64, +) -> EntryPointExecutionResult { + let call = CallEntryPoint { + initial_gas: max_gas, + calldata: Calldata(Arc::new(request.calldata)), + storage_address: to_blk_address(request.contract_address), + entry_point_selector: EntryPointSelector(request.entry_point_selector), + ..Default::default() + }; + + // Now, the max step is not given directly to this function. + // It's computed by a new function max_steps, and it tooks the values + // from the block context itself instead of the input given. The dojoengine + // fork of the blockifier ensures we're not limited by the min function applied + // by starkware. + // https://github.com/starkware-libs/blockifier/blob/4fd71645b45fd1deb6b8e44802414774ec2a2ec1/crates/blockifier/src/execution/entry_point.rs#L159 + // https://github.com/dojoengine/blockifier/blob/5f58be8961ddf84022dd739a8ab254e32c435075/crates/blockifier/src/execution/entry_point.rs#L188 + + let limit_steps_by_resources = true; + let tx_info = DeprecatedTransactionInfo { max_fee: Fee(1), ..Default::default() }; + + let mut ctx = EntryPointExecutionContext::new_invoke( + Arc::new(TransactionContext { + block_context: block_context.clone(), + tx_info: TransactionInfo::Deprecated(tx_info), + }), + limit_steps_by_resources, + ) + .unwrap(); + + // manually override the run resources + ctx.vm_run_resources = RunResources::new(max_gas as usize); + call.execute(state, &mut ExecutionResources::default(), &mut ctx) +} + +#[cfg(test)] +mod tests { + use std::str::FromStr; + + use blockifier::context::BlockContext; + use blockifier::state::cached_state::{self}; + use katana_primitives::class::ContractClass; + use katana_primitives::{address, felt, ContractAddress}; + use katana_provider::test_utils; + use katana_provider::traits::contract::ContractClassWriter; + use katana_provider::traits::state::{StateFactoryProvider, StateWriter}; + use starknet::macros::selector; + + use super::execute_call_inner; + use crate::implementation::blockifier::state::StateProviderDb; + use crate::EntryPointCall; + + #[test] + fn max_steps() { + // -------------------- Preparations ------------------------------- + + let json = include_str!("../../../tests/fixtures/call_test.json"); + let class = ContractClass::from_str(json).unwrap(); + let class_hash = class.class_hash().unwrap(); + let casm_hash = class.clone().compile().unwrap().class_hash().unwrap(); + + // Initialize provider with the test contract + let provider = test_utils::test_provider(); + // Declare test contract + provider.set_class(class_hash, class).unwrap(); + provider.set_compiled_class_hash_of_class_hash(class_hash, casm_hash).unwrap(); + // Deploy test contract + let address = address!("0x1337"); + provider.set_class_hash_of_contract(address, class_hash).unwrap(); + + let state = provider.latest().unwrap(); + let state = StateProviderDb::new(state, Default::default()); + + // --------------------------------------------------------------- + + let mut state = cached_state::CachedState::new(state); + let ctx = BlockContext::create_for_testing(); + + let mut req = EntryPointCall { + calldata: Vec::new(), + contract_address: address, + entry_point_selector: selector!("bounded_call"), + }; + + // all the values for the calldata are handpicked as it's difficult to write a function that + // consumes a specific number of gas + + let max_gas_1 = 1_000_000; + { + // ~900,000 gas + req.calldata = vec![felt!("460")]; + let info = execute_call_inner(req.clone(), &mut state, &ctx, max_gas_1).unwrap(); + assert!(max_gas_1 >= info.execution.gas_consumed); + + req.calldata = vec![felt!("600")]; + let result = execute_call_inner(req.clone(), &mut state, &ctx, max_gas_1); + assert!(result.is_err(), "should fail due to out of run resources") + } + + let max_gas_2 = 10_000_000; + { + // rougly equivalent to 9,000,000 gas + req.calldata = vec![felt!("4600")]; + let info = execute_call_inner(req.clone(), &mut state, &ctx, max_gas_2).unwrap(); + assert!(max_gas_2 >= info.execution.gas_consumed); + assert!(max_gas_1 < info.execution.gas_consumed); + + req.calldata = vec![felt!("5000")]; + let result = execute_call_inner(req.clone(), &mut state, &ctx, max_gas_2); + assert!(result.is_err(), "should fail due to out of run resources") + } + + let max_gas_3 = 100_000_000; + { + req.calldata = vec![felt!("47000")]; + let info = execute_call_inner(req.clone(), &mut state, &ctx, max_gas_3).unwrap(); + assert!(max_gas_3 >= info.execution.gas_consumed); + assert!(max_gas_2 < info.execution.gas_consumed); + + req.calldata = vec![felt!("60000")]; + let result = execute_call_inner(req.clone(), &mut state, &ctx, max_gas_3); + assert!(result.is_err(), "should fail due to out of run resources") + } + + // Check that 'call' isn't bounded by the block context max invoke steps + assert!(max_gas_3 > ctx.versioned_constants().invoke_tx_max_n_steps as u64); + } +} diff --git a/crates/katana/executor/src/implementation/blockifier/mod.rs b/crates/katana/executor/src/implementation/blockifier/mod.rs index 051f04ebc6..ee38b16cdf 100644 --- a/crates/katana/executor/src/implementation/blockifier/mod.rs +++ b/crates/katana/executor/src/implementation/blockifier/mod.rs @@ -2,6 +2,7 @@ pub use blockifier; use blockifier::bouncer::{Bouncer, BouncerConfig, BouncerWeights}; +pub mod call; mod error; pub mod state; pub mod utils; @@ -328,7 +329,7 @@ impl ExecutorExt for StarknetVMProcessor<'_> { let block_context = &self.block_context; let mut state = self.state.inner.lock(); let state = MutRefState::new(&mut state.cached_state); - let retdata = utils::call(call, state, block_context, 1_000_000_000)?; + let retdata = call::execute_call(call, state, block_context, 1_000_000_000)?; Ok(retdata) } } diff --git a/crates/katana/executor/src/implementation/blockifier/utils.rs b/crates/katana/executor/src/implementation/blockifier/utils.rs index 4fbba3d13e..a95a6cc77c 100644 --- a/crates/katana/executor/src/implementation/blockifier/utils.rs +++ b/crates/katana/executor/src/implementation/blockifier/utils.rs @@ -4,23 +4,19 @@ use std::sync::Arc; use blockifier::blockifier::block::{BlockInfo, GasPrices}; use blockifier::bouncer::{Bouncer, BouncerConfig}; -use blockifier::context::{BlockContext, ChainInfo, FeeTokenAddresses, TransactionContext}; +use blockifier::context::{BlockContext, ChainInfo, FeeTokenAddresses}; use blockifier::execution::call_info::{ CallExecution, CallInfo, OrderedEvent, OrderedL2ToL1Message, }; -use blockifier::execution::common_hints::ExecutionMode; use blockifier::execution::contract_class::{ ClassInfo, ContractClass, ContractClassV0, ContractClassV1, }; -use blockifier::execution::entry_point::{CallEntryPoint, CallType, EntryPointExecutionContext}; +use blockifier::execution::entry_point::CallType; use blockifier::fee::fee_utils::get_fee_by_gas_vector; use blockifier::state::cached_state::{self, TransactionalState}; use blockifier::state::state_api::{StateReader, UpdatableState}; use blockifier::transaction::account_transaction::AccountTransaction; -use blockifier::transaction::objects::{ - DeprecatedTransactionInfo, FeeType, HasRelatedFeeType, TransactionExecutionInfo, - TransactionInfo, -}; +use blockifier::transaction::objects::{FeeType, HasRelatedFeeType, TransactionExecutionInfo}; use blockifier::transaction::transaction_execution::Transaction; use blockifier::transaction::transactions::{ DeclareTransaction, DeployAccountTransaction, ExecutableTransaction, InvokeTransaction, @@ -56,7 +52,7 @@ use katana_provider::traits::contract::ContractClassProvider; use starknet::core::utils::parse_cairo_short_string; use super::state::CachedState; -use crate::abstraction::{EntryPointCall, ExecutionFlags}; +use crate::abstraction::ExecutionFlags; use crate::utils::build_receipt; use crate::{ExecutionError, ExecutionResult, ExecutorResult}; @@ -156,51 +152,6 @@ pub fn transact( } } -/// Perform a function call on a contract and retrieve the return values. -pub fn call( - request: EntryPointCall, - state: S, - block_context: &BlockContext, - initial_gas: u128, -) -> Result, ExecutionError> { - let mut state = cached_state::CachedState::new(state); - - let call = CallEntryPoint { - initial_gas: initial_gas as u64, - storage_address: to_blk_address(request.contract_address), - entry_point_selector: core::EntryPointSelector(request.entry_point_selector), - calldata: Calldata(Arc::new(request.calldata)), - ..Default::default() - }; - - // TODO: this must be false if fees are disabled I assume. - let limit_steps_by_resources = true; - - // Now, the max step is not given directly to this function. - // It's computed by a new function max_steps, and it tooks the values - // from the block context itself instead of the input give. The dojoengine - // fork of the blockifier ensures we're not limited by the min function applied - // by starkware. - // https://github.com/starkware-libs/blockifier/blob/4fd71645b45fd1deb6b8e44802414774ec2a2ec1/crates/blockifier/src/execution/entry_point.rs#L159 - // https://github.com/dojoengine/blockifier/blob/5f58be8961ddf84022dd739a8ab254e32c435075/crates/blockifier/src/execution/entry_point.rs#L188 - - let res = call.execute( - &mut state, - &mut ExecutionResources::default(), - &mut EntryPointExecutionContext::new( - Arc::new(TransactionContext { - block_context: block_context.clone(), - tx_info: TransactionInfo::Deprecated(DeprecatedTransactionInfo::default()), - }), - ExecutionMode::Execute, - limit_steps_by_resources, - ) - .expect("shouldn't fail"), - )?; - - Ok(res.execution.retdata.0) -} - pub fn to_executor_tx(tx: ExecutableTxWithHash) -> Transaction { let hash = tx.hash; @@ -739,6 +690,7 @@ mod tests { use std::collections::{HashMap, HashSet}; + use blockifier::execution::entry_point::CallEntryPoint; use katana_cairo::cairo_vm::types::builtin_name::BuiltinName; use katana_cairo::cairo_vm::vm::runners::cairo_runner::ExecutionResources; use katana_cairo::starknet_api::core::EntryPointSelector; diff --git a/crates/katana/executor/tests/fixtures/call_test.json b/crates/katana/executor/tests/fixtures/call_test.json new file mode 100644 index 0000000000..ee7ce7d9a4 --- /dev/null +++ b/crates/katana/executor/tests/fixtures/call_test.json @@ -0,0 +1,372 @@ +{ + "sierra_program": [ + "0x1", + "0x6", + "0x0", + "0x2", + "0x8", + "0x4", + "0x8b", + "0x75", + "0x18", + "0x52616e6765436865636b", + "0x800000000000000100000000000000000000000000000000", + "0x436f6e7374", + "0x800000000000000000000000000000000000000000000002", + "0x1", + "0x16", + "0x2", + "0x7536345f616464204f766572666c6f77", + "0x9", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x4f7574206f6620676173", + "0x4172726179", + "0x800000000000000300000000000000000000000000000001", + "0x536e617073686f74", + "0x800000000000000700000000000000000000000000000001", + "0x5", + "0x537472756374", + "0x800000000000000700000000000000000000000000000002", + "0x0", + "0x1baeba72e79e9db2587cf44fedb2f3700b2075a5e8e39a562584862c4b71f62", + "0x6", + "0x2ee1e2b1b89f8c495f200e4956278a4d47395fe262f27b52e5865c9524c08c3", + "0x7", + "0x753634", + "0x800000000000000700000000000000000000000000000000", + "0x800000000000000f00000000000000000000000000000001", + "0x800000000000000700000000000000000000000000000003", + "0xa", + "0x16a4c8d7c05909052238a862d8cc3e7975bf05a07b3a69c6b28951083a6d672", + "0x800000000000000300000000000000000000000000000003", + "0xc", + "0x456e756d", + "0x909b0519d7c88c554565d942b48b326c8dcbd2e2915301868fb8159e606aa3", + "0xb", + "0xd", + "0x4275696c74696e436f737473", + "0x53797374656d", + "0x9931c641b913035ae674b400b61a51476d506bbe8bba2ff8a6272790aba9e6", + "0x8", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x426f78", + "0x29d7d57c04a880978e7b3689f6218e507f3be17588744b58dc17762447ad0e7", + "0x14", + "0x66656c74323532", + "0x4761734275696c74696e", + "0x39", + "0x7265766f6b655f61705f747261636b696e67", + "0x77697468647261775f676173", + "0x6272616e63685f616c69676e", + "0x7374727563745f6465636f6e737472756374", + "0x656e61626c655f61705f747261636b696e67", + "0x73746f72655f74656d70", + "0x61727261795f736e617073686f745f706f705f66726f6e74", + "0x656e756d5f696e6974", + "0x15", + "0x6a756d70", + "0x7374727563745f636f6e737472756374", + "0x656e756d5f6d61746368", + "0x756e626f78", + "0x72656e616d65", + "0x7536345f7472795f66726f6d5f66656c74323532", + "0x64697361626c655f61705f747261636b696e67", + "0x64726f70", + "0x61727261795f6e6577", + "0x636f6e73745f61735f696d6d656469617465", + "0x13", + "0x61727261795f617070656e64", + "0x12", + "0x17", + "0x11", + "0x6765745f6275696c74696e5f636f737473", + "0x10", + "0x77697468647261775f6761735f616c6c", + "0xf", + "0x66756e6374696f6e5f63616c6c", + "0x3", + "0xe", + "0x736e617073686f745f74616b65", + "0x4", + "0x647570", + "0x7536345f6f766572666c6f77696e675f737562", + "0x7536345f6f766572666c6f77696e675f616464", + "0xb6", + "0xffffffffffffffff", + "0x70", + "0x5f", + "0x5b", + "0x19", + "0x2b", + "0x1a", + "0x1b", + "0x1c", + "0x1d", + "0x1e", + "0x1f", + "0x20", + "0x21", + "0x22", + "0x23", + "0x4d", + "0x24", + "0x25", + "0x26", + "0x27", + "0x28", + "0x29", + "0x2a", + "0x46", + "0x2c", + "0x2d", + "0x2e", + "0x2f", + "0x30", + "0x31", + "0x32", + "0x33", + "0x34", + "0x35", + "0x36", + "0x37", + "0x38", + "0x63", + "0x3a", + "0x3b", + "0x3c", + "0x3d", + "0x3e", + "0x3f", + "0x40", + "0x41", + "0x42", + "0x43", + "0x44", + "0x45", + "0xa8", + "0x8e", + "0x9a", + "0x7e", + "0x6f7", + "0x6050d0c0b07060504030a0706050403050709050403080706050403020100", + "0x111c05090516131b1116131a11191817051613121115051413121110050f0e", + "0x1e20022519241307090504032305220521131e2010051f0516131e111d131a", + "0x132f2e022d192c1c052b052a131b2006050f29280706050403230527052613", + "0x5053415050534130737050736060505351305053413331705053213311330", + "0x133d060505340605053c0605053b3705053a0507370507361c050539133837", + "0x391f0505390605054342050541060505400905053f2b05053f1505053f133e", + "0x5411349480505341347440505344605053445050534050744050736230505", + "0x39170505391005053f1005054e2205053f4d05053a054c054b090505344a05", + "0x1351090505501705053f4c0505411c05053f4f050541130744050736270505", + "0x5305074d050736050505411352070505414d05053413074d05073622050539", + "0x54c054c1313540513071317150755104f0754070513070513135405131313", + "0x71322051f1c09075407270515134f0554054f051013135405134f13270554", + "0x131c134d0554051f05091323055405090527131f0554051c05171313540513", + "0x5540522052713480554054a051f134a055405132213135405130713134605", + "0x546054d13135405130713440556460554074d0523134d0554054805091323", + "0x55706370754072b4f0746132b0554052b0548132b05540542054a13420554", + "0x51307135a0559580007540723051513370554053705101313540513071345", + "0x6131354050605371313540558052b13135405000542131354051344131354", + "0x58135d0554055c5b0700135c0554055c0548135c0554051345135b05540513", + "0x133705540537051013600554055f055b135f0554055d5e075a135e05540513", + "0x713600710374f056005540560055e130705540507055d131005540510055c", + "0x554056105601361055405135f131354055a05421313540513441313540513", + "0x1013670554051362131354051307136665076463620754076110374c611361", + "0x13060554050605631367055405670563136305540563055c13620554056205", + "0x671313540513071359056c6b0554076a0566136a69684c5405066763624f65", + "0x56a131354056e0569136f6e0754056d0568136d0554051306131354056b05", + "0x5c13680554056805101372055405710559137105540570056b13700554056f", + "0x130713720769684f057205540572055e130705540507055d13690554056905", + "0x7055d136905540569055c1368055405680510137305540559055b13135405", + "0x13540506053713135405130713730769684f057305540573055e1307055405", + "0x760554057574070013750554057505481375055405136d1374055405130613", + "0x55405650510137905540578055b13780554057677075a1377055405135813", + "0x790766654f057905540579055e130705540507055d136605540566055c1365", + "0x5130713137a05131c132e0554054505101313540523054213135405130713", + "0x131354051344132e0554054f0510131354052305421313540544056e131354", + "0x137d0554057c7b0700137c0554057c0548137c055405136f137b0554051306", + "0x2e0554052e051013800554057f055b137f0554057d7e075a137e0554051358", + "0x138007102e4f058005540580055e130705540507055d131005540510055c13", + "0x58205481382055405136d13810554051306131354054c0570131354051307", + "0x55b13850554058384075a1384055405135813830554058281070013820554", + "0x5e130705540507055d131705540517055c1315055405150510138605540585", + "0x150787104f0754070513070513135405134413860717154f05860554058605", + "0x9274f4c7213094c0754054c05711327070754050705711313540513071317", + "0x22131354054c05371313540522053713135405130713231f0788221c075407", + "0x131c0554051c051013480554054a0574134a0554054d070773134d05540513", + "0x52305371313540513071348101c4c0548055405480575131005540510055c", + "0x2b0789424407540746071f4c77134605540546056313460554051376131354", + "0x42055405420563131005540510055c13440554054405101313540513071337", + "0x54051307130045064c050045064c54054c4210444f65134c0554054c056313", + "0x48135a055405137813580554051306131354054c0537131354053705371313", + "0x5d0554055b5c075a135c0554051358135b0554055a580700135a0554055a05", + "0x554055e0575131005540510055c132b0554052b0510135e0554055d057913", + "0x54051306131354054c053713135405070537131354051307135e102b4c055e", + "0x540513581361055405605f070013600554056005481360055405136d135f05", + "0x17055c1315055405150510136505540563057913630554056162075a136205", + "0x70513444645134f174645134f076517154c05650554056505751317055405", + "0x8a4c0705134d45134c090945134f134c" + ], + "sierra_program_debug_info": { + "type_names": [ + [0, "RangeCheck"], + [1, "Const"], + [2, "Const"], + [ + 3, + "Const" + ], + [4, "Const"], + [5, "Array"], + [6, "Snapshot>"], + [7, "core::array::Span::"], + [8, "Tuple>"], + [9, "u64"], + [10, "Unit"], + [11, "Tuple"], + [12, "core::panics::Panic"], + [13, "Tuple>"], + [14, "core::panics::PanicResult::<(core::integer::u64, ())>"], + [15, "Const"], + [16, "BuiltinCosts"], + [17, "System"], + [ + 18, + "core::panics::PanicResult::<(core::array::Span::,)>" + ], + [ + 19, + "Const" + ], + [20, "Box"], + [21, "core::option::Option::>"], + [22, "felt252"], + [23, "GasBuiltin"] + ], + "libfunc_names": [ + [0, "revoke_ap_tracking"], + [1, "withdraw_gas"], + [2, "branch_align"], + [3, "struct_deconstruct>"], + [4, "enable_ap_tracking"], + [5, "store_temp"], + [6, "array_snapshot_pop_front"], + [ + 7, + "enum_init>, 0>" + ], + [8, "store_temp>>"], + [ + 9, + "store_temp>>" + ], + [10, "jump"], + [11, "struct_construct"], + [ + 12, + "enum_init>, 1>" + ], + [ + 13, + "enum_match>>" + ], + [14, "unbox"], + [15, "rename"], + [16, "store_temp"], + [17, "u64_try_from_felt252"], + [18, "disable_ap_tracking"], + [19, "drop>>"], + [20, "drop>"], + [21, "drop"], + [22, "array_new"], + [ + 23, + "const_as_immediate>" + ], + [24, "array_append"], + [25, "struct_construct"], + [26, "struct_construct>>"], + [ + 27, + "enum_init,)>, 1>" + ], + [28, "store_temp"], + [29, "store_temp"], + [ + 30, + "store_temp,)>>" + ], + [31, "get_builtin_costs"], + [32, "store_temp"], + [33, "withdraw_gas_all"], + [34, "const_as_immediate>"], + [35, "store_temp"], + [36, "function_call"], + [37, "enum_match>"], + [38, "drop>"], + [39, "snapshot_take>"], + [40, "drop>"], + [41, "struct_construct>"], + [42, "struct_construct>>"], + [ + 43, + "enum_init,)>, 0>" + ], + [44, "const_as_immediate>"], + [45, "drop"], + [ + 46, + "const_as_immediate>" + ], + [47, "drop>"], + [48, "dup"], + [49, "u64_overflowing_sub"], + [50, "struct_construct>"], + [ + 51, + "enum_init, 0>" + ], + [52, "store_temp>"], + [53, "const_as_immediate>"], + [54, "u64_overflowing_add"], + [ + 55, + "const_as_immediate>" + ], + [ + 56, + "enum_init, 1>" + ] + ], + "user_func_names": [ + [0, "katana_misc::CallTest::__wrapper__bounded_call"], + [1, "katana_misc::CallTest::bounded_call[expr10]"] + ] + }, + "contract_class_version": "0.1.0", + "entry_points_by_type": { + "EXTERNAL": [ + { + "selector": "0x21d0cf45d9490ac58c9252600f690efd840d30938fa0edbd7e88dd6e16e882c", + "function_idx": 0 + } + ], + "L1_HANDLER": [], + "CONSTRUCTOR": [] + }, + "abi": [ + { + "type": "function", + "name": "bounded_call", + "inputs": [{ "name": "iterations", "type": "core::integer::u64" }], + "outputs": [], + "state_mutability": "view" + }, + { + "type": "event", + "name": "katana_misc::CallTest::Event", + "kind": "enum", + "variants": [] + } + ] +} diff --git a/crates/katana/executor/tests/fixtures/mod.rs b/crates/katana/executor/tests/fixtures/mod.rs index 903f858d94..67515f8234 100644 --- a/crates/katana/executor/tests/fixtures/mod.rs +++ b/crates/katana/executor/tests/fixtures/mod.rs @@ -238,9 +238,9 @@ pub fn cfg() -> CfgEnv { CfgEnv { fee_token_addresses, - max_recursion_depth: 100, - validate_max_n_steps: 1_000_000, - invoke_tx_max_n_steps: 1_000_000, + max_recursion_depth: usize::MAX, + validate_max_n_steps: u32::MAX, + invoke_tx_max_n_steps: u32::MAX, chain_id: ChainId::parse("KATANA").unwrap(), } } From 6d3ec560e39bae0434ea659353ac4d45025f1779 Mon Sep 17 00:00:00 2001 From: Ammar Arif Date: Thu, 13 Feb 2025 14:11:30 -0500 Subject: [PATCH 2/3] add comments --- .../src/implementation/blockifier/call.rs | 21 +++++++++++-------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/crates/katana/executor/src/implementation/blockifier/call.rs b/crates/katana/executor/src/implementation/blockifier/call.rs index c9c6226326..018401c0be 100644 --- a/crates/katana/executor/src/implementation/blockifier/call.rs +++ b/crates/katana/executor/src/implementation/blockifier/call.rs @@ -42,16 +42,19 @@ fn execute_call_inner( ..Default::default() }; - // Now, the max step is not given directly to this function. - // It's computed by a new function max_steps, and it tooks the values - // from the block context itself instead of the input given. The dojoengine - // fork of the blockifier ensures we're not limited by the min function applied - // by starkware. - // https://github.com/starkware-libs/blockifier/blob/4fd71645b45fd1deb6b8e44802414774ec2a2ec1/crates/blockifier/src/execution/entry_point.rs#L159 - // https://github.com/dojoengine/blockifier/blob/5f58be8961ddf84022dd739a8ab254e32c435075/crates/blockifier/src/execution/entry_point.rs#L188 - + // The run resources for a call execution will either be constraint ONLY by the block context + // limits OR based on the tx fee and gas prices. As can be seen here, the upper bound will + // always be limited the block max invoke steps https://github.com/dojoengine/blockifier/blob/5f58be8961ddf84022dd739a8ab254e32c435075/crates/blockifier/src/execution/entry_point.rs#L253 + // even if the it's max steps is derived from the tx fees. + // + // This if statement here determines how execution will be constraint to . + // This basically means, we can not set an arbitrary gas limit for this call without modifying + // the block context. So, we just set the run resources here manually to bypass that. + + // The values for these parameters are essentially useless as we manually set the run resources + // later anyway. let limit_steps_by_resources = true; - let tx_info = DeprecatedTransactionInfo { max_fee: Fee(1), ..Default::default() }; + let tx_info = DeprecatedTransactionInfo::default(); let mut ctx = EntryPointExecutionContext::new_invoke( Arc::new(TransactionContext { From 886ac5ccd0b7f5cb2aa16f648a6565eff0fd3db1 Mon Sep 17 00:00:00 2001 From: Ammar Arif Date: Thu, 13 Feb 2025 14:48:16 -0500 Subject: [PATCH 3/3] clippy --- crates/katana/executor/src/implementation/blockifier/call.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/katana/executor/src/implementation/blockifier/call.rs b/crates/katana/executor/src/implementation/blockifier/call.rs index 018401c0be..480b66caac 100644 --- a/crates/katana/executor/src/implementation/blockifier/call.rs +++ b/crates/katana/executor/src/implementation/blockifier/call.rs @@ -10,7 +10,7 @@ use blockifier::state::state_api::StateReader; use blockifier::transaction::objects::{DeprecatedTransactionInfo, TransactionInfo}; use katana_cairo::cairo_vm::vm::runners::cairo_runner::{ExecutionResources, RunResources}; use katana_cairo::starknet_api::core::EntryPointSelector; -use katana_cairo::starknet_api::transaction::{Calldata, Fee}; +use katana_cairo::starknet_api::transaction::Calldata; use katana_primitives::Felt; use super::utils::to_blk_address;