diff --git a/Cargo.lock b/Cargo.lock index c0befcb573..b76079c458 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1203,6 +1203,17 @@ dependencies = [ "tinyvec", ] +[[package]] +name = "bstr" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" +dependencies = [ + "lazy_static", + "memchr", + "regex-automata 0.1.10", +] + [[package]] name = "bstr" version = "1.9.0" @@ -4485,7 +4496,7 @@ version = "0.30.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0a7bb9fad6125c81372987c06469601d37e1a2d421511adb69971b9083517a8a" dependencies = [ - "bstr", + "bstr 1.9.0", "btoi", "gix-date", "itoa", @@ -4499,7 +4510,7 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b4d28c5375dd1a8a433ce0bb6d2a462182d853861d625cb43f0a821365ac020" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-date", "gix-object", "gix-worktree-stream", @@ -4512,7 +4523,7 @@ version = "0.22.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "214ee3792e504ee1ce206b36dcafa4f328ca313d1e2ac0b41433d68ef4e14260" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-glob", "gix-path", "gix-quote", @@ -4547,7 +4558,7 @@ version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c82b5e9494e61983e61049bbd15fe0fa6b70672dd236362bdb5b2b50fc428f10" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-path", "gix-trace", "shell-words", @@ -4559,7 +4570,7 @@ version = "0.24.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "82dbd7fb959862e3df2583331f0ad032ac93533e8a52f1b0694bc517f5d292bc" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-chunk", "gix-features", "gix-hash", @@ -4573,7 +4584,7 @@ version = "0.34.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e62bf2073b6ce3921ffa6d8326f645f30eec5fc4a8e8a4bc0fcb721a2f3f69dc" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-config-value", "gix-features", "gix-glob", @@ -4595,7 +4606,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5b8a1e7bfb37a46ed0b8468db37a6d8a0a61d56bdbe4603ae492cb322e5f3958" dependencies = [ "bitflags 2.4.2", - "bstr", + "bstr 1.9.0", "gix-path", "libc", "thiserror", @@ -4607,7 +4618,7 @@ version = "0.24.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "206ede3fe433abba3c8b0174179d5bbac65ae3f0d9187e2ea96c0494db6a139f" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-command", "gix-config-value", "gix-path", @@ -4624,7 +4635,7 @@ version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fb7f3dfb72bebe3449b5e642be64e3c6ccbe9821c8b8f19f487cf5bfbbf4067e" dependencies = [ - "bstr", + "bstr 1.9.0", "itoa", "thiserror", "time", @@ -4636,7 +4647,7 @@ version = "0.40.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cbdcb5e49c4b9729dd1c361040ae5c3cd7c497b2260b18c954f62db3a63e98cf" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-command", "gix-filter", "gix-fs", @@ -4656,7 +4667,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4669218f3ec0cbbf8f16857b32200890f8ca585f36f5817242e4115fe4551af" dependencies = [ - "bstr", + "bstr 1.9.0", "dunce", "gix-fs", "gix-hash", @@ -4696,7 +4707,7 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9240862840fb740d209422937195e129e4ed3da49af212383260134bea8f6c1a" dependencies = [ - "bstr", + "bstr 1.9.0", "encoding_rs", "gix-attributes", "gix-command", @@ -4728,7 +4739,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4965a1d06d0ab84a29d4a67697a97352ab14ae1da821084e5afb1fd6d8191ca0" dependencies = [ "bitflags 2.4.2", - "bstr", + "bstr 1.9.0", "gix-features", "gix-path", ] @@ -4760,7 +4771,7 @@ version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1f7069aaca4a05784c4cb44e392f0eaf627c6e57e05d3100c0e2386a37a682f0" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-glob", "gix-path", "gix-trace", @@ -4774,7 +4785,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1d7152181ba8f0a3addc5075dd612cea31fc3e252b29c8be8c45f4892bf87426" dependencies = [ "bitflags 2.4.2", - "bstr", + "bstr 1.9.0", "btoi", "filetime", "gix-bitmap", @@ -4820,7 +4831,7 @@ version = "0.22.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c8755c637aeeee7205fb605b4cfe5f8ff0ff48ad3d19b3ac98de7d0422538575" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-actor", "gix-date", "thiserror", @@ -4848,7 +4859,7 @@ version = "0.41.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "693ce9d30741506cb082ef2d8b797415b48e032cce0ab23eff894c19a7e4777b" dependencies = [ - "bstr", + "bstr 1.9.0", "btoi", "gix-actor", "gix-date", @@ -4908,7 +4919,7 @@ version = "0.17.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ca8ef6dd3ea50e26f3bf572e90c034d033c804d340cd1eb386392f184a9ba2f7" dependencies = [ - "bstr", + "bstr 1.9.0", "faster-hex", "gix-trace", "thiserror", @@ -4920,7 +4931,7 @@ version = "0.10.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97e9ad649bf5e109562d6acba657ca428661ec08e77eaf3a755d8fa55485be9c" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-trace", "home", "once_cell", @@ -4934,7 +4945,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9cbd49750edb26b0a691e5246fc635fa554d344da825cd20fa9ee0da9c1b761f" dependencies = [ "bitflags 2.4.2", - "bstr", + "bstr 1.9.0", "gix-attributes", "gix-config-value", "gix-glob", @@ -4961,7 +4972,7 @@ version = "0.4.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9f7dc10303d73a960d10fb82f81188b036ac3e6b11b5795b20b1a60b51d1321f" dependencies = [ - "bstr", + "bstr 1.9.0", "btoi", "thiserror", ] @@ -4994,7 +5005,7 @@ version = "0.22.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "613aa4d93034c5791d13bdc635e530f4ddab1412ddfb4a8215f76213177b61c7" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-hash", "gix-revision", "gix-validate", @@ -5008,7 +5019,7 @@ version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "288f6549d7666db74dc3f169a9a333694fc28ecd2f5aa7b2c979c89eb556751a" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-date", "gix-hash", "gix-hashtable", @@ -5051,7 +5062,7 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "324d6b9ad77d9e1b73611ce274f4fc1145bf29bc893e18c9e378981d0dc4ae80" dependencies = [ - "bstr", + "bstr 1.9.0", "filetime", "gix-features", "gix-filter", @@ -5070,7 +5081,7 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "73182f6c1f5ed1ed94ba16581ac62593d5e29cd1c028b2af618f836283b8f8d4" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-config", "gix-path", "gix-pathspec", @@ -5123,7 +5134,7 @@ version = "0.27.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "26f1981ecc700f4fd73ae62b9ca2da7c8816c8fd267f0185e3f8c21e967984ac" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-features", "gix-path", "home", @@ -5147,7 +5158,7 @@ version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ac7cc36f496bd5d96cdca0f9289bb684480725d40db60f48194aa7723b883854" dependencies = [ - "bstr", + "bstr 1.9.0", "thiserror", ] @@ -5157,7 +5168,7 @@ version = "0.30.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ca36bb3dc54038c66507dc75c4d8edbee2d6d5cc45227b4eb508ad13dd60a006" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-attributes", "gix-features", "gix-fs", @@ -5175,7 +5186,7 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ae178614b70bdb0c7f6f21b8c9fb711ab78bd7e8e1866f565fcf28876747f1d" dependencies = [ - "bstr", + "bstr 1.9.0", "gix-features", "gix-filter", "gix-fs", @@ -5220,7 +5231,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57da3b9b5b85bd66f31093f8c408b90a74431672542466497dcbdfdc02034be1" dependencies = [ "aho-corasick", - "bstr", + "bstr 1.9.0", "log", "regex-automata 0.4.5", "regex-syntax 0.8.2", @@ -6615,10 +6626,14 @@ version = "0.6.0-alpha.0" dependencies = [ "anyhow", "blockifier", + "cairo-vm", "convert_case 0.6.0", "katana-primitives", "katana-provider", "parking_lot 0.12.1", + "rstest", + "serde_json", + "similar-asserts", "starknet", "starknet_api", "thiserror", @@ -10820,6 +10835,20 @@ name = "similar" version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32fea41aca09ee824cc9724996433064c89f7777e60762749a4170a14abbfa21" +dependencies = [ + "bstr 0.2.17", + "unicode-segmentation", +] + +[[package]] +name = "similar-asserts" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e041bb827d1bfca18f213411d51b665309f1afb37a04a5d1464530e13779fc0f" +dependencies = [ + "console", + "similar", +] [[package]] name = "simple_asn1" diff --git a/Cargo.toml b/Cargo.toml index f48170bb6b..f1043d8d4b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -148,6 +148,7 @@ semver = "1.0.5" serde = { version = "1.0.192", features = [ "derive" ] } serde_json = { version = "1.0", features = [ "arbitrary_precision" ] } serde_with = "2.3.1" +similar-asserts = "1.5.0" smol_str = { version = "0.2.0", features = [ "serde" ] } sqlx = { version = "0.7.2", features = [ "chrono", "macros", "regexp", "runtime-async-std", "runtime-tokio", "sqlite", "uuid" ] } starknet = "0.8.0" @@ -163,6 +164,9 @@ tracing = "0.1.34" tracing-subscriber = { version = "0.3.16", features = [ "env-filter", "json" ] } url = { version = "2.4.0", features = [ "serde" ] } +rstest = "0.18.2" +rstest_reuse = "0.6.0" + # server hyper = "0.14.27" warp = "0.3" diff --git a/crates/katana/core/src/backend/mod.rs b/crates/katana/core/src/backend/mod.rs index 5fe61c09d1..8d65dc8b97 100644 --- a/crates/katana/core/src/backend/mod.rs +++ b/crates/katana/core/src/backend/mod.rs @@ -146,6 +146,7 @@ impl Backend { let prev_hash = BlockHashProvider::latest_hash(self.blockchain.provider())?; let partial_header = PartialHeader { + number: block_env.number, parent_hash: prev_hash, version: CURRENT_STARKNET_VERSION, timestamp: block_env.timestamp, diff --git a/crates/katana/executor/Cargo.toml b/crates/katana/executor/Cargo.toml index 9fb9e748b5..18c13a00f0 100644 --- a/crates/katana/executor/Cargo.toml +++ b/crates/katana/executor/Cargo.toml @@ -21,3 +21,10 @@ tracing.workspace = true blockifier.workspace = true starknet_api.workspace = true tokio.workspace = true + +[dev-dependencies] +cairo-vm.workspace = true +katana-provider.workspace = true +rstest.workspace = true +serde_json.workspace = true +similar-asserts.workspace = true diff --git a/crates/katana/executor/src/abstraction.rs b/crates/katana/executor/src/abstraction.rs index 03e5e60a2c..d8eff5d75d 100644 --- a/crates/katana/executor/src/abstraction.rs +++ b/crates/katana/executor/src/abstraction.rs @@ -34,6 +34,9 @@ pub enum ExecutorError { #[error(transparent)] Other(Box), + + #[error(transparent)] + BlockifierError(#[from] crate::implementation::blockifier::Error), } pub type ExecutorResult = Result; diff --git a/crates/katana/executor/src/implementation/blockifier/mod.rs b/crates/katana/executor/src/implementation/blockifier/mod.rs new file mode 100644 index 0000000000..1436271170 --- /dev/null +++ b/crates/katana/executor/src/implementation/blockifier/mod.rs @@ -0,0 +1,190 @@ +mod output; +mod state; +mod utils; + +use blockifier::block_context::BlockContext; +use blockifier::state::cached_state::{self, MutRefState}; +use katana_primitives::block::{ExecutableBlock, GasPrices, PartialHeader}; +use katana_primitives::env::{BlockEnv, CfgEnv}; +use katana_primitives::receipt::Receipt; +use katana_primitives::transaction::{ExecutableTx, ExecutableTxWithHash, TxWithHash}; +use katana_primitives::FieldElement; +use katana_provider::traits::state::StateProvider; +use starknet_api::block::{BlockNumber, BlockTimestamp}; + +use self::state::CachedState; +pub use self::utils::Error; +use crate::{ + abstraction, BlockExecutor, EntryPointCall, ExecutionOutput, ExecutorResult, SimulationFlag, + StateProviderDb, TransactionExecutionOutput, TransactionExecutor, +}; + +#[derive(Debug)] +pub struct BlockifierFactory { + cfg: CfgEnv, + flags: SimulationFlag, +} + +impl BlockifierFactory { + /// Create a new factory with the given configuration and simulation flags. + pub fn new(cfg: CfgEnv, flags: SimulationFlag) -> Self { + Self { cfg, flags } + } +} + +impl abstraction::ExecutorFactory for BlockifierFactory { + fn with_state<'a, P>(&self, state: P) -> Box + 'a> + where + P: StateProvider + 'a, + { + self.with_state_and_block_env(state, BlockEnv::default()) + } + + fn with_state_and_block_env<'a, P>( + &self, + state: P, + block_env: BlockEnv, + ) -> Box + 'a> + where + P: StateProvider + 'a, + { + let cfg_env = self.cfg.clone(); + let flags = self.flags.clone(); + Box::new(StarknetVMProcessor::new(Box::new(state), block_env, cfg_env, flags)) + } + + fn cfg(&self) -> &CfgEnv { + &self.cfg + } +} + +pub struct StarknetVMProcessor<'a> { + block_context: BlockContext, + state: CachedState>, + transactions: Vec<(TxWithHash, Option)>, + simulation_flags: SimulationFlag, +} + +impl<'a> StarknetVMProcessor<'a> { + pub fn new( + state: Box, + block_env: BlockEnv, + cfg_env: CfgEnv, + simulation_flags: SimulationFlag, + ) -> Self { + let transactions = Vec::new(); + let block_context = utils::block_context_from_envs(&block_env, &cfg_env); + let state = state::CachedState::new(StateProviderDb(state)); + Self { block_context, state, transactions, simulation_flags } + } + + fn fill_block_env_from_header(&mut self, header: &PartialHeader) { + // TODO: include block number in partial header + let number = BlockNumber(header.number); + let timestamp = BlockTimestamp(header.timestamp); + let eth_l1_gas_price = header.gas_prices.eth as u128; + let strk_l1_gas_price = header.gas_prices.strk as u128; + + self.block_context.block_info.block_number = number; + self.block_context.block_info.block_timestamp = timestamp; + self.block_context.block_info.gas_prices.eth_l1_gas_price = eth_l1_gas_price; + self.block_context.block_info.gas_prices.strk_l1_gas_price = strk_l1_gas_price; + self.block_context.block_info.sequencer_address = header.sequencer_address.into(); + } +} + +impl<'a> abstraction::TransactionExecutor for StarknetVMProcessor<'a> { + fn execute( + &mut self, + tx: ExecutableTxWithHash, + ) -> ExecutorResult> { + let state = &self.state; + let block_context = &self.block_context; + let flags = &self.simulation_flags; + + let class_declaration_artifacts = if let ExecutableTx::Declare(tx) = tx.as_ref() { + let class_hash = tx.class_hash(); + Some((class_hash, tx.compiled_class.clone(), tx.sierra_class.clone())) + } else { + None + }; + + let tx_ = TxWithHash::from(&tx); + let res = utils::transact(tx, &mut state.0.write().inner, block_context, flags)?; + + let receipt = res.receipt(tx_.as_ref()); + self.transactions.push((tx_, Some(receipt))); + + if let Some((class_hash, compiled_class, sierra_class)) = class_declaration_artifacts { + state.0.write().declared_classes.insert(class_hash, (compiled_class, sierra_class)); + } + + Ok(Box::new(res)) + } + + fn simulate( + &self, + tx: ExecutableTxWithHash, + flags: SimulationFlag, + ) -> ExecutorResult> { + let block_context = &self.block_context; + + let state = &mut self.state.0.write().inner; + let mut state = cached_state::CachedState::new(MutRefState::new(state), Default::default()); + + let res = utils::transact(tx, &mut state, block_context, &flags)?; + Ok(Box::new(res)) + } + + fn call(&self, call: EntryPointCall, initial_gas: u128) -> ExecutorResult> { + let block_context = &self.block_context; + + let state = &mut self.state.0.write().inner; + let mut state = cached_state::CachedState::new(MutRefState::new(state), Default::default()); + + let res = utils::call(call, &mut state, block_context, initial_gas)?; + + let retdata = res.execution.retdata.0; + let retdata = retdata.into_iter().map(|f| f.into()).collect::>(); + + Ok(retdata) + } +} + +impl<'a> abstraction::BlockExecutor<'a> for StarknetVMProcessor<'a> { + fn execute_block(&mut self, block: ExecutableBlock) -> ExecutorResult<()> { + self.fill_block_env_from_header(&block.header); + + for tx in block.body { + let _ = self.execute(tx)?; + } + + Ok(()) + } + + fn take_execution_output(&mut self) -> ExecutorResult { + let states = utils::state_update_from_cached_state(&self.state); + let transactions = std::mem::take(&mut self.transactions); + Ok(ExecutionOutput { states, transactions }) + } + + fn state(&self) -> Box { + Box::new(self.state.clone()) + } + + fn transactions(&self) -> &[(TxWithHash, Option)] { + &self.transactions + } + + fn block_env(&self) -> BlockEnv { + BlockEnv { + number: self.block_context.block_info.block_number.0, + timestamp: self.block_context.block_info.block_timestamp.0, + sequencer_address: self.block_context.block_info.sequencer_address.into(), + l1_gas_prices: GasPrices { + eth: self.block_context.block_info.gas_prices.eth_l1_gas_price as u64, + strk: self.block_context.block_info.gas_prices.strk_l1_gas_price as u64, + }, + } + } +} diff --git a/crates/katana/executor/src/implementation/blockifier/output.rs b/crates/katana/executor/src/implementation/blockifier/output.rs new file mode 100644 index 0000000000..f4383eb531 --- /dev/null +++ b/crates/katana/executor/src/implementation/blockifier/output.rs @@ -0,0 +1,169 @@ +use std::collections::HashMap; + +use blockifier::execution::call_info::CallInfo; +use blockifier::transaction::objects; +use katana_primitives::contract::ContractAddress; +use katana_primitives::receipt::{ + DeclareTxReceipt, DeployAccountTxReceipt, Event, InvokeTxReceipt, L1HandlerTxReceipt, + MessageToL1, Receipt, TxExecutionResources, +}; +use katana_primitives::transaction::Tx; +use katana_primitives::FieldElement; + +use crate::TransactionExecutionOutput; + +#[derive(Debug, Default)] +pub struct TransactionExecutionInfo { + pub gas_used: u128, + pub(super) inner: objects::TransactionExecutionInfo, +} + +impl TransactionExecutionOutput for TransactionExecutionInfo { + fn receipt(&self, tx: &Tx) -> Receipt { + let actual_fee = self.inner.actual_fee.0; + let events = events_from_exec_info(self); + let revert_error = self.inner.revert_error.clone(); + let messages_sent = l2_to_l1_messages_from_exec_info(self); + let actual_resources = parse_actual_resources(&self.inner.actual_resources.0); + + match tx { + Tx::Invoke(_) => Receipt::Invoke(InvokeTxReceipt { + events, + actual_fee, + revert_error, + messages_sent, + execution_resources: actual_resources, + }), + + Tx::Declare(_) => Receipt::Declare(DeclareTxReceipt { + events, + actual_fee, + revert_error, + messages_sent, + execution_resources: actual_resources, + }), + + Tx::L1Handler(tx) => Receipt::L1Handler(L1HandlerTxReceipt { + events, + actual_fee, + revert_error, + messages_sent, + message_hash: tx.message_hash, + execution_resources: actual_resources, + }), + + Tx::DeployAccount(tx) => Receipt::DeployAccount(DeployAccountTxReceipt { + events, + actual_fee, + revert_error, + messages_sent, + execution_resources: actual_resources, + contract_address: tx.contract_address, + }), + } + } + + fn actual_fee(&self) -> u128 { + self.inner.actual_fee.0 + } + + fn gas_used(&self) -> u128 { + self.gas_used + } + + fn revert_error(&self) -> Option<&str> { + self.inner.revert_error.as_deref() + } +} + +fn events_from_exec_info(info: &TransactionExecutionInfo) -> Vec { + let mut events: Vec = vec![]; + + fn get_events_recursively(call_info: &CallInfo) -> Vec { + let mut events: Vec = vec![]; + + events.extend(call_info.execution.events.iter().map(|e| Event { + from_address: call_info.call.storage_address.into(), + data: e.event.data.0.iter().map(|d| (*d).into()).collect(), + keys: e.event.keys.iter().map(|k| k.0.into()).collect(), + })); + + call_info.inner_calls.iter().for_each(|call| { + events.extend(get_events_recursively(call)); + }); + + events + } + + if let Some(ref call) = info.inner.validate_call_info { + events.extend(get_events_recursively(call)); + } + + if let Some(ref call) = info.inner.execute_call_info { + events.extend(get_events_recursively(call)); + } + + if let Some(ref call) = info.inner.fee_transfer_call_info { + events.extend(get_events_recursively(call)); + } + + events +} + +fn l2_to_l1_messages_from_exec_info(info: &TransactionExecutionInfo) -> Vec { + let mut messages = vec![]; + + fn get_messages_recursively(info: &CallInfo) -> Vec { + let mut messages = vec![]; + + // By default, `from_address` must correspond to the contract address that + // is sending the message. In the case of library calls, `code_address` is `None`, + // we then use the `caller_address` instead (which can also be an account). + let from_address = if let Some(code_address) = info.call.code_address { + *code_address.0.key() + } else { + *info.call.caller_address.0.key() + }; + + messages.extend(info.execution.l2_to_l1_messages.iter().map(|m| MessageToL1 { + to_address: + FieldElement::from_byte_slice_be(m.message.to_address.0.as_bytes()).unwrap(), + from_address: ContractAddress(from_address.into()), + payload: m.message.payload.0.iter().map(|p| (*p).into()).collect(), + })); + + info.inner_calls.iter().for_each(|call| { + messages.extend(get_messages_recursively(call)); + }); + + messages + } + + if let Some(ref info) = info.inner.validate_call_info { + messages.extend(get_messages_recursively(info)); + } + + if let Some(ref info) = info.inner.execute_call_info { + messages.extend(get_messages_recursively(info)); + } + + if let Some(ref info) = info.inner.fee_transfer_call_info { + messages.extend(get_messages_recursively(info)); + } + + messages +} + +fn parse_actual_resources(resources: &HashMap) -> TxExecutionResources { + TxExecutionResources { + steps: resources.get("n_steps").copied().unwrap_or_default() as u64, + memory_holes: resources.get("memory_holes").map(|x| *x as u64), + ec_op_builtin: resources.get("ec_op_builtin").map(|x| *x as u64), + ecdsa_builtin: resources.get("ecdsa_builtin").map(|x| *x as u64), + keccak_builtin: resources.get("keccak_builtin").map(|x| *x as u64), + bitwise_builtin: resources.get("bitwise_builtin").map(|x| *x as u64), + pedersen_builtin: resources.get("pedersen_builtin").map(|x| *x as u64), + poseidon_builtin: resources.get("poseidon_builtin").map(|x| *x as u64), + range_check_builtin: resources.get("range_check_builtin").map(|x| *x as u64), + } +} diff --git a/crates/katana/executor/src/implementation/blockifier/state.rs b/crates/katana/executor/src/implementation/blockifier/state.rs new file mode 100644 index 0000000000..bad164e6af --- /dev/null +++ b/crates/katana/executor/src/implementation/blockifier/state.rs @@ -0,0 +1,232 @@ +use std::collections::HashMap; +use std::sync::Arc; + +use blockifier::state::cached_state::{self, GlobalContractCache}; +use blockifier::state::errors::StateError; +use blockifier::state::state_api::{StateReader, StateResult}; +use katana_primitives::class::{CompiledClass, FlattenedSierraClass}; +use katana_primitives::{conversion, FieldElement}; +use katana_provider::traits::contract::ContractClassProvider; +use katana_provider::traits::state::StateProvider; +use katana_provider::ProviderResult; +use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard}; +use starknet_api::core::{ClassHash, CompiledClassHash, Nonce, PatriciaKey}; +use starknet_api::hash::StarkHash; +use starknet_api::patricia_key; +use starknet_api::state::StorageKey; + +use crate::StateProviderDb; + +/// A helper trait to enforce that a type must implement both [StateProvider] and [StateReader]. +pub(super) trait StateDb: StateProvider + StateReader {} + +impl StateDb for T where T: StateProvider + StateReader {} + +impl<'a> StateReader for StateProviderDb<'a> { + fn get_class_hash_at( + &mut self, + contract_address: starknet_api::core::ContractAddress, + ) -> StateResult { + self.0 + .class_hash_of_contract(contract_address.into()) + .map(|v| ClassHash(v.unwrap_or_default().into())) + .map_err(|e| StateError::StateReadError(e.to_string())) + } + + fn get_compiled_class_hash( + &mut self, + class_hash: starknet_api::core::ClassHash, + ) -> StateResult { + if let Some(hash) = self + .0 + .compiled_class_hash_of_class_hash(class_hash.0.into()) + .map_err(|e| StateError::StateReadError(e.to_string()))? + { + Ok(CompiledClassHash(hash.into())) + } else { + Err(StateError::UndeclaredClassHash(class_hash)) + } + } + + fn get_compiled_contract_class( + &mut self, + class_hash: ClassHash, + ) -> StateResult { + if let Some(class) = self + .0 + .class(class_hash.0.into()) + .map_err(|e| StateError::StateReadError(e.to_string()))? + { + let class = conversion::blockifier::to_class(class) + .map_err(|e| StateError::StateReadError(e.to_string()))?; + + Ok(class) + } else { + Err(StateError::UndeclaredClassHash(class_hash)) + } + } + + fn get_nonce_at( + &mut self, + contract_address: starknet_api::core::ContractAddress, + ) -> StateResult { + self.0 + .nonce(contract_address.into()) + .map(|n| Nonce(n.unwrap_or_default().into())) + .map_err(|e| StateError::StateReadError(e.to_string())) + } + + fn get_storage_at( + &mut self, + contract_address: starknet_api::core::ContractAddress, + key: starknet_api::state::StorageKey, + ) -> StateResult { + self.0 + .storage(contract_address.into(), (*key.0.key()).into()) + .map(|v| v.unwrap_or_default().into()) + .map_err(|e| StateError::StateReadError(e.to_string())) + } +} + +pub(super) struct CachedState(pub(super) Arc>>); + +impl Clone for CachedState { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } +} + +type DeclaredClass = (CompiledClass, Option); + +#[derive(Debug)] +pub(super) struct CachedStateInner { + pub(super) inner: cached_state::CachedState, + pub(super) declared_classes: HashMap, +} + +impl CachedState { + pub(super) fn new(state: S) -> Self { + let declared_classes = HashMap::new(); + let cached_state = cached_state::CachedState::new(state, GlobalContractCache::default()); + let inner = CachedStateInner { inner: cached_state, declared_classes }; + Self(Arc::new(RwLock::new(inner))) + } + + fn read(&self) -> RwLockReadGuard<'_, CachedStateInner> { + self.0.read() + } + + fn write(&self) -> RwLockWriteGuard<'_, CachedStateInner> { + self.0.write() + } +} + +impl ContractClassProvider for CachedState { + fn class( + &self, + hash: katana_primitives::class::ClassHash, + ) -> ProviderResult> { + let state = self.read(); + if let Some((class, _)) = state.declared_classes.get(&hash) { + Ok(Some(class.clone())) + } else { + state.inner.state.class(hash) + } + } + + fn compiled_class_hash_of_class_hash( + &self, + hash: katana_primitives::class::ClassHash, + ) -> ProviderResult> { + let Ok(hash) = self.write().inner.get_compiled_class_hash(ClassHash(hash.into())) else { + return Ok(None); + }; + Ok(Some(hash.0.into())) + } + + fn sierra_class( + &self, + hash: katana_primitives::class::ClassHash, + ) -> ProviderResult> { + let state = self.read(); + if let Some((_, sierra)) = state.declared_classes.get(&hash) { + Ok(sierra.clone()) + } else { + state.inner.state.sierra_class(hash) + } + } +} + +impl StateProvider for CachedState { + fn class_hash_of_contract( + &self, + address: katana_primitives::contract::ContractAddress, + ) -> ProviderResult> { + let Ok(hash) = self.write().inner.get_class_hash_at(address.into()) else { + return Ok(None); + }; + + let hash = hash.0.into(); + if hash == FieldElement::ZERO { Ok(None) } else { Ok(Some(hash)) } + } + + fn nonce( + &self, + address: katana_primitives::contract::ContractAddress, + ) -> ProviderResult> { + let Ok(nonce) = self.write().inner.get_nonce_at(address.into()) else { + return Ok(None); + }; + Ok(Some(nonce.0.into())) + } + + fn storage( + &self, + address: katana_primitives::contract::ContractAddress, + storage_key: katana_primitives::contract::StorageKey, + ) -> ProviderResult> { + let address = address.into(); + let key = StorageKey(patricia_key!(storage_key)); + + if let Ok(value) = self.write().inner.get_storage_at(address, key) { + Ok(Some(value.into())) + } else { + Ok(None) + } + } +} + +impl StateReader for CachedState { + fn get_class_hash_at( + &mut self, + contract_address: starknet_api::core::ContractAddress, + ) -> StateResult { + self.write().inner.get_class_hash_at(contract_address) + } + + fn get_compiled_class_hash(&mut self, class_hash: ClassHash) -> StateResult { + self.write().inner.get_compiled_class_hash(class_hash) + } + + fn get_compiled_contract_class( + &mut self, + class_hash: ClassHash, + ) -> StateResult { + self.write().inner.get_compiled_contract_class(class_hash) + } + + fn get_nonce_at( + &mut self, + contract_address: starknet_api::core::ContractAddress, + ) -> StateResult { + self.write().inner.get_nonce_at(contract_address) + } + + fn get_storage_at( + &mut self, + contract_address: starknet_api::core::ContractAddress, + key: StorageKey, + ) -> StateResult { + self.write().inner.get_storage_at(contract_address, key) + } +} diff --git a/crates/katana/executor/src/implementation/blockifier/utils.rs b/crates/katana/executor/src/implementation/blockifier/utils.rs new file mode 100644 index 0000000000..43abd54e19 --- /dev/null +++ b/crates/katana/executor/src/implementation/blockifier/utils.rs @@ -0,0 +1,323 @@ +use std::collections::HashMap; +use std::sync::Arc; + +use blockifier::block_context::{BlockContext, BlockInfo, ChainInfo, FeeTokenAddresses, GasPrices}; +use blockifier::execution::call_info::CallInfo; +use blockifier::execution::common_hints::ExecutionMode; +use blockifier::execution::entry_point::{ + CallEntryPoint, EntryPointExecutionContext, ExecutionResources, +}; +use blockifier::execution::errors::EntryPointExecutionError; +use blockifier::fee::fee_utils::calculate_tx_l1_gas_usages; +use blockifier::state::cached_state::{self}; +use blockifier::state::state_api::{State, StateReader}; +use blockifier::transaction::account_transaction::AccountTransaction; +use blockifier::transaction::errors::{TransactionExecutionError, TransactionFeeError}; +use blockifier::transaction::objects::{ + AccountTransactionContext, DeprecatedAccountTransactionContext, +}; +use blockifier::transaction::transaction_execution::Transaction; +use blockifier::transaction::transactions::{ + DeclareTransaction, DeployAccountTransaction, ExecutableTransaction, InvokeTransaction, + L1HandlerTransaction, +}; +use katana_primitives::class::{ClassHash, CompiledClass, FlattenedSierraClass}; +use katana_primitives::conversion::blockifier::to_class; +use katana_primitives::env::{BlockEnv, CfgEnv}; +use katana_primitives::state::{StateUpdates, StateUpdatesWithDeclaredClasses}; +use katana_primitives::transaction::{DeclareTx, ExecutableTx, ExecutableTxWithHash}; +use katana_provider::traits::contract::ContractClassProvider; +use starknet_api::block::{BlockNumber, BlockTimestamp}; +use starknet_api::core; +use starknet_api::transaction::{ + Calldata, ContractAddressSalt, DeclareTransaction as ApiDeclareTransaction, + DeclareTransactionV0V1, DeclareTransactionV2, + DeployAccountTransaction as ApiDeployAccountTransaction, DeployAccountTransactionV1, Fee, + InvokeTransaction as ApiInvokeTransaction, TransactionHash, TransactionSignature, + TransactionVersion, +}; + +use super::output::TransactionExecutionInfo; +use super::state::{CachedState, StateDb}; +use crate::abstraction::{EntryPointCall, SimulationFlag}; + +#[derive(Debug, thiserror::Error)] +pub enum Error { + #[error("failed to execute call: {0}")] + CallError(#[from] EntryPointExecutionError), + + #[error("fee error: {0}")] + TransactionFee(#[from] TransactionFeeError), + + #[error("failed to execute transaction: {0}")] + TransactionExecution(#[from] TransactionExecutionError), +} + +pub(super) fn transact( + tx: ExecutableTxWithHash, + state: &mut cached_state::CachedState, + block_context: &BlockContext, + simulation_flags: &SimulationFlag, +) -> Result { + let validate = !simulation_flags.skip_validate; + let charge_fee = !simulation_flags.skip_fee_transfer; + + let res = match to_executor_tx(tx) { + Transaction::AccountTransaction(tx) => { + tx.execute(state, block_context, charge_fee, validate) + } + Transaction::L1HandlerTransaction(tx) => { + tx.execute(state, block_context, charge_fee, validate) + } + }?; + + let gas_used = calculate_tx_l1_gas_usages(&res.actual_resources, block_context)?.gas_usage; + Ok(TransactionExecutionInfo { inner: res, gas_used }) +} + +/// Perform a function call on a contract and retrieve the return values. +pub(super) fn call( + request: EntryPointCall, + state: &mut cached_state::CachedState, + block_context: &BlockContext, + initial_gas: u128, +) -> Result { + // let inner = &mut state.0.write().inner; + // let inner = MutRefState::new(inner); + + // let mut state = cached_state::CachedState::new(inner, GlobalContractCache::default()); + + let call = CallEntryPoint { + initial_gas: initial_gas as u64, + storage_address: request.contract_address.into(), + entry_point_selector: core::EntryPointSelector(request.entry_point_selector.into()), + calldata: Calldata(Arc::new(request.calldata.into_iter().map(|f| f.into()).collect())), + ..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 teh block context itself instead of the input give. + // https://github.com/starkware-libs/blockifier/blob/51b343fe38139a309a69b2482f4b484e8caa5edf/crates/blockifier/src/execution/entry_point.rs#L165 + // The blockifier patch must be adjusted to modify this function to return + // the limit we have into the block context without min applied: + // https://github.com/starkware-libs/blockifier/blob/51b343fe38139a309a69b2482f4b484e8caa5edf/crates/blockifier/src/execution/entry_point.rs#L215 + let res = call.execute( + state, + &mut ExecutionResources::default(), + &mut EntryPointExecutionContext::new( + block_context, + // TODO: the current does not have Default, let's use the old one for now. + &AccountTransactionContext::Deprecated(DeprecatedAccountTransactionContext::default()), + ExecutionMode::Execute, + limit_steps_by_resources, + )?, + )?; + + Ok(res) +} + +fn to_executor_tx(tx: ExecutableTxWithHash) -> Transaction { + let hash = tx.hash; + + match tx.transaction { + ExecutableTx::Invoke(tx) => { + let calldata = tx.calldata.into_iter().map(|f| f.into()).collect(); + let signature = tx.signature.into_iter().map(|f| f.into()).collect(); + Transaction::AccountTransaction(AccountTransaction::Invoke(InvokeTransaction { + tx: ApiInvokeTransaction::V1(starknet_api::transaction::InvokeTransactionV1 { + max_fee: Fee(tx.max_fee), + nonce: core::Nonce(tx.nonce.into()), + sender_address: tx.sender_address.into(), + signature: TransactionSignature(signature), + calldata: Calldata(Arc::new(calldata)), + }), + tx_hash: TransactionHash(hash.into()), + only_query: false, + })) + } + + ExecutableTx::DeployAccount(tx) => { + let calldata = tx.constructor_calldata.into_iter().map(|f| f.into()).collect(); + let signature = tx.signature.into_iter().map(|f| f.into()).collect(); + Transaction::AccountTransaction(AccountTransaction::DeployAccount( + DeployAccountTransaction { + contract_address: tx.contract_address.into(), + tx: ApiDeployAccountTransaction::V1(DeployAccountTransactionV1 { + max_fee: Fee(tx.max_fee), + nonce: core::Nonce(tx.nonce.into()), + signature: TransactionSignature(signature), + class_hash: core::ClassHash(tx.class_hash.into()), + constructor_calldata: Calldata(Arc::new(calldata)), + contract_address_salt: ContractAddressSalt(tx.contract_address_salt.into()), + }), + tx_hash: TransactionHash(hash.into()), + only_query: false, + }, + )) + } + + ExecutableTx::Declare(tx) => { + let contract_class = tx.compiled_class; + + let tx = match tx.transaction { + DeclareTx::V1(tx) => { + let signature = tx.signature.into_iter().map(|f| f.into()).collect(); + ApiDeclareTransaction::V1(DeclareTransactionV0V1 { + max_fee: Fee(tx.max_fee), + nonce: core::Nonce(tx.nonce.into()), + sender_address: tx.sender_address.into(), + signature: TransactionSignature(signature), + class_hash: core::ClassHash(tx.class_hash.into()), + }) + } + + DeclareTx::V2(tx) => { + let signature = tx.signature.into_iter().map(|f| f.into()).collect(); + ApiDeclareTransaction::V2(DeclareTransactionV2 { + max_fee: Fee(tx.max_fee), + nonce: core::Nonce(tx.nonce.into()), + sender_address: tx.sender_address.into(), + signature: TransactionSignature(signature), + class_hash: core::ClassHash(tx.class_hash.into()), + compiled_class_hash: core::CompiledClassHash(tx.compiled_class_hash.into()), + }) + } + }; + + let tx = DeclareTransaction::new( + tx, + TransactionHash(hash.into()), + to_class(contract_class).unwrap(), + ) + .expect("class mismatch"); + Transaction::AccountTransaction(AccountTransaction::Declare(tx)) + } + + ExecutableTx::L1Handler(tx) => { + let calldata = tx.calldata.into_iter().map(|f| f.into()).collect(); + Transaction::L1HandlerTransaction(L1HandlerTransaction { + paid_fee_on_l1: Fee(tx.paid_fee_on_l1), + tx: starknet_api::transaction::L1HandlerTransaction { + nonce: core::Nonce(tx.nonce.into()), + calldata: Calldata(Arc::new(calldata)), + version: TransactionVersion(1u128.into()), + contract_address: tx.contract_address.into(), + entry_point_selector: core::EntryPointSelector(tx.entry_point_selector.into()), + }, + tx_hash: TransactionHash(hash.into()), + }) + } + } +} + +/// Create a block context from the chain environment values. +pub(super) fn block_context_from_envs(block_env: &BlockEnv, cfg_env: &CfgEnv) -> BlockContext { + let fee_token_addresses = FeeTokenAddresses { + eth_fee_token_address: cfg_env.fee_token_addresses.eth.into(), + strk_fee_token_address: cfg_env.fee_token_addresses.strk.into(), + }; + + let gas_prices = GasPrices { + eth_l1_gas_price: block_env.l1_gas_prices.eth.try_into().unwrap(), + strk_l1_gas_price: block_env.l1_gas_prices.strk.try_into().unwrap(), + eth_l1_data_gas_price: 0, + strk_l1_data_gas_price: 0, + }; + + BlockContext { + block_info: BlockInfo { + gas_prices, + use_kzg_da: false, + block_number: BlockNumber(block_env.number), + block_timestamp: BlockTimestamp(block_env.timestamp), + sequencer_address: block_env.sequencer_address.into(), + max_recursion_depth: cfg_env.max_recursion_depth, + validate_max_n_steps: cfg_env.validate_max_n_steps, + invoke_tx_max_n_steps: cfg_env.invoke_tx_max_n_steps, + vm_resource_fee_cost: cfg_env.vm_resource_fee_cost.clone().into(), + }, + chain_info: ChainInfo { fee_token_addresses, chain_id: cfg_env.chain_id.into() }, + } +} + +pub(super) fn state_update_from_cached_state( + state: &CachedState, +) -> StateUpdatesWithDeclaredClasses { + let state_diff = state.0.write().inner.to_state_diff(); + + let mut declared_compiled_classes: HashMap = HashMap::new(); + let mut declared_sierra_classes: HashMap = HashMap::new(); + + for (class_hash, _) in &state_diff.class_hash_to_compiled_class_hash { + let hash = class_hash.0.into(); + let class = state.class(hash).unwrap().expect("must exist if declared"); + + if let CompiledClass::Class(_) = class { + let sierra = state.sierra_class(hash).unwrap().expect("must exist if declared"); + declared_sierra_classes.insert(hash, sierra); + } + + declared_compiled_classes.insert(hash, class); + } + + let nonce_updates = + state_diff + .address_to_nonce + .into_iter() + .map(|(key, value)| (key.into(), value.0.into())) + .collect::>(); + + let storage_updates = state_diff + .storage_updates + .into_iter() + .map(|(addr, entries)| { + let entries = entries + .into_iter() + .map(|(k, v)| ((*k.0.key()).into(), v.into())) + .collect::>(); + + (addr.into(), entries) + }) + .collect::>(); + + let contract_updates = + state_diff + .address_to_class_hash + .into_iter() + .map(|(key, value)| (key.into(), value.0.into())) + .collect::>(); + + let declared_classes = + state_diff + .class_hash_to_compiled_class_hash + .into_iter() + .map(|(key, value)| (key.0.into(), value.0.into())) + .collect::>(); + + StateUpdatesWithDeclaredClasses { + declared_sierra_classes, + declared_compiled_classes, + state_updates: StateUpdates { + nonce_updates, + storage_updates, + contract_updates, + declared_classes, + }, + } +} diff --git a/crates/katana/executor/src/implementation/mod.rs b/crates/katana/executor/src/implementation/mod.rs new file mode 100644 index 0000000000..22486ef41d --- /dev/null +++ b/crates/katana/executor/src/implementation/mod.rs @@ -0,0 +1 @@ +pub mod blockifier; diff --git a/crates/katana/executor/src/lib.rs b/crates/katana/executor/src/lib.rs index 65cec94612..809f18c2a0 100644 --- a/crates/katana/executor/src/lib.rs +++ b/crates/katana/executor/src/lib.rs @@ -1,4 +1,6 @@ pub mod blockifier; +pub mod implementation; + mod abstraction; pub use abstraction::*; diff --git a/crates/katana/executor/tests/executor.rs b/crates/katana/executor/tests/executor.rs new file mode 100644 index 0000000000..a3f7c83397 --- /dev/null +++ b/crates/katana/executor/tests/executor.rs @@ -0,0 +1,185 @@ +mod fixtures; + +use std::collections::HashMap; + +use fixtures::blockifier::factory as blockifier_factory; +use fixtures::{state_provider, valid_blocks}; +use katana_executor::implementation::blockifier::BlockifierFactory; +use katana_executor::{ExecutionOutput, ExecutorFactory}; +use katana_primitives::block::ExecutableBlock; +use katana_primitives::contract::ContractAddress; +use katana_primitives::genesis::constant::{ + DEFAULT_LEGACY_ERC20_CONTRACT_CLASS_HASH, DEFAULT_OZ_ACCOUNT_CONTRACT_CLASS_HASH, +}; +use katana_primitives::transaction::TxWithHash; +use katana_provider::traits::state::StateProvider; +use starknet::core::utils::{get_udc_deployed_address, UdcUniqueSettings, UdcUniqueness}; +use starknet::macros::felt; + +#[rstest::rstest] +fn test_blockifier_executor_with_valid_blocks( + #[from(blockifier_factory)] factory: BlockifierFactory, + #[from(state_provider)] state: Box, + #[from(valid_blocks)] blocks: [ExecutableBlock; 3], +) { + test_executor_with_valid_blocks_impl(factory, state, blocks) +} + +fn test_executor_with_valid_blocks_impl( + factory: EF, + state: Box, + blocks: [ExecutableBlock; 3], +) { + let mut executor = factory.with_state(state); + let mut expected_txs: Vec = Vec::with_capacity(3); + + // execute the blocks and assert the block env is equivalent to the values in the block header + { + let block = &blocks[0]; + expected_txs.extend(block.body.iter().map(|t| t.into())); + + executor.execute_block(block.clone()).unwrap(); + + // assert that the block env is correctly set + let actual_block_env = executor.block_env(); + assert_eq!(actual_block_env.number, block.header.number); + assert_eq!(actual_block_env.timestamp, block.header.timestamp); + assert_eq!(actual_block_env.l1_gas_prices, block.header.gas_prices); + assert_eq!(actual_block_env.sequencer_address, block.header.sequencer_address); + } + + { + let block = &blocks[1]; + expected_txs.extend(block.body.iter().map(|t| t.into())); + + executor.execute_block(block.clone()).unwrap(); + + // assert that the block env is correctly set + let actual_block_env = executor.block_env(); + assert_eq!(actual_block_env.number, block.header.number); + assert_eq!(actual_block_env.timestamp, block.header.timestamp); + assert_eq!(actual_block_env.l1_gas_prices, block.header.gas_prices); + assert_eq!(actual_block_env.sequencer_address, block.header.sequencer_address); + } + + { + let block = &blocks[2]; + expected_txs.extend(block.body.iter().map(|t| t.into())); + + executor.execute_block(block.clone()).unwrap(); + + // assert that the block env is correctly set + let actual_block_env = executor.block_env(); + assert_eq!(actual_block_env.number, block.header.number); + assert_eq!(actual_block_env.timestamp, block.header.timestamp); + assert_eq!(actual_block_env.l1_gas_prices, block.header.gas_prices); + assert_eq!(actual_block_env.sequencer_address, block.header.sequencer_address); + } + + // get the current state of the executor after the blocks are executed + let state = executor.state(); + + // the contract address of the account deployed using the `DeployAccount` tx + let new_acc: ContractAddress = + felt!("0x77880e2192169bc7107d213ebe643452e1e3e8f40bcc2ebba420b77b1522bd1").into(); + + // assert that the deploy account tx executed correctly + let actual_new_acc_class_hash = state.class_hash_of_contract(new_acc).unwrap(); + let actual_new_acc_nonce = state.nonce(new_acc).unwrap(); + + assert_eq!( + actual_new_acc_class_hash, + Some(DEFAULT_OZ_ACCOUNT_CONTRACT_CLASS_HASH), + "account is deployed" + ); + assert_eq!(actual_new_acc_nonce, Some(1u64.into()), "account nonce is updated"); + + // the contract address of the main account used to send most of the transactions + let main_account: ContractAddress = + felt!("0x6b86e40118f29ebe393a75469b4d926c7a44c2e2681b6d319520b7c1156d114").into(); + + // compute the contract address that we deploy thru the UDC using Invoke tx + let deployed_contr = get_udc_deployed_address( + felt!("0x6ea2ff5aa6f633708e69f5c61d2ac5f860d2435b46ddbd016aa065bce25100a"), + felt!("0x02a8846878b6ad1f54f6ba46f5f40e11cee755c677f130b2c4b60566c9003f1f"), + &UdcUniqueness::Unique(UdcUniqueSettings { + deployer_address: *main_account, + udc_contract_address: felt!( + "0x41a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf" + ), + }), + &[ + felt!("0x4b415249"), + felt!("0x4b415249"), + felt!("0x12"), + felt!("0x1b39"), + felt!("0x0"), + felt!("0x6b86e40118f29ebe393a75469b4d926c7a44c2e2681b6d319520b7c1156d114"), + ], + ); + + let class_hash = state.class_hash_of_contract(deployed_contr.into()).unwrap(); + + assert_eq!(class_hash, Some(DEFAULT_LEGACY_ERC20_CONTRACT_CLASS_HASH), "contract is deployed"); + + // assert that the nonce of the main contract is updated, 4 txs were executed + let nonce = state.nonce(main_account).unwrap(); + assert_eq!(nonce, Some(4u64.into()), "account nonce is updated"); + + // assert that the legacy class is declared + let hash = felt!("0xbadbeef"); + + let actual_class = state.class(hash).unwrap(); + let actual_compiled_hash = state.compiled_class_hash_of_class_hash(hash).unwrap(); + + assert_eq!(actual_class, Some(fixtures::legacy_contract_class()), "legacy class is declared"); + assert_eq!( + actual_compiled_hash, + Some(hash), + "legacy compiled class hash is the same as class hash" + ); + + // assert that the sierra class is declared + let hash = felt!("0x420"); + let compiled_hash = felt!("0x1337"); + + let (casm, sierra) = fixtures::contract_class(); + let actual_casm = state.class(hash).unwrap(); + let actual_sierra = state.sierra_class(hash).unwrap(); + let actual_compiled_hash = state.compiled_class_hash_of_class_hash(hash).unwrap(); + + assert_eq!(actual_casm, Some(casm)); + assert_eq!(actual_sierra, Some(sierra)); + assert_eq!(actual_compiled_hash, Some(compiled_hash)); + + // assert the state updates + + let ExecutionOutput { states, transactions } = executor.take_execution_output().unwrap(); + + // asserts that the executed transactions are stored + let actual_txs: Vec = transactions.iter().map(|(tx, _)| tx.clone()).collect(); + + assert_eq!(actual_txs, expected_txs); + assert!(transactions.iter().all(|(_, rct)| rct.is_some()), "all txs should have a receipt"); + + let actual_nonce_updates = states.state_updates.nonce_updates; + let expected_nonce_updates = HashMap::from([(main_account, felt!("4")), (new_acc, felt!("1"))]); + + similar_asserts::assert_eq!(actual_nonce_updates, expected_nonce_updates); + + let actual_declared_classes = states.state_updates.declared_classes; + let expected_declared_classes = HashMap::from([ + (felt!("0xbadbeef"), felt!("0xbadbeef")), + (felt!("0x420"), felt!("0x1337")), + ]); + + similar_asserts::assert_eq!(actual_declared_classes, expected_declared_classes); + + let actual_contract_deployed = states.state_updates.contract_updates; + let expected_contract_deployed = HashMap::from([ + (new_acc, DEFAULT_OZ_ACCOUNT_CONTRACT_CLASS_HASH), + (deployed_contr.into(), DEFAULT_LEGACY_ERC20_CONTRACT_CLASS_HASH), + ]); + + similar_asserts::assert_eq!(actual_contract_deployed, expected_contract_deployed); +} diff --git a/crates/katana/executor/tests/fixtures/contract.json b/crates/katana/executor/tests/fixtures/contract.json new file mode 120000 index 0000000000..ce1957cd94 --- /dev/null +++ b/crates/katana/executor/tests/fixtures/contract.json @@ -0,0 +1 @@ +../../../primitives/contracts/compiled/oz_account_080.json \ No newline at end of file diff --git a/crates/katana/primitives/contracts/compiled/test_contract.json b/crates/katana/executor/tests/fixtures/legacy_contract.json similarity index 100% rename from crates/katana/primitives/contracts/compiled/test_contract.json rename to crates/katana/executor/tests/fixtures/legacy_contract.json diff --git a/crates/katana/executor/tests/fixtures/mod.rs b/crates/katana/executor/tests/fixtures/mod.rs new file mode 100644 index 0000000000..ae17aada2f --- /dev/null +++ b/crates/katana/executor/tests/fixtures/mod.rs @@ -0,0 +1,274 @@ +use std::collections::HashMap; + +use cairo_vm::vm::runners::builtin_runner::{ + BITWISE_BUILTIN_NAME, EC_OP_BUILTIN_NAME, HASH_BUILTIN_NAME, KECCAK_BUILTIN_NAME, + OUTPUT_BUILTIN_NAME, POSEIDON_BUILTIN_NAME, RANGE_CHECK_BUILTIN_NAME, + SEGMENT_ARENA_BUILTIN_NAME, SIGNATURE_BUILTIN_NAME, +}; +use katana_executor::SimulationFlag; +use katana_primitives::block::{ + Block, ExecutableBlock, FinalityStatus, GasPrices, PartialHeader, SealedBlockWithStatus, +}; +use katana_primitives::chain::ChainId; +use katana_primitives::class::{CompiledClass, FlattenedSierraClass}; +use katana_primitives::contract::ContractAddress; +use katana_primitives::env::{CfgEnv, FeeTokenAddressses}; +use katana_primitives::genesis::allocation::DevAllocationsGenerator; +use katana_primitives::genesis::constant::{ + DEFAULT_FEE_TOKEN_ADDRESS, DEFAULT_PREFUNDED_ACCOUNT_BALANCE, +}; +use katana_primitives::genesis::Genesis; +use katana_primitives::transaction::{ + DeclareTx, DeclareTxV1, DeclareTxV2, DeclareTxWithClass, DeployAccountTx, ExecutableTx, + ExecutableTxWithHash, InvokeTx, +}; +use katana_primitives::utils::class::{parse_compiled_class, parse_sierra_class}; +use katana_primitives::version::Version; +use katana_primitives::FieldElement; +use katana_provider::providers::in_memory::InMemoryProvider; +use katana_provider::traits::block::BlockWriter; +use katana_provider::traits::state::{StateFactoryProvider, StateProvider}; +use starknet::macros::felt; + +pub fn legacy_contract_class() -> CompiledClass { + let json = include_str!("legacy_contract.json"); + let artifact = serde_json::from_str(json).unwrap(); + parse_compiled_class(artifact).unwrap() +} + +pub fn contract_class() -> (CompiledClass, FlattenedSierraClass) { + let json = include_str!("contract.json"); + let artifact = serde_json::from_str(json).unwrap(); + + let sierra = parse_sierra_class(json).unwrap().flatten().unwrap(); + let compiled = parse_compiled_class(artifact).unwrap(); + + (compiled, sierra) +} + +/// Returns a state provider with some prefilled states. +#[rstest::fixture] +pub fn state_provider() -> Box { + let mut seed = [0u8; 32]; + seed[0] = b'0'; + + let accounts = DevAllocationsGenerator::new(10) + .with_seed(seed) + .with_balance(DEFAULT_PREFUNDED_ACCOUNT_BALANCE) + .generate(); + + let mut genesis = Genesis::default(); + genesis.extend_allocations(accounts.into_iter().map(|(k, v)| (k, v.into()))); + + let provider = InMemoryProvider::new(); + + let states = genesis.state_updates(); + let block = SealedBlockWithStatus { + status: FinalityStatus::AcceptedOnL2, + block: Block::default().seal_with_hash(123u64.into()), + }; + + provider + .insert_block_with_states_and_receipts(block, states, vec![]) + .expect("able to insert block"); + + ::latest(&provider).unwrap() +} + +// TODO: update the txs to include valid signatures +// TODO: add a declare transactions +/// Returns an array of blocks with transaction that are valid against the state by +/// [state_provider]. +#[rstest::fixture] +pub fn valid_blocks() -> [ExecutableBlock; 3] { + let version = Version::new(0, 13, 0); + let chain_id = ChainId::parse("KATANA").unwrap(); + let sequencer_address = ContractAddress(1u64.into()); + + let sender_address = ContractAddress(felt!( + "0x06b86e40118f29ebe393a75469b4d926c7a44c2e2681b6d319520b7c1156d114" + )); + + [ + ExecutableBlock { + header: PartialHeader { + version, + number: 1, + timestamp: 100, + sequencer_address, + parent_hash: 123u64.into(), + gas_prices: GasPrices::default(), + }, + body: vec![ + // fund the account to be deployed, sending 0x9999999999999 amount + ExecutableTxWithHash::new(ExecutableTx::Invoke(InvokeTx { + chain_id, + sender_address, + calldata: vec![ + felt!("0x1"), + felt!("0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7"), + felt!("0x83afd3f4caedc6eebf44246fe54e38c95e3179a5ec9ea81740eca5b482d12e"), + felt!("0x3"), + felt!("0x77880e2192169bc7107d213ebe643452e1e3e8f40bcc2ebba420b77b1522bd1"), + felt!("0x9999999999999"), + felt!("0x0"), + ], + max_fee: 0, + version: FieldElement::ONE, + signature: vec![], + nonce: FieldElement::ZERO, + })), + // declare contract + ExecutableTxWithHash::new(ExecutableTx::Declare({ + let (compiled_class, sierra) = contract_class(); + DeclareTxWithClass { + compiled_class, + sierra_class: Some(sierra), + transaction: DeclareTx::V2(DeclareTxV2 { + nonce: FieldElement::ONE, + max_fee: 0, + chain_id, + signature: vec![], + sender_address, + class_hash: felt!("0x420"), + compiled_class_hash: felt!("0x1337"), + }), + } + })), + ], + }, + ExecutableBlock { + header: PartialHeader { + version, + number: 2, + timestamp: 200, + sequencer_address, + parent_hash: 1234u64.into(), + gas_prices: GasPrices::default(), + }, + body: vec![ + // deploy account tx with the default account class + ExecutableTxWithHash::new(ExecutableTx::DeployAccount(DeployAccountTx { + chain_id, + max_fee: 0, + version: FieldElement::ONE, + signature: vec![], + nonce: 0u64.into(), + contract_address_salt: felt!( + "0x2ce091f544a799160324295e62da74d194eda204682b5b8fd0dd4d2f8f5ab18" + ), + constructor_calldata: vec![felt!( + "0x4c339f18b9d1b95b64a6d378abd1480b2e0d5d5bd33cd0828cbce4d65c27284" + )], + class_hash: felt!( + "0x5400e90f7e0ae78bd02c77cd75527280470e2fe19c54970dd79dc37a9d3645c" + ), + contract_address: ContractAddress(felt!( + "0x77880e2192169bc7107d213ebe643452e1e3e8f40bcc2ebba420b77b1522bd1" + )), + })), + ], + }, + ExecutableBlock { + header: PartialHeader { + version, + number: 3, + timestamp: 300, + sequencer_address, + parent_hash: 12345u64.into(), + gas_prices: GasPrices::default(), + }, + body: vec![ + // deploy contract using UDC + ExecutableTxWithHash::new(ExecutableTx::Invoke(InvokeTx { + chain_id, + sender_address, + calldata: vec![ + felt!("0x1"), + felt!("0x41a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf"), + felt!("0x1987cbd17808b9a23693d4de7e246a443cfe37e6e7fbaeabd7d7e6532b07c3d"), + felt!("0xa"), + felt!("0x2a8846878b6ad1f54f6ba46f5f40e11cee755c677f130b2c4b60566c9003f1f"), + felt!("0x6ea2ff5aa6f633708e69f5c61d2ac5f860d2435b46ddbd016aa065bce25100a"), + felt!("0x1"), + felt!("0x6"), + felt!("0x4b415249"), + felt!("0x4b415249"), + felt!("0x12"), + felt!("0x1b39"), + felt!("0x0"), + felt!("0x6b86e40118f29ebe393a75469b4d926c7a44c2e2681b6d319520b7c1156d114"), + ], + max_fee: 0, + version: FieldElement::ONE, + signature: vec![], + nonce: FieldElement::TWO, + })), + // legacy declare transaction + ExecutableTxWithHash::new(ExecutableTx::Declare(DeclareTxWithClass { + sierra_class: None, + compiled_class: legacy_contract_class(), + transaction: DeclareTx::V1(DeclareTxV1 { + chain_id, + sender_address, + max_fee: 0, + signature: vec![], + nonce: FieldElement::THREE, + class_hash: felt!("0xbadbeef"), + }), + })), + ], + }, + ] +} + +#[rstest::fixture] +pub fn cfg() -> CfgEnv { + let fee_token_addresses = + FeeTokenAddressses { eth: DEFAULT_FEE_TOKEN_ADDRESS, strk: ContractAddress(222u64.into()) }; + + let vm_resource_fee_cost = HashMap::from([ + (String::from("n_steps"), 1_f64), + (HASH_BUILTIN_NAME.to_string(), 1_f64), + (RANGE_CHECK_BUILTIN_NAME.to_string(), 1_f64), + (SIGNATURE_BUILTIN_NAME.to_string(), 1_f64), + (BITWISE_BUILTIN_NAME.to_string(), 1_f64), + (POSEIDON_BUILTIN_NAME.to_string(), 1_f64), + (OUTPUT_BUILTIN_NAME.to_string(), 1_f64), + (EC_OP_BUILTIN_NAME.to_string(), 1_f64), + (KECCAK_BUILTIN_NAME.to_string(), 1_f64), + (SEGMENT_ARENA_BUILTIN_NAME.to_string(), 1_f64), + ]); + + CfgEnv { + fee_token_addresses, + vm_resource_fee_cost, + max_recursion_depth: 100, + validate_max_n_steps: 1_000_000, + invoke_tx_max_n_steps: 1_000_000, + chain_id: ChainId::parse("KATANA").unwrap(), + } +} + +// TODO: test both with and without the flags turned on +#[rstest::fixture] +pub fn flags() -> SimulationFlag { + SimulationFlag { + skip_validate: true, + ignore_max_fee: true, + skip_fee_transfer: true, + ..Default::default() + } +} + +pub mod blockifier { + use katana_executor::implementation::blockifier::BlockifierFactory; + use katana_executor::SimulationFlag; + + use super::{cfg, flags, CfgEnv}; + + #[rstest::fixture] + pub fn factory(cfg: CfgEnv, flags: SimulationFlag) -> BlockifierFactory { + BlockifierFactory::new(cfg, flags) + } +} diff --git a/crates/katana/executor/tests/simulate.rs b/crates/katana/executor/tests/simulate.rs new file mode 100644 index 0000000000..681564e4bf --- /dev/null +++ b/crates/katana/executor/tests/simulate.rs @@ -0,0 +1 @@ +mod fixtures; diff --git a/crates/katana/primitives/contracts/compiled/account.json b/crates/katana/primitives/contracts/compiled/account.json index f015ab90e6..195603b14e 100644 --- a/crates/katana/primitives/contracts/compiled/account.json +++ b/crates/katana/primitives/contracts/compiled/account.json @@ -1,4579 +1,5698 @@ { - "abi": [ - { - "members": [ - { "name": "to", "offset": 0, "type": "felt" }, - { "name": "selector", "offset": 1, "type": "felt" }, - { "name": "data_offset", "offset": 2, "type": "felt" }, - { "name": "data_len", "offset": 3, "type": "felt" } - ], - "name": "AccountCallArray", - "size": 4, - "type": "struct" - }, - { - "inputs": [{ "name": "publicKey", "type": "felt" }], - "name": "constructor", - "outputs": [], - "type": "constructor" - }, - { - "inputs": [], - "name": "getPublicKey", - "outputs": [{ "name": "publicKey", "type": "felt" }], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [{ "name": "interfaceId", "type": "felt" }], - "name": "supportsInterface", - "outputs": [{ "name": "success", "type": "felt" }], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [{ "name": "newPublicKey", "type": "felt" }], - "name": "setPublicKey", - "outputs": [], - "type": "function" - }, - { - "inputs": [ - { "name": "hash", "type": "felt" }, - { "name": "signature_len", "type": "felt" }, - { "name": "signature", "type": "felt*" } - ], - "name": "isValidSignature", - "outputs": [{ "name": "isValid", "type": "felt" }], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { "name": "call_array_len", "type": "felt" }, - { "name": "call_array", "type": "AccountCallArray*" }, - { "name": "calldata_len", "type": "felt" }, - { "name": "calldata", "type": "felt*" } - ], - "name": "__validate__", - "outputs": [], - "type": "function" - }, - { - "inputs": [{ "name": "class_hash", "type": "felt" }], - "name": "__validate_declare__", - "outputs": [], - "type": "function" - }, - { - "inputs": [ - { "name": "class_hash", "type": "felt" }, - { "name": "salt", "type": "felt" }, - { "name": "publicKey", "type": "felt" } - ], - "name": "__validate_deploy__", - "outputs": [], - "type": "function" - }, - { - "inputs": [ - { "name": "call_array_len", "type": "felt" }, - { "name": "call_array", "type": "AccountCallArray*" }, - { "name": "calldata_len", "type": "felt" }, - { "name": "calldata", "type": "felt*" } - ], - "name": "__execute__", - "outputs": [ - { "name": "response_len", "type": "felt" }, - { "name": "response", "type": "felt*" } - ], - "type": "function" - } - ], - "entry_points_by_type": { - "CONSTRUCTOR": [ - { - "offset": "0x16e", - "selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194" - } - ], - "EXTERNAL": [ - { - "offset": "0x1cd", - "selector": "0xbc0eb87884ab91e330445c3584a50d7ddf4b568f02fbeb456a6242cce3f5d9" - }, - { - "offset": "0x2bb", - "selector": "0x15d40a3d6ca2ac30f4031e42be28da9b056fef9bb7357ac5e85627ee876e5ad" - }, - { - "offset": "0x224", - "selector": "0x162da33a4585851fe8d3af3c2a9c60b557814e221e0d4f30ff0b2189d9c7775" - }, - { - "offset": "0x191", - "selector": "0x1a6c6a0bdec86cc645c91997d8eea83e87148659e3e61122f72361fd5e94079" - }, - { - "offset": "0x1f4", - "selector": "0x213dfe25e2ca309c4d615a09cfc95fdb2fc7dc73fbcad12c450fe93b1f2ff9e" - }, - { - "offset": "0x25f", - "selector": "0x289da278a8dc833409cabfdad1581e8e7d40e42dcaed693fa4008dcdb4963b3" - }, - { - "offset": "0x1b2", - "selector": "0x29e211664c0b63c79638fbea474206ca74016b3e9a3dc4f9ac300ffd8bdf2cd" - }, - { - "offset": "0x285", - "selector": "0x36fcbf06cd96843058359e1a75928beacfac10727dab22a3972f0af8aa92895" - } - ], - "L1_HANDLER": [] - }, - "program": { - "debug_info": { - "file_contents": {}, - "instruction_locations": {} - }, - "attributes": [ - { - "accessible_scopes": [ - "openzeppelin.account.library", - "openzeppelin.account.library.Account", - "openzeppelin.account.library.Account.assert_only_self" - ], - "end_pc": 192, - "flow_tracking_data": { - "ap_tracking": { "group": 16, "offset": 12 }, - "reference_ids": {} - }, - "name": "error_message", - "start_pc": 191, - "value": "Account: caller is not this account" - }, - { - "accessible_scopes": [ - "openzeppelin.account.library", - "openzeppelin.account.library.Account", - "openzeppelin.account.library.Account.execute" - ], - "end_pc": 269, - "flow_tracking_data": { - "ap_tracking": { "group": 21, "offset": 9 }, - "reference_ids": {} - }, - "name": "error_message", - "start_pc": 259, - "value": "Account: deprecated tx version" - }, - { - "accessible_scopes": [ - "openzeppelin.account.library", - "openzeppelin.account.library.Account", - "openzeppelin.account.library.Account.execute" - ], - "end_pc": 274, - "flow_tracking_data": { - "ap_tracking": { "group": 21, "offset": 49 }, - "reference_ids": {} - }, - "name": "error_message", - "start_pc": 272, - "value": "Account: reentrant call" - } - ], - "builtins": ["pedersen", "range_check", "ecdsa", "bitwise"], - "compiler_version": "0.10.2", - "data": [ - "0x40780017fff7fff", - "0x1", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffd", - "0x3", - "0x208b7fff7fff7ffe", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480080007fff8000", - "0x400080007ffd7fff", - "0x482480017ffd8001", - "0x1", - "0x482480017ffd8001", - "0x1", - "0xa0680017fff7ffe", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", - "0x402a7ffc7ffd7fff", - "0x208b7fff7fff7ffe", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x484480017fff8000", - "0x2aaaaaaaaaaaab05555555555555556", - "0x48307fff7ffd8000", - "0x480280027ffb8000", - "0x480280037ffb8000", - "0x484480017fff8000", - "0x4000000000000088000000000000001", - "0x48307fff7ffd8000", - "0xa0680017fff8000", - "0xe", - "0x480680017fff8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x48287ffc80007fff", - "0x40307ffc7ff87fff", - "0x48297ffd80007ffc", - "0x482680017ffd8000", - "0x1", - "0x48507fff7ffe8000", - "0x40507ff97ff57fff", - "0x482680017ffb8000", - "0x4", - "0x208b7fff7fff7ffe", - "0xa0680017fff8000", - "0xc", - "0x480680017fff8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x48287ffd80007fff", - "0x48327fff7ffc8000", - "0x40307ffa7ff67fff", - "0x48527ffe7ffc8000", - "0x40507ff97ff57fff", - "0x482680017ffb8000", - "0x4", - "0x208b7fff7fff7ffe", - "0x40317ffd7ff97ffd", - "0x48297ffc80007ffd", - "0x48527fff7ffc8000", - "0x40507ffb7ff77fff", - "0x40780017fff7fff", - "0x2", - "0x482680017ffb8000", - "0x4", - "0x208b7fff7fff7ffe", - "0x48297ffd80007ffc", - "0x20680017fff7fff", - "0x4", - "0x402780017ffc7ffc", - "0x1", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcc", - "0x208b7fff7fff7ffe", - "0x480680017fff8000", - "0x43616c6c436f6e7472616374", - "0x400280007ff97fff", - "0x400380017ff97ffa", - "0x400380027ff97ffb", - "0x400380037ff97ffc", - "0x400380047ff97ffd", - "0x482680017ff98000", - "0x7", - "0x480280057ff98000", - "0x480280067ff98000", - "0x208b7fff7fff7ffe", - "0x480680017fff8000", - "0x47657443616c6c657241646472657373", - "0x400280007ffd7fff", - "0x482680017ffd8000", - "0x2", - "0x480280017ffd8000", - "0x208b7fff7fff7ffe", - "0x480680017fff8000", - "0x476574436f6e747261637441646472657373", - "0x400280007ffd7fff", - "0x482680017ffd8000", - "0x2", - "0x480280017ffd8000", - "0x208b7fff7fff7ffe", - "0x480680017fff8000", - "0x53746f7261676552656164", - "0x400280007ffc7fff", - "0x400380017ffc7ffd", - "0x482680017ffc8000", - "0x3", - "0x480280027ffc8000", - "0x208b7fff7fff7ffe", - "0x480680017fff8000", - "0x53746f726167655772697465", - "0x400280007ffb7fff", - "0x400380017ffb7ffc", - "0x400380027ffb7ffd", - "0x482680017ffb8000", - "0x3", - "0x208b7fff7fff7ffe", - "0x480680017fff8000", - "0x4765745478496e666f", - "0x400280007ffd7fff", - "0x482680017ffd8000", - "0x2", - "0x480280017ffd8000", - "0x208b7fff7fff7ffe", - "0x400380017ff97ffa", - "0x400380007ff97ffb", - "0x482680017ff98000", - "0x2", - "0x208b7fff7fff7ffe", - "0xa0680017fff8000", - "0xc", - "0x40780017fff7fff", - "0x6", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff8c", - "0x480680017fff8000", - "0x1", - "0x208b7fff7fff7ffe", - "0x480a7ffb7fff8000", - "0x480a7ffd7fff8000", - "0x480a7ffc7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffb1", - "0x480680017fff8000", - "0x0", - "0x208b7fff7fff7ffe", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x480680017fff8000", - "0x1379ac0624b939ceb9dede92211d7db5ee174fe28be72245b0a1a2abd81c98f", - "0x208b7fff7fff7ffe", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffa", - "0x480a7ffb7fff8000", - "0x48127ffe7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc6", - "0x48127ffe7fff8000", - "0x48127ff57fff8000", - "0x48127ff57fff8000", - "0x48127ffc7fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffed", - "0x480a7ffa7fff8000", - "0x48127ffe7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc0", - "0x48127ff67fff8000", - "0x48127ff67fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff1", - "0x208b7fff7fff7ffe", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffa4", - "0x48127ffe7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff9a", - "0x40127fff7fff7ff9", - "0x48127ffe7fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd5", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffe00365a", - "0x20680017fff7fff", - "0x8", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480680017fff8000", - "0x1", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffff59942a8c", - "0x20680017fff7fff", - "0x8", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480680017fff8000", - "0x1", - "0x208b7fff7fff7ffe", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480680017fff8000", - "0x0", - "0x208b7fff7fff7ffe", - "0x480a7ffa7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd7", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffbf", - "0x208b7fff7fff7ffe", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a7ffa7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffac", - "0x480a7ff97fff8000", - "0x480a7ffb7fff8000", - "0x48127ffd7fff8000", - "0x480280007ffd8000", - "0x480280017ffd8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff87", - "0x48127ff47fff8000", - "0x48127ff47fff8000", - "0x48127ffd7fff8000", - "0x48127ff37fff8000", - "0x480680017fff8000", - "0x1", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x3", - "0x480a7ff57fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff74", - "0x480a7ff97fff8000", - "0x480680017fff8000", - "0x1", - "0x480080007ffd8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff7a", - "0x480680017fff8000", - "0x1", - "0x40127fff7fff7ffe", - "0x40137ffd7fff8000", - "0x48127fdc7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff49", - "0x400680017fff7fff", - "0x0", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffeef", - "0x40137fff7fff8001", - "0x48127ffb7fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffd7fff8000", - "0x480a80017fff8000", - "0x1104800180018000", - "0x35", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffee5", - "0x40137fff7fff8002", - "0x48127ffc7fff8000", - "0x480a7ffa7fff8000", - "0x480a80017fff8000", - "0x480a80027fff8000", - "0x1104800180018000", - "0xa", - "0x48127ffe7fff8000", - "0x480a7ff67fff8000", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a80007fff8000", - "0x48127ffa7fff8000", - "0x480a80027fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x3", - "0x20780017fff7ffb", - "0x6", - "0x480a7ffa7fff8000", - "0x480680017fff8000", - "0x0", - "0x208b7fff7fff7ffe", - "0x480a7ffa7fff8000", - "0x480280007ffc8000", - "0x480280017ffc8000", - "0x480280027ffc8000", - "0x480280037ffc8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff11", - "0x40137ffe7fff8000", - "0x40137fff7fff8001", - "0x40137ffd7fff8002", - "0x480a7ffd7fff8000", - "0x480a80017fff8000", - "0x480a80007fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffec2", - "0x480a80027fff8000", - "0x482680017ffb8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x482680017ffc8000", - "0x4", - "0x482a80007ffd8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe4", - "0x48127ffe7fff8000", - "0x482880007ffe8000", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffa", - "0x4", - "0x480a7ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480280007ffb8000", - "0x400280007ffd7fff", - "0x480280017ffb8000", - "0x400280017ffd7fff", - "0x480280037ffb8000", - "0x400280027ffd7fff", - "0x480280027ffb8000", - "0x48327fff7ffc8000", - "0x400280037ffd7fff", - "0x480a7ff97fff8000", - "0x482680017ffa8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x482680017ffb8000", - "0x4", - "0x480a7ffc7fff8000", - "0x482680017ffd8000", - "0x4", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffec", - "0x208b7fff7fff7ffe", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff48", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x1", - "0x402a7ffd7ffc7fff", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280027ffb8000", - "0x480280007ffd8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", - "0x40780017fff7fff", - "0x1", - "0x48127ffc7fff8000", - "0x48127ffc7fff8000", - "0x48127ffc7fff8000", - "0x480280037ffb8000", - "0x480280047ffb8000", - "0x480680017fff8000", - "0x0", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff3e", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1", - "0x4003800080007ffc", - "0x4826800180008000", - "0x1", - "0x480a7ffd7fff8000", - "0x4828800080007ffe", - "0x480a80007fff8000", - "0x208b7fff7fff7ffe", - "0x402b7ffd7ffc7ffd", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280027ffb8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", - "0x48127ffe7fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff1", - "0x48127ff47fff8000", - "0x48127ff47fff8000", - "0x48127ffb7fff8000", - "0x480280037ffb8000", - "0x480280047ffb8000", - "0x48127ff97fff8000", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff23", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1", - "0x4003800080007ffc", - "0x4826800180008000", - "0x1", - "0x480a7ffd7fff8000", - "0x4828800080007ffe", - "0x480a80007fff8000", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x1", - "0x402a7ffd7ffc7fff", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280027ffb8000", - "0x480280007ffd8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffea", - "0x48127ffe7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", - "0x48127ff47fff8000", - "0x48127ff47fff8000", - "0x48127ffb7fff8000", - "0x480280037ffb8000", - "0x480280047ffb8000", - "0x48127ff97fff8000", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff19", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x1", - "0x402a7ffd7ffc7fff", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280027ffb8000", - "0x480280007ffd8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", - "0x40780017fff7fff", - "0x1", - "0x48127ffc7fff8000", - "0x48127ffc7fff8000", - "0x48127ffc7fff8000", - "0x480280037ffb8000", - "0x480280047ffb8000", - "0x480680017fff8000", - "0x0", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff04", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1", - "0x4003800080007ffc", - "0x4826800180008000", - "0x1", - "0x480a7ffd7fff8000", - "0x4828800080007ffe", - "0x480a80007fff8000", - "0x208b7fff7fff7ffe", - "0x480280027ffb8000", - "0x480280017ffd8000", - "0x400080007ffe7fff", - "0x482680017ffd8000", - "0x2", - "0x480280017ffd8000", - "0x48307fff7ffe8000", - "0x402a7ffd7ffc7fff", - "0x480280027ffb8000", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280037ffb8000", - "0x482480017ffc8000", - "0x1", - "0x480280007ffd8000", - "0x480280017ffd8000", - "0x482680017ffd8000", - "0x2", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdc", - "0x48127ffe7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe3", - "0x48127ff37fff8000", - "0x48127ff37fff8000", - "0x48127ffb7fff8000", - "0x48127ff27fff8000", - "0x480280047ffb8000", - "0x48127ff97fff8000", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ff67fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe61", - "0x48127ffe7fff8000", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480080057ffb8000", - "0x480080037ffa8000", - "0x480080047ff98000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffecf", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x208b7fff7fff7ffe", - "0x480280027ffb8000", - "0x480280007ffd8000", - "0x400080007ffe7fff", - "0x482680017ffd8000", - "0x1", - "0x480280007ffd8000", - "0x484480017fff8000", - "0x4", - "0x48307fff7ffd8000", - "0x480280027ffb8000", - "0x480080007ffe8000", - "0x400080017ffe7fff", - "0x482480017ffd8000", - "0x1", - "0x480080007ffc8000", - "0x48307fff7ffe8000", - "0x402a7ffd7ffc7fff", - "0x480280027ffb8000", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280037ffb8000", - "0x482480017ffc8000", - "0x2", - "0x480280007ffd8000", - "0x482680017ffd8000", - "0x1", - "0x480080007ff38000", - "0x482480017ff28000", - "0x1", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd3", - "0x40780017fff7fff", - "0x1", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffc7fff8000", - "0x48127ffa7fff8000", - "0x480280047ffb8000", - "0x480680017fff8000", - "0x0", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ff97fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe26", - "0x48127ffe7fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480080057ffb8000", - "0x480080037ffa8000", - "0x480080047ff98000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe94", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x1", - "0x402a7ffd7ffc7fff", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280037ffb8000", - "0x480280027ffb8000", - "0x480280007ffd8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe8", - "0x40780017fff7fff", - "0x1", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffc7fff8000", - "0x48127ffa7fff8000", - "0x480280047ffb8000", - "0x480680017fff8000", - "0x0", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ff77fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe00", - "0x48127ffe7fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480080057ffb8000", - "0x480080037ffa8000", - "0x480080047ff98000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe6e", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x3", - "0x402a7ffd7ffc7fff", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280037ffb8000", - "0x480280027ffb8000", - "0x480280007ffd8000", - "0x480280017ffd8000", - "0x480280027ffd8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe6", - "0x40780017fff7fff", - "0x1", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x48127ffc7fff8000", - "0x48127ffa7fff8000", - "0x480280047ffb8000", - "0x480680017fff8000", - "0x0", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ff57fff8000", - "0x480a7ff67fff8000", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe5a", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x3", - "0x4003800080007ffb", - "0x400380007ffd7ffb", - "0x402780017ffd8001", - "0x1", - "0x4826800180008000", - "0x1", - "0x40297ffb7fff8002", - "0x4826800180008000", - "0x1", - "0x480a7ffc7fff8000", - "0x480a7ffb7fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd4f", - "0x480a80017fff8000", - "0x4829800080008002", - "0x480a80007fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x4", - "0x480280027ffb8000", - "0x480280007ffd8000", - "0x400080007ffe7fff", - "0x482680017ffd8000", - "0x1", - "0x480280007ffd8000", - "0x484480017fff8000", - "0x4", - "0x48307fff7ffd8000", - "0x480280027ffb8000", - "0x480080007ffe8000", - "0x400080017ffe7fff", - "0x482480017ffd8000", - "0x1", - "0x480080007ffc8000", - "0x48307fff7ffe8000", - "0x402a7ffd7ffc7fff", - "0x480280027ffb8000", - "0x480280007ffb8000", - "0x480280017ffb8000", - "0x480280037ffb8000", - "0x480280047ffb8000", - "0x482480017ffb8000", - "0x2", - "0x480280007ffd8000", - "0x482680017ffd8000", - "0x1", - "0x480080007ff28000", - "0x482480017ff18000", - "0x1", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc2", - "0x40137ff97fff8000", - "0x40137ffa7fff8001", - "0x40137ffb7fff8002", - "0x40137ffc7fff8003", - "0x48127ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc7", - "0x480a80007fff8000", - "0x480a80017fff8000", - "0x48127ffb7fff8000", - "0x480a80027fff8000", - "0x480a80037fff8000", - "0x48127ff97fff8000", - "0x48127ff97fff8000", - "0x208b7fff7fff7ffe" - ], - "hints": { - "0": [ - { - "accessible_scopes": [ - "starkware.cairo.common.alloc", - "starkware.cairo.common.alloc.alloc" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 0, "offset": 0 }, - "reference_ids": {} - } - } - ], - "6": [ - { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "code": "vm_enter_scope({'n': ids.len})", - "flow_tracking_data": { - "ap_tracking": { "group": 1, "offset": 0 }, - "reference_ids": { "starkware.cairo.common.memcpy.memcpy.len": 0 } - } - } - ], - "14": [ - { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "code": "n -= 1\nids.continue_copying = 1 if n > 0 else 0", - "flow_tracking_data": { - "ap_tracking": { "group": 1, "offset": 5 }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.continue_copying": 1 - } - } - } - ], - "17": [ - { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "code": "vm_exit_scope()", - "flow_tracking_data": { - "ap_tracking": { "group": 1, "offset": 6 }, - "reference_ids": {} - } - } - ], - "18": [ - { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_le_felt" - ], - "code": "import itertools\n\nfrom starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\na = ids.a % PRIME\nb = ids.b % PRIME\nassert a <= b, f'a = {a} is not less than or equal to b = {b}.'\n\n# Find an arc less than PRIME / 3, and another less than PRIME / 2.\nlengths_and_indices = [(a, 0), (b - a, 1), (PRIME - 1 - b, 2)]\nlengths_and_indices.sort()\nassert lengths_and_indices[0][0] <= PRIME // 3 and lengths_and_indices[1][0] <= PRIME // 2\nexcluded = lengths_and_indices[2][1]\n\nmemory[ids.range_check_ptr + 1], memory[ids.range_check_ptr + 0] = (\n divmod(lengths_and_indices[0][0], ids.PRIME_OVER_3_HIGH))\nmemory[ids.range_check_ptr + 3], memory[ids.range_check_ptr + 2] = (\n divmod(lengths_and_indices[1][0], ids.PRIME_OVER_2_HIGH))", - "flow_tracking_data": { - "ap_tracking": { "group": 2, "offset": 0 }, - "reference_ids": { - "starkware.cairo.common.math.assert_le_felt.a": 2, - "starkware.cairo.common.math.assert_le_felt.b": 3, - "starkware.cairo.common.math.assert_le_felt.range_check_ptr": 4 - } - } - } - ], - "28": [ - { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_le_felt" - ], - "code": "memory[ap] = 1 if excluded != 0 else 0", - "flow_tracking_data": { - "ap_tracking": { "group": 2, "offset": 8 }, - "reference_ids": {} - } - } - ], - "42": [ - { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_le_felt" - ], - "code": "memory[ap] = 1 if excluded != 1 else 0", - "flow_tracking_data": { - "ap_tracking": { "group": 2, "offset": 9 }, - "reference_ids": {} - } - } - ], - "54": [ - { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_le_felt" - ], - "code": "assert excluded == 2", - "flow_tracking_data": { - "ap_tracking": { "group": 2, "offset": 10 }, - "reference_ids": {} - } - } - ], - "63": [ - { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_lt_felt" - ], - "code": "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'", - "flow_tracking_data": { - "ap_tracking": { "group": 3, "offset": 0 }, - "reference_ids": { - "starkware.cairo.common.math.assert_lt_felt.a": 5, - "starkware.cairo.common.math.assert_lt_felt.b": 6 - } - } - } - ], - "81": [ - { - "accessible_scopes": [ - "starkware.starknet.common.syscalls", - "starkware.starknet.common.syscalls.call_contract" - ], - "code": "syscall_handler.call_contract(segments=segments, syscall_ptr=ids.syscall_ptr)", - "flow_tracking_data": { - "ap_tracking": { "group": 4, "offset": 1 }, - "reference_ids": { - "starkware.starknet.common.syscalls.call_contract.syscall_ptr": 7 - } - } - } - ], - "89": [ - { - "accessible_scopes": [ - "starkware.starknet.common.syscalls", - "starkware.starknet.common.syscalls.get_caller_address" - ], - "code": "syscall_handler.get_caller_address(segments=segments, syscall_ptr=ids.syscall_ptr)", - "flow_tracking_data": { - "ap_tracking": { "group": 5, "offset": 1 }, - "reference_ids": { - "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr": 8 - } - } - } - ], - "96": [ - { - "accessible_scopes": [ - "starkware.starknet.common.syscalls", - "starkware.starknet.common.syscalls.get_contract_address" - ], - "code": "syscall_handler.get_contract_address(segments=segments, syscall_ptr=ids.syscall_ptr)", - "flow_tracking_data": { - "ap_tracking": { "group": 6, "offset": 1 }, - "reference_ids": { - "starkware.starknet.common.syscalls.get_contract_address.syscall_ptr": 9 - } - } - } - ], - "104": [ - { - "accessible_scopes": [ - "starkware.starknet.common.syscalls", - "starkware.starknet.common.syscalls.storage_read" - ], - "code": "syscall_handler.storage_read(segments=segments, syscall_ptr=ids.syscall_ptr)", - "flow_tracking_data": { - "ap_tracking": { "group": 7, "offset": 1 }, - "reference_ids": { - "starkware.starknet.common.syscalls.storage_read.syscall_ptr": 10 - } - } - } - ], - "113": [ - { - "accessible_scopes": [ - "starkware.starknet.common.syscalls", - "starkware.starknet.common.syscalls.storage_write" - ], - "code": "syscall_handler.storage_write(segments=segments, syscall_ptr=ids.syscall_ptr)", - "flow_tracking_data": { - "ap_tracking": { "group": 8, "offset": 1 }, - "reference_ids": { - "starkware.starknet.common.syscalls.storage_write.syscall_ptr": 11 - } - } - } - ], - "119": [ - { - "accessible_scopes": [ - "starkware.starknet.common.syscalls", - "starkware.starknet.common.syscalls.get_tx_info" - ], - "code": "syscall_handler.get_tx_info(segments=segments, syscall_ptr=ids.syscall_ptr)", - "flow_tracking_data": { - "ap_tracking": { "group": 9, "offset": 1 }, - "reference_ids": { - "starkware.starknet.common.syscalls.get_tx_info.syscall_ptr": 12 - } - } - } - ], - "123": [ - { - "accessible_scopes": [ - "starkware.cairo.common.signature", - "starkware.cairo.common.signature.verify_ecdsa_signature" - ], - "code": "ecdsa_builtin.add_signature(ids.ecdsa_ptr.address_, (ids.signature_r, ids.signature_s))", - "flow_tracking_data": { - "ap_tracking": { "group": 10, "offset": 0 }, - "reference_ids": { - "starkware.cairo.common.signature.verify_ecdsa_signature.ecdsa_ptr": 15, - "starkware.cairo.common.signature.verify_ecdsa_signature.signature_r": 13, - "starkware.cairo.common.signature.verify_ecdsa_signature.signature_s": 14 - } - } - } - ], - "128": [ - { - "accessible_scopes": [ - "starkware.cairo.common.math_cmp", - "starkware.cairo.common.math_cmp.is_le_felt" - ], - "code": "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1", - "flow_tracking_data": { - "ap_tracking": { "group": 11, "offset": 0 }, - "reference_ids": { - "starkware.cairo.common.math_cmp.is_le_felt.a": 16, - "starkware.cairo.common.math_cmp.is_le_felt.b": 17 - } - } - } - ], - "375": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.constructor" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 30, "offset": 35 }, - "reference_ids": {} - } - } - ], - "392": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.getPublicKey_encode_return" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 32, "offset": 0 }, - "reference_ids": {} - } - } - ], - "425": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.supportsInterface_encode_return" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 36, "offset": 0 }, - "reference_ids": {} - } - } - ], - "470": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.setPublicKey" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 40, "offset": 50 }, - "reference_ids": {} - } - } - ], - "491": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.isValidSignature_encode_return" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 42, "offset": 0 }, - "reference_ids": {} - } - } - ], - "579": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.__validate__" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 45, "offset": 77 }, - "reference_ids": {} - } - } - ], - "617": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.__validate_declare__" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 47, "offset": 63 }, - "reference_ids": {} - } - } - ], - "657": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.__validate_deploy__" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 49, "offset": 65 }, - "reference_ids": {} - } - } - ], - "680": [ - { - "accessible_scopes": [ - "__main__", - "__main__", - "__wrappers__", - "__wrappers__.__execute___encode_return" - ], - "code": "memory[ap] = segments.add()", - "flow_tracking_data": { - "ap_tracking": { "group": 52, "offset": 0 }, - "reference_ids": {} - } - } - ] - }, - "identifiers": { - "__main__.Account": { - "destination": "openzeppelin.account.library.Account", - "type": "alias" - }, - "__main__.AccountCallArray": { - "destination": "openzeppelin.account.library.AccountCallArray", - "type": "alias" - }, - "__main__.BitwiseBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "type": "alias" - }, - "__main__.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "__main__.SignatureBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", - "type": "alias" - }, - "__main__.__execute__": { - "decorators": ["external"], - "pc": 668, - "type": "function" - }, - "__main__.__execute__.Args": { - "full_name": "__main__.__execute__.Args", - "members": { - "call_array": { - "cairo_type": "openzeppelin.account.library.AccountCallArray*", - "offset": 1 - }, - "call_array_len": { "cairo_type": "felt", "offset": 0 }, - "calldata": { "cairo_type": "felt*", "offset": 3 }, - "calldata_len": { "cairo_type": "felt", "offset": 2 } - }, - "size": 4, - "type": "struct" - }, - "__main__.__execute__.ImplicitArgs": { - "full_name": "__main__.__execute__.ImplicitArgs", - "members": { - "bitwise_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin*", - "offset": 3 - }, - "ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "offset": 2 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 4 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 5, - "type": "struct" - }, - "__main__.__execute__.Return": { - "cairo_type": "(response_len: felt, response: felt*)", - "type": "type_definition" - }, - "__main__.__execute__.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__main__.__validate__": { - "decorators": ["external"], - "pc": 531, - "type": "function" - }, - "__main__.__validate__.Args": { - "full_name": "__main__.__validate__.Args", - "members": { - "call_array": { - "cairo_type": "openzeppelin.account.library.AccountCallArray*", - "offset": 1 - }, - "call_array_len": { "cairo_type": "felt", "offset": 0 }, - "calldata": { "cairo_type": "felt*", "offset": 3 }, - "calldata_len": { "cairo_type": "felt", "offset": 2 } - }, - "size": 4, - "type": "struct" - }, - "__main__.__validate__.ImplicitArgs": { - "full_name": "__main__.__validate__.ImplicitArgs", - "members": { - "ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "offset": 2 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 3 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 4, - "type": "struct" - }, - "__main__.__validate__.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.__validate__.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__main__.__validate_declare__": { - "decorators": ["external"], - "pc": 590, - "type": "function" - }, - "__main__.__validate_declare__.Args": { - "full_name": "__main__.__validate_declare__.Args", - "members": { "class_hash": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "__main__.__validate_declare__.ImplicitArgs": { - "full_name": "__main__.__validate_declare__.ImplicitArgs", - "members": { - "ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "offset": 2 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 3 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 4, - "type": "struct" - }, - "__main__.__validate_declare__.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.__validate_declare__.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "__main__.__validate_deploy__": { - "decorators": ["external"], - "pc": 628, - "type": "function" - }, - "__main__.__validate_deploy__.Args": { - "full_name": "__main__.__validate_deploy__.Args", - "members": { - "class_hash": { "cairo_type": "felt", "offset": 0 }, - "publicKey": { "cairo_type": "felt", "offset": 2 }, - "salt": { "cairo_type": "felt", "offset": 1 } - }, - "size": 3, - "type": "struct" - }, - "__main__.__validate_deploy__.ImplicitArgs": { - "full_name": "__main__.__validate_deploy__.ImplicitArgs", - "members": { - "ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "offset": 2 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 3 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 4, - "type": "struct" - }, - "__main__.__validate_deploy__.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.__validate_deploy__.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__main__.constructor": { - "decorators": ["constructor"], - "pc": 359, - "type": "function" - }, - "__main__.constructor.Args": { - "full_name": "__main__.constructor.Args", - "members": { "publicKey": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "__main__.constructor.ImplicitArgs": { - "full_name": "__main__.constructor.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "__main__.constructor.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.constructor.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__main__.getPublicKey": { - "decorators": ["view"], - "pc": 386, - "type": "function" - }, - "__main__.getPublicKey.Args": { - "full_name": "__main__.getPublicKey.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__main__.getPublicKey.ImplicitArgs": { - "full_name": "__main__.getPublicKey.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "__main__.getPublicKey.Return": { - "cairo_type": "(publicKey: felt)", - "type": "type_definition" - }, - "__main__.getPublicKey.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__main__.get_tx_info": { - "destination": "starkware.starknet.common.syscalls.get_tx_info", - "type": "alias" - }, - "__main__.isValidSignature": { - "decorators": ["view"], - "pc": 481, - "type": "function" - }, - "__main__.isValidSignature.Args": { - "full_name": "__main__.isValidSignature.Args", - "members": { - "hash": { "cairo_type": "felt", "offset": 0 }, - "signature": { "cairo_type": "felt*", "offset": 2 }, - "signature_len": { "cairo_type": "felt", "offset": 1 } - }, - "size": 3, - "type": "struct" - }, - "__main__.isValidSignature.ImplicitArgs": { - "full_name": "__main__.isValidSignature.ImplicitArgs", - "members": { - "ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "offset": 2 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 3 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 4, - "type": "struct" - }, - "__main__.isValidSignature.Return": { - "cairo_type": "(isValid: felt)", - "type": "type_definition" - }, - "__main__.isValidSignature.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__main__.setPublicKey": { - "decorators": ["external"], - "pc": 454, - "type": "function" - }, - "__main__.setPublicKey.Args": { - "full_name": "__main__.setPublicKey.Args", - "members": { "newPublicKey": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "__main__.setPublicKey.ImplicitArgs": { - "full_name": "__main__.setPublicKey.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "__main__.setPublicKey.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.setPublicKey.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__main__.supportsInterface": { - "decorators": ["view"], - "pc": 418, - "type": "function" - }, - "__main__.supportsInterface.Args": { - "full_name": "__main__.supportsInterface.Args", - "members": { "interfaceId": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "__main__.supportsInterface.ImplicitArgs": { - "full_name": "__main__.supportsInterface.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "__main__.supportsInterface.Return": { - "cairo_type": "(success: felt)", - "type": "type_definition" - }, - "__main__.supportsInterface.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__wrappers__.__execute__": { - "decorators": ["external"], - "pc": 699, - "type": "function" - }, - "__wrappers__.__execute__.Args": { - "full_name": "__wrappers__.__execute__.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__execute__.ImplicitArgs": { - "full_name": "__wrappers__.__execute__.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__execute__.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: starkware.cairo.common.cairo_builtins.BitwiseBuiltin*, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.__execute__.SIZEOF_LOCALS": { "type": "const", "value": 4 }, - "__wrappers__.__execute__.__wrapped_func": { - "destination": "__main__.__execute__", - "type": "alias" - }, - "__wrappers__.__execute___encode_return": { - "decorators": [], - "pc": 680, - "type": "function" - }, - "__wrappers__.__execute___encode_return.Args": { - "full_name": "__wrappers__.__execute___encode_return.Args", - "members": { - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "ret_value": { - "cairo_type": "(response_len: felt, response: felt*)", - "offset": 0 - } - }, - "size": 3, - "type": "struct" - }, - "__wrappers__.__execute___encode_return.ImplicitArgs": { - "full_name": "__wrappers__.__execute___encode_return.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__execute___encode_return.Return": { - "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", - "type": "type_definition" - }, - "__wrappers__.__execute___encode_return.SIZEOF_LOCALS": { - "type": "const", - "value": 3 - }, - "__wrappers__.__execute___encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__wrappers__.__validate__": { - "decorators": ["external"], - "pc": 548, - "type": "function" - }, - "__wrappers__.__validate__.Args": { - "full_name": "__wrappers__.__validate__.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__validate__.ImplicitArgs": { - "full_name": "__wrappers__.__validate__.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__validate__.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: felt, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.__validate__.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__wrappers__.__validate__.__wrapped_func": { - "destination": "__main__.__validate__", - "type": "alias" - }, - "__wrappers__.__validate___encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__wrappers__.__validate_declare__": { - "decorators": ["external"], - "pc": 607, - "type": "function" - }, - "__wrappers__.__validate_declare__.Args": { - "full_name": "__wrappers__.__validate_declare__.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__validate_declare__.ImplicitArgs": { - "full_name": "__wrappers__.__validate_declare__.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__validate_declare__.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: felt, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.__validate_declare__.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "__wrappers__.__validate_declare__.__wrapped_func": { - "destination": "__main__.__validate_declare__", - "type": "alias" - }, - "__wrappers__.__validate_declare___encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__wrappers__.__validate_deploy__": { - "decorators": ["external"], - "pc": 645, - "type": "function" - }, - "__wrappers__.__validate_deploy__.Args": { - "full_name": "__wrappers__.__validate_deploy__.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__validate_deploy__.ImplicitArgs": { - "full_name": "__wrappers__.__validate_deploy__.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.__validate_deploy__.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: felt, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.__validate_deploy__.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "__wrappers__.__validate_deploy__.__wrapped_func": { - "destination": "__main__.__validate_deploy__", - "type": "alias" - }, - "__wrappers__.__validate_deploy___encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__wrappers__.constructor": { - "decorators": ["constructor"], - "pc": 366, - "type": "function" - }, - "__wrappers__.constructor.Args": { - "full_name": "__wrappers__.constructor.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.constructor.ImplicitArgs": { - "full_name": "__wrappers__.constructor.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.constructor.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: felt, bitwise_ptr: felt, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.constructor.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__wrappers__.constructor.__wrapped_func": { - "destination": "__main__.constructor", - "type": "alias" - }, - "__wrappers__.constructor_encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__wrappers__.getPublicKey": { - "decorators": ["view"], - "pc": 401, - "type": "function" - }, - "__wrappers__.getPublicKey.Args": { - "full_name": "__wrappers__.getPublicKey.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.getPublicKey.ImplicitArgs": { - "full_name": "__wrappers__.getPublicKey.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.getPublicKey.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: felt, bitwise_ptr: felt, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.getPublicKey.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__wrappers__.getPublicKey.__wrapped_func": { - "destination": "__main__.getPublicKey", - "type": "alias" - }, - "__wrappers__.getPublicKey_encode_return": { - "decorators": [], - "pc": 392, - "type": "function" - }, - "__wrappers__.getPublicKey_encode_return.Args": { - "full_name": "__wrappers__.getPublicKey_encode_return.Args", - "members": { - "range_check_ptr": { "cairo_type": "felt", "offset": 1 }, - "ret_value": { "cairo_type": "(publicKey: felt)", "offset": 0 } - }, - "size": 2, - "type": "struct" - }, - "__wrappers__.getPublicKey_encode_return.ImplicitArgs": { - "full_name": "__wrappers__.getPublicKey_encode_return.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.getPublicKey_encode_return.Return": { - "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", - "type": "type_definition" - }, - "__wrappers__.getPublicKey_encode_return.SIZEOF_LOCALS": { - "type": "const", - "value": 1 - }, - "__wrappers__.getPublicKey_encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__wrappers__.isValidSignature": { - "decorators": ["view"], - "pc": 500, - "type": "function" - }, - "__wrappers__.isValidSignature.Args": { - "full_name": "__wrappers__.isValidSignature.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.isValidSignature.ImplicitArgs": { - "full_name": "__wrappers__.isValidSignature.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.isValidSignature.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: felt, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.isValidSignature.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "__wrappers__.isValidSignature.__wrapped_func": { - "destination": "__main__.isValidSignature", - "type": "alias" - }, - "__wrappers__.isValidSignature_encode_return": { - "decorators": [], - "pc": 491, - "type": "function" - }, - "__wrappers__.isValidSignature_encode_return.Args": { - "full_name": "__wrappers__.isValidSignature_encode_return.Args", - "members": { - "range_check_ptr": { "cairo_type": "felt", "offset": 1 }, - "ret_value": { "cairo_type": "(isValid: felt)", "offset": 0 } - }, - "size": 2, - "type": "struct" - }, - "__wrappers__.isValidSignature_encode_return.ImplicitArgs": { - "full_name": "__wrappers__.isValidSignature_encode_return.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.isValidSignature_encode_return.Return": { - "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", - "type": "type_definition" - }, - "__wrappers__.isValidSignature_encode_return.SIZEOF_LOCALS": { - "type": "const", - "value": 1 - }, - "__wrappers__.isValidSignature_encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__wrappers__.setPublicKey": { - "decorators": ["external"], - "pc": 461, - "type": "function" - }, - "__wrappers__.setPublicKey.Args": { - "full_name": "__wrappers__.setPublicKey.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.setPublicKey.ImplicitArgs": { - "full_name": "__wrappers__.setPublicKey.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.setPublicKey.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: felt, bitwise_ptr: felt, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.setPublicKey.SIZEOF_LOCALS": { "type": "const", "value": 0 }, - "__wrappers__.setPublicKey.__wrapped_func": { - "destination": "__main__.setPublicKey", - "type": "alias" - }, - "__wrappers__.setPublicKey_encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__wrappers__.supportsInterface": { - "decorators": ["view"], - "pc": 434, - "type": "function" - }, - "__wrappers__.supportsInterface.Args": { - "full_name": "__wrappers__.supportsInterface.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.supportsInterface.ImplicitArgs": { - "full_name": "__wrappers__.supportsInterface.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.supportsInterface.Return": { - "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: felt, bitwise_ptr: felt, size: felt, retdata: felt*)", - "type": "type_definition" - }, - "__wrappers__.supportsInterface.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "__wrappers__.supportsInterface.__wrapped_func": { - "destination": "__main__.supportsInterface", - "type": "alias" - }, - "__wrappers__.supportsInterface_encode_return": { - "decorators": [], - "pc": 425, - "type": "function" - }, - "__wrappers__.supportsInterface_encode_return.Args": { - "full_name": "__wrappers__.supportsInterface_encode_return.Args", - "members": { - "range_check_ptr": { "cairo_type": "felt", "offset": 1 }, - "ret_value": { "cairo_type": "(success: felt)", "offset": 0 } - }, - "size": 2, - "type": "struct" - }, - "__wrappers__.supportsInterface_encode_return.ImplicitArgs": { - "full_name": "__wrappers__.supportsInterface_encode_return.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "__wrappers__.supportsInterface_encode_return.Return": { - "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", - "type": "type_definition" - }, - "__wrappers__.supportsInterface_encode_return.SIZEOF_LOCALS": { - "type": "const", - "value": 1 - }, - "__wrappers__.supportsInterface_encode_return.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "openzeppelin.account.library.Account": { "type": "namespace" }, - "openzeppelin.account.library.Account.Args": { - "full_name": "openzeppelin.account.library.Account.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "openzeppelin.account.library.Account.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "openzeppelin.account.library.Account.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "openzeppelin.account.library.Account.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account._execute_list": { - "decorators": [], - "pc": 301, - "type": "function" - }, - "openzeppelin.account.library.Account._execute_list.Args": { - "full_name": "openzeppelin.account.library.Account._execute_list.Args", - "members": { - "calls": { - "cairo_type": "openzeppelin.account.library.Call*", - "offset": 1 - }, - "calls_len": { "cairo_type": "felt", "offset": 0 }, - "response": { "cairo_type": "felt*", "offset": 2 } - }, - "size": 3, - "type": "struct" - }, - "openzeppelin.account.library.Account._execute_list.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account._execute_list.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "openzeppelin.account.library.Account._execute_list.Return": { - "cairo_type": "(response_len: felt)", - "type": "type_definition" - }, - "openzeppelin.account.library.Account._execute_list.SIZEOF_LOCALS": { - "type": "const", - "value": 3 - }, - "openzeppelin.account.library.Account._from_call_array_to_call": { - "decorators": [], - "pc": 335, - "type": "function" - }, - "openzeppelin.account.library.Account._from_call_array_to_call.Args": { - "full_name": "openzeppelin.account.library.Account._from_call_array_to_call.Args", - "members": { - "call_array": { - "cairo_type": "openzeppelin.account.library.AccountCallArray*", - "offset": 1 - }, - "call_array_len": { "cairo_type": "felt", "offset": 0 }, - "calldata": { "cairo_type": "felt*", "offset": 2 }, - "calls": { - "cairo_type": "openzeppelin.account.library.Call*", - "offset": 3 - } - }, - "size": 4, - "type": "struct" - }, - "openzeppelin.account.library.Account._from_call_array_to_call.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account._from_call_array_to_call.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "openzeppelin.account.library.Account._from_call_array_to_call.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "openzeppelin.account.library.Account._from_call_array_to_call.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account.assert_only_self": { - "decorators": [], - "pc": 185, - "type": "function" - }, - "openzeppelin.account.library.Account.assert_only_self.Args": { - "full_name": "openzeppelin.account.library.Account.assert_only_self.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "openzeppelin.account.library.Account.assert_only_self.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account.assert_only_self.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "openzeppelin.account.library.Account.assert_only_self.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "openzeppelin.account.library.Account.assert_only_self.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account.execute": { - "decorators": [], - "pc": 254, - "type": "function" - }, - "openzeppelin.account.library.Account.execute.Args": { - "full_name": "openzeppelin.account.library.Account.execute.Args", - "members": { - "call_array": { - "cairo_type": "openzeppelin.account.library.AccountCallArray*", - "offset": 1 - }, - "call_array_len": { "cairo_type": "felt", "offset": 0 }, - "calldata": { "cairo_type": "felt*", "offset": 3 }, - "calldata_len": { "cairo_type": "felt", "offset": 2 } - }, - "size": 4, - "type": "struct" - }, - "openzeppelin.account.library.Account.execute.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account.execute.ImplicitArgs", - "members": { - "bitwise_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin*", - "offset": 3 - }, - "ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "offset": 2 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 4 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 5, - "type": "struct" - }, - "openzeppelin.account.library.Account.execute.Return": { - "cairo_type": "(response_len: felt, response: felt*)", - "type": "type_definition" - }, - "openzeppelin.account.library.Account.execute.SIZEOF_LOCALS": { - "type": "const", - "value": 3 - }, - "openzeppelin.account.library.Account.get_public_key": { - "decorators": [], - "pc": 194, - "type": "function" - }, - "openzeppelin.account.library.Account.get_public_key.Args": { - "full_name": "openzeppelin.account.library.Account.get_public_key.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "openzeppelin.account.library.Account.get_public_key.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account.get_public_key.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "openzeppelin.account.library.Account.get_public_key.Return": { - "cairo_type": "(public_key: felt)", - "type": "type_definition" - }, - "openzeppelin.account.library.Account.get_public_key.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account.initializer": { - "decorators": [], - "pc": 178, - "type": "function" - }, - "openzeppelin.account.library.Account.initializer.Args": { - "full_name": "openzeppelin.account.library.Account.initializer.Args", - "members": { "_public_key": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "openzeppelin.account.library.Account.initializer.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account.initializer.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "openzeppelin.account.library.Account.initializer.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "openzeppelin.account.library.Account.initializer.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account.is_valid_signature": { - "decorators": [], - "pc": 235, - "type": "function" - }, - "openzeppelin.account.library.Account.is_valid_signature.Args": { - "full_name": "openzeppelin.account.library.Account.is_valid_signature.Args", - "members": { - "hash": { "cairo_type": "felt", "offset": 0 }, - "signature": { "cairo_type": "felt*", "offset": 2 }, - "signature_len": { "cairo_type": "felt", "offset": 1 } - }, - "size": 3, - "type": "struct" - }, - "openzeppelin.account.library.Account.is_valid_signature.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account.is_valid_signature.ImplicitArgs", - "members": { - "ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "offset": 2 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 3 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 4, - "type": "struct" - }, - "openzeppelin.account.library.Account.is_valid_signature.Return": { - "cairo_type": "(is_valid: felt)", - "type": "type_definition" - }, - "openzeppelin.account.library.Account.is_valid_signature.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account.set_public_key": { - "decorators": [], - "pc": 226, - "type": "function" - }, - "openzeppelin.account.library.Account.set_public_key.Args": { - "full_name": "openzeppelin.account.library.Account.set_public_key.Args", - "members": { "new_public_key": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "openzeppelin.account.library.Account.set_public_key.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account.set_public_key.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "openzeppelin.account.library.Account.set_public_key.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "openzeppelin.account.library.Account.set_public_key.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account.supports_interface": { - "decorators": [], - "pc": 200, - "type": "function" - }, - "openzeppelin.account.library.Account.supports_interface.Args": { - "full_name": "openzeppelin.account.library.Account.supports_interface.Args", - "members": { "interface_id": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "openzeppelin.account.library.Account.supports_interface.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account.supports_interface.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "openzeppelin.account.library.Account.supports_interface.Return": { - "cairo_type": "(success: felt)", - "type": "type_definition" - }, - "openzeppelin.account.library.Account.supports_interface.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.AccountCallArray": { - "full_name": "openzeppelin.account.library.AccountCallArray", - "members": { - "data_len": { "cairo_type": "felt", "offset": 3 }, - "data_offset": { "cairo_type": "felt", "offset": 2 }, - "selector": { "cairo_type": "felt", "offset": 1 }, - "to": { "cairo_type": "felt", "offset": 0 } - }, - "size": 4, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key": { "type": "namespace" }, - "openzeppelin.account.library.Account_public_key.Args": { - "full_name": "openzeppelin.account.library.Account_public_key.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "openzeppelin.account.library.Account_public_key.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account_public_key.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "openzeppelin.account.library.Account_public_key.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account_public_key.addr": { - "decorators": [], - "pc": 148, - "type": "function" - }, - "openzeppelin.account.library.Account_public_key.addr.Args": { - "full_name": "openzeppelin.account.library.Account_public_key.addr.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key.addr.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account_public_key.addr.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 0 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 1 } - }, - "size": 2, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key.addr.Return": { - "cairo_type": "(res: felt)", - "type": "type_definition" - }, - "openzeppelin.account.library.Account_public_key.addr.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account_public_key.hash2": { - "destination": "starkware.cairo.common.hash.hash2", - "type": "alias" - }, - "openzeppelin.account.library.Account_public_key.normalize_address": { - "destination": "starkware.starknet.common.storage.normalize_address", - "type": "alias" - }, - "openzeppelin.account.library.Account_public_key.read": { - "decorators": [], - "pc": 153, - "type": "function" - }, - "openzeppelin.account.library.Account_public_key.read.Args": { - "full_name": "openzeppelin.account.library.Account_public_key.read.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key.read.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account_public_key.read.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key.read.Return": { - "cairo_type": "(public_key: felt)", - "type": "type_definition" - }, - "openzeppelin.account.library.Account_public_key.read.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.Account_public_key.storage_read": { - "destination": "starkware.starknet.common.syscalls.storage_read", - "type": "alias" - }, - "openzeppelin.account.library.Account_public_key.storage_write": { - "destination": "starkware.starknet.common.syscalls.storage_write", - "type": "alias" - }, - "openzeppelin.account.library.Account_public_key.write": { - "decorators": [], - "pc": 166, - "type": "function" - }, - "openzeppelin.account.library.Account_public_key.write.Args": { - "full_name": "openzeppelin.account.library.Account_public_key.write.Args", - "members": { "value": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key.write.ImplicitArgs": { - "full_name": "openzeppelin.account.library.Account_public_key.write.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "range_check_ptr": { "cairo_type": "felt", "offset": 2 }, - "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "openzeppelin.account.library.Account_public_key.write.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "openzeppelin.account.library.Account_public_key.write.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "openzeppelin.account.library.BitwiseBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "type": "alias" - }, - "openzeppelin.account.library.Call": { - "full_name": "openzeppelin.account.library.Call", - "members": { - "calldata": { "cairo_type": "felt*", "offset": 3 }, - "calldata_len": { "cairo_type": "felt", "offset": 2 }, - "selector": { "cairo_type": "felt", "offset": 1 }, - "to": { "cairo_type": "felt", "offset": 0 } - }, - "size": 4, - "type": "struct" - }, - "openzeppelin.account.library.FALSE": { - "destination": "starkware.cairo.common.bool.FALSE", - "type": "alias" - }, - "openzeppelin.account.library.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "openzeppelin.account.library.IACCOUNT_ID": { - "destination": "openzeppelin.utils.constants.library.IACCOUNT_ID", - "type": "alias" - }, - "openzeppelin.account.library.IERC165_ID": { - "destination": "openzeppelin.utils.constants.library.IERC165_ID", - "type": "alias" - }, - "openzeppelin.account.library.SignatureBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", - "type": "alias" - }, - "openzeppelin.account.library.TRANSACTION_VERSION": { - "destination": "openzeppelin.utils.constants.library.TRANSACTION_VERSION", - "type": "alias" - }, - "openzeppelin.account.library.TRUE": { - "destination": "starkware.cairo.common.bool.TRUE", - "type": "alias" - }, - "openzeppelin.account.library.Uint256": { - "destination": "starkware.cairo.common.uint256.Uint256", - "type": "alias" - }, - "openzeppelin.account.library.alloc": { - "destination": "starkware.cairo.common.alloc.alloc", - "type": "alias" - }, - "openzeppelin.account.library.call_contract": { - "destination": "starkware.starknet.common.syscalls.call_contract", - "type": "alias" - }, - "openzeppelin.account.library.get_caller_address": { - "destination": "starkware.starknet.common.syscalls.get_caller_address", - "type": "alias" - }, - "openzeppelin.account.library.get_contract_address": { - "destination": "starkware.starknet.common.syscalls.get_contract_address", - "type": "alias" - }, - "openzeppelin.account.library.get_fp_and_pc": { - "destination": "starkware.cairo.common.registers.get_fp_and_pc", - "type": "alias" - }, - "openzeppelin.account.library.get_tx_info": { - "destination": "starkware.starknet.common.syscalls.get_tx_info", - "type": "alias" - }, - "openzeppelin.account.library.is_le_felt": { - "destination": "starkware.cairo.common.math_cmp.is_le_felt", - "type": "alias" - }, - "openzeppelin.account.library.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "openzeppelin.account.library.split_felt": { - "destination": "starkware.cairo.common.math.split_felt", - "type": "alias" - }, - "openzeppelin.account.library.verify_ecdsa_signature": { - "destination": "starkware.cairo.common.signature.verify_ecdsa_signature", - "type": "alias" - }, - "openzeppelin.account.library.verify_eth_signature_uint256": { - "destination": "starkware.cairo.common.cairo_secp.signature.verify_eth_signature_uint256", - "type": "alias" - }, - "openzeppelin.utils.constants.library.DEFAULT_ADMIN_ROLE": { - "type": "const", - "value": 0 - }, - "openzeppelin.utils.constants.library.IACCESSCONTROL_ID": { - "type": "const", - "value": 2036718347 - }, - "openzeppelin.utils.constants.library.IACCOUNT_ID": { - "type": "const", - "value": 2792084853 - }, - "openzeppelin.utils.constants.library.IERC165_ID": { - "type": "const", - "value": 33540519 - }, - "openzeppelin.utils.constants.library.IERC721_ENUMERABLE_ID": { - "type": "const", - "value": 2014223715 - }, - "openzeppelin.utils.constants.library.IERC721_ID": { - "type": "const", - "value": 2158778573 - }, - "openzeppelin.utils.constants.library.IERC721_METADATA_ID": { - "type": "const", - "value": 1532892063 - }, - "openzeppelin.utils.constants.library.IERC721_RECEIVER_ID": { - "type": "const", - "value": 353073666 - }, - "openzeppelin.utils.constants.library.INVALID_ID": { - "type": "const", - "value": 4294967295 - }, - "openzeppelin.utils.constants.library.TRANSACTION_VERSION": { - "type": "const", - "value": 1 - }, - "openzeppelin.utils.constants.library.UINT8_MAX": { - "type": "const", - "value": 255 - }, - "starkware.cairo.common.alloc.alloc": { - "decorators": [], - "pc": 0, - "type": "function" - }, - "starkware.cairo.common.alloc.alloc.Args": { - "full_name": "starkware.cairo.common.alloc.alloc.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.common.alloc.alloc.ImplicitArgs": { - "full_name": "starkware.cairo.common.alloc.alloc.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.common.alloc.alloc.Return": { - "cairo_type": "(ptr: felt*)", - "type": "type_definition" - }, - "starkware.cairo.common.alloc.alloc.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.bitwise.ALL_ONES": { - "type": "const", - "value": -106710729501573572985208420194530329073740042555888586719234 - }, - "starkware.cairo.common.bitwise.BitwiseBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "type": "alias" - }, - "starkware.cairo.common.bool.FALSE": { "type": "const", "value": 0 }, - "starkware.cairo.common.bool.TRUE": { "type": "const", "value": 1 }, - "starkware.cairo.common.cairo_builtins.BitwiseBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "members": { - "x": { "cairo_type": "felt", "offset": 0 }, - "x_and_y": { "cairo_type": "felt", "offset": 2 }, - "x_or_y": { "cairo_type": "felt", "offset": 4 }, - "x_xor_y": { "cairo_type": "felt", "offset": 3 }, - "y": { "cairo_type": "felt", "offset": 1 } - }, - "size": 5, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.EcOpBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", - "members": { - "m": { "cairo_type": "felt", "offset": 4 }, - "p": { - "cairo_type": "starkware.cairo.common.ec_point.EcPoint", - "offset": 0 - }, - "q": { - "cairo_type": "starkware.cairo.common.ec_point.EcPoint", - "offset": 2 - }, - "r": { - "cairo_type": "starkware.cairo.common.ec_point.EcPoint", - "offset": 5 - } - }, - "size": 7, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.EcPoint": { - "destination": "starkware.cairo.common.ec_point.EcPoint", - "type": "alias" - }, - "starkware.cairo.common.cairo_builtins.HashBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "members": { - "result": { "cairo_type": "felt", "offset": 2 }, - "x": { "cairo_type": "felt", "offset": 0 }, - "y": { "cairo_type": "felt", "offset": 1 } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.KeccakBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.KeccakBuiltin", - "members": { - "input": { - "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", - "offset": 0 - }, - "output": { - "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", - "offset": 8 - } - }, - "size": 16, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.KeccakBuiltinState": { - "destination": "starkware.cairo.common.keccak_state.KeccakBuiltinState", - "type": "alias" - }, - "starkware.cairo.common.cairo_builtins.SignatureBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", - "members": { - "message": { "cairo_type": "felt", "offset": 1 }, - "pub_key": { "cairo_type": "felt", "offset": 0 } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.cairo_keccak.keccak.BLOCK_SIZE": { - "destination": "starkware.cairo.common.cairo_keccak.packed_keccak.BLOCK_SIZE", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.BYTES_IN_WORD": { - "type": "const", - "value": 8 - }, - "starkware.cairo.common.cairo_keccak.keccak.BitwiseBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.KECCAK_CAPACITY_IN_WORDS": { - "type": "const", - "value": 8 - }, - "starkware.cairo.common.cairo_keccak.keccak.KECCAK_FULL_RATE_IN_BYTES": { - "type": "const", - "value": 136 - }, - "starkware.cairo.common.cairo_keccak.keccak.KECCAK_FULL_RATE_IN_WORDS": { - "type": "const", - "value": 17 - }, - "starkware.cairo.common.cairo_keccak.keccak.KECCAK_STATE_SIZE_FELTS": { - "type": "const", - "value": 25 - }, - "starkware.cairo.common.cairo_keccak.keccak.Uint256": { - "destination": "starkware.cairo.common.uint256.Uint256", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.alloc": { - "destination": "starkware.cairo.common.alloc.alloc", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.assert_lt": { - "destination": "starkware.cairo.common.math.assert_lt", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.assert_nn": { - "destination": "starkware.cairo.common.math.assert_nn", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.assert_nn_le": { - "destination": "starkware.cairo.common.math.assert_nn_le", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.assert_not_zero": { - "destination": "starkware.cairo.common.math.assert_not_zero", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.bitwise_and": { - "destination": "starkware.cairo.common.bitwise.bitwise_and", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.bitwise_or": { - "destination": "starkware.cairo.common.bitwise.bitwise_or", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.bitwise_xor": { - "destination": "starkware.cairo.common.bitwise.bitwise_xor", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.memset": { - "destination": "starkware.cairo.common.memset.memset", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.packed_keccak_func": { - "destination": "starkware.cairo.common.cairo_keccak.packed_keccak.packed_keccak_func", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.pow": { - "destination": "starkware.cairo.common.pow.pow", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.split_felt": { - "destination": "starkware.cairo.common.math.split_felt", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.uint256_reverse_endian": { - "destination": "starkware.cairo.common.uint256.uint256_reverse_endian", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.keccak.unsigned_div_rem": { - "destination": "starkware.cairo.common.math.unsigned_div_rem", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.packed_keccak.ALL_ONES": { - "type": "const", - "value": -106710729501573572985208420194530329073740042555888586719234 - }, - "starkware.cairo.common.cairo_keccak.packed_keccak.BLOCK_SIZE": { - "type": "const", - "value": 3 - }, - "starkware.cairo.common.cairo_keccak.packed_keccak.BitwiseBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.packed_keccak.SHIFTS": { - "type": "const", - "value": 340282366920938463481821351505477763073 - }, - "starkware.cairo.common.cairo_keccak.packed_keccak.alloc": { - "destination": "starkware.cairo.common.alloc.alloc", - "type": "alias" - }, - "starkware.cairo.common.cairo_keccak.packed_keccak.get_fp_and_pc": { - "destination": "starkware.cairo.common.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.bigint.BASE": { - "destination": "starkware.cairo.common.cairo_secp.constants.BASE", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.bigint.BigInt3": { - "full_name": "starkware.cairo.common.cairo_secp.bigint.BigInt3", - "members": { - "d0": { "cairo_type": "felt", "offset": 0 }, - "d1": { "cairo_type": "felt", "offset": 1 }, - "d2": { "cairo_type": "felt", "offset": 2 } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.cairo_secp.bigint.RC_BOUND": { - "destination": "starkware.cairo.common.math_cmp.RC_BOUND", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.bigint.Uint256": { - "destination": "starkware.cairo.common.uint256.Uint256", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3": { - "full_name": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3", - "members": { - "d0": { "cairo_type": "felt", "offset": 0 }, - "d1": { "cairo_type": "felt", "offset": 1 }, - "d2": { "cairo_type": "felt", "offset": 2 } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt5": { - "full_name": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt5", - "members": { - "d0": { "cairo_type": "felt", "offset": 0 }, - "d1": { "cairo_type": "felt", "offset": 1 }, - "d2": { "cairo_type": "felt", "offset": 2 }, - "d3": { "cairo_type": "felt", "offset": 3 }, - "d4": { "cairo_type": "felt", "offset": 4 } - }, - "size": 5, - "type": "struct" - }, - "starkware.cairo.common.cairo_secp.bigint.assert_nn": { - "destination": "starkware.cairo.common.math.assert_nn", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.bigint.assert_nn_le": { - "destination": "starkware.cairo.common.math.assert_nn_le", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.bigint.unsigned_div_rem": { - "destination": "starkware.cairo.common.math.unsigned_div_rem", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.constants.BASE": { - "type": "const", - "value": 77371252455336267181195264 - }, - "starkware.cairo.common.cairo_secp.constants.BETA": { - "type": "const", - "value": 7 - }, - "starkware.cairo.common.cairo_secp.constants.N0": { - "type": "const", - "value": 10428087374290690730508609 - }, - "starkware.cairo.common.cairo_secp.constants.N1": { - "type": "const", - "value": 77371252455330678278691517 - }, - "starkware.cairo.common.cairo_secp.constants.N2": { - "type": "const", - "value": 19342813113834066795298815 - }, - "starkware.cairo.common.cairo_secp.constants.P0": { - "type": "const", - "value": 77371252455336262886226991 - }, - "starkware.cairo.common.cairo_secp.constants.P1": { - "type": "const", - "value": 77371252455336267181195263 - }, - "starkware.cairo.common.cairo_secp.constants.P2": { - "type": "const", - "value": 19342813113834066795298815 - }, - "starkware.cairo.common.cairo_secp.constants.SECP_REM": { - "type": "const", - "value": 4294968273 - }, - "starkware.cairo.common.cairo_secp.ec.BigInt3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.BigInt3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.ec.EcPoint": { - "full_name": "starkware.cairo.common.cairo_secp.ec.EcPoint", - "members": { - "x": { - "cairo_type": "starkware.cairo.common.cairo_secp.bigint.BigInt3", - "offset": 0 - }, - "y": { - "cairo_type": "starkware.cairo.common.cairo_secp.bigint.BigInt3", - "offset": 3 - } - }, - "size": 6, - "type": "struct" - }, - "starkware.cairo.common.cairo_secp.ec.UnreducedBigInt3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.ec.is_zero": { - "destination": "starkware.cairo.common.cairo_secp.field.is_zero", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.ec.nondet_bigint3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.nondet_bigint3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.ec.unreduced_mul": { - "destination": "starkware.cairo.common.cairo_secp.field.unreduced_mul", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.ec.unreduced_sqr": { - "destination": "starkware.cairo.common.cairo_secp.field.unreduced_sqr", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.ec.verify_zero": { - "destination": "starkware.cairo.common.cairo_secp.field.verify_zero", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.BASE": { - "destination": "starkware.cairo.common.cairo_secp.constants.BASE", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.BigInt3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.BigInt3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.P0": { - "destination": "starkware.cairo.common.cairo_secp.constants.P0", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.P1": { - "destination": "starkware.cairo.common.cairo_secp.constants.P1", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.P2": { - "destination": "starkware.cairo.common.cairo_secp.constants.P2", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.SECP_REM": { - "destination": "starkware.cairo.common.cairo_secp.constants.SECP_REM", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.UnreducedBigInt3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.assert_nn_le": { - "destination": "starkware.cairo.common.math.assert_nn_le", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.field.nondet_bigint3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.nondet_bigint3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.BASE": { - "destination": "starkware.cairo.common.cairo_secp.bigint.BASE", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.BETA": { - "destination": "starkware.cairo.common.cairo_secp.constants.BETA", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.BigInt3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.BigInt3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.BitwiseBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.EcPoint": { - "destination": "starkware.cairo.common.cairo_secp.ec.EcPoint", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.N0": { - "destination": "starkware.cairo.common.cairo_secp.constants.N0", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.N1": { - "destination": "starkware.cairo.common.cairo_secp.constants.N1", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.N2": { - "destination": "starkware.cairo.common.cairo_secp.constants.N2", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.RC_BOUND": { - "destination": "starkware.cairo.common.math_cmp.RC_BOUND", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.Uint256": { - "destination": "starkware.cairo.common.uint256.Uint256", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.UnreducedBigInt3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.alloc": { - "destination": "starkware.cairo.common.alloc.alloc", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.assert_nn": { - "destination": "starkware.cairo.common.math.assert_nn", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.assert_nn_le": { - "destination": "starkware.cairo.common.math.assert_nn_le", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.assert_not_zero": { - "destination": "starkware.cairo.common.math.assert_not_zero", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.bigint_mul": { - "destination": "starkware.cairo.common.cairo_secp.bigint.bigint_mul", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.bigint_to_uint256": { - "destination": "starkware.cairo.common.cairo_secp.bigint.bigint_to_uint256", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.ec_add": { - "destination": "starkware.cairo.common.cairo_secp.ec.ec_add", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.ec_mul": { - "destination": "starkware.cairo.common.cairo_secp.ec.ec_mul", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.ec_negate": { - "destination": "starkware.cairo.common.cairo_secp.ec.ec_negate", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.finalize_keccak": { - "destination": "starkware.cairo.common.cairo_keccak.keccak.finalize_keccak", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.keccak_uint256s_bigend": { - "destination": "starkware.cairo.common.cairo_keccak.keccak.keccak_uint256s_bigend", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.nondet_bigint3": { - "destination": "starkware.cairo.common.cairo_secp.bigint.nondet_bigint3", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.reduce": { - "destination": "starkware.cairo.common.cairo_secp.field.reduce", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.uint256_to_bigint": { - "destination": "starkware.cairo.common.cairo_secp.bigint.uint256_to_bigint", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.unreduced_mul": { - "destination": "starkware.cairo.common.cairo_secp.field.unreduced_mul", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.unreduced_sqr": { - "destination": "starkware.cairo.common.cairo_secp.field.unreduced_sqr", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.unsigned_div_rem": { - "destination": "starkware.cairo.common.math.unsigned_div_rem", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.validate_reduced_field_element": { - "destination": "starkware.cairo.common.cairo_secp.field.validate_reduced_field_element", - "type": "alias" - }, - "starkware.cairo.common.cairo_secp.signature.verify_zero": { - "destination": "starkware.cairo.common.cairo_secp.field.verify_zero", - "type": "alias" - }, - "starkware.cairo.common.dict_access.DictAccess": { - "full_name": "starkware.cairo.common.dict_access.DictAccess", - "members": { - "key": { "cairo_type": "felt", "offset": 0 }, - "new_value": { "cairo_type": "felt", "offset": 2 }, - "prev_value": { "cairo_type": "felt", "offset": 1 } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.ec.EcOpBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", - "type": "alias" - }, - "starkware.cairo.common.ec.EcPoint": { - "destination": "starkware.cairo.common.ec_point.EcPoint", - "type": "alias" - }, - "starkware.cairo.common.ec.StarkCurve": { "type": "namespace" }, - "starkware.cairo.common.ec.StarkCurve.ALPHA": { "type": "const", "value": 1 }, - "starkware.cairo.common.ec.StarkCurve.Args": { - "full_name": "starkware.cairo.common.ec.StarkCurve.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.common.ec.StarkCurve.BETA": { - "type": "const", - "value": -476910135076337975234679399815567221425937815956490878998147463828055613816 - }, - "starkware.cairo.common.ec.StarkCurve.GEN_X": { - "type": "const", - "value": 874739451078007766457464989774322083649278607533249481151382481072868806602 - }, - "starkware.cairo.common.ec.StarkCurve.GEN_Y": { - "type": "const", - "value": 152666792071518830868575557812948353041420400780739481342941381225525861407 - }, - "starkware.cairo.common.ec.StarkCurve.ImplicitArgs": { - "full_name": "starkware.cairo.common.ec.StarkCurve.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.common.ec.StarkCurve.ORDER": { - "type": "const", - "value": -96363463615509210819012598251359154898 - }, - "starkware.cairo.common.ec.StarkCurve.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.ec.StarkCurve.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.ec.is_quad_residue": { - "destination": "starkware.cairo.common.math.is_quad_residue", - "type": "alias" - }, - "starkware.cairo.common.ec_point.EcPoint": { - "full_name": "starkware.cairo.common.ec_point.EcPoint", - "members": { - "x": { "cairo_type": "felt", "offset": 0 }, - "y": { "cairo_type": "felt", "offset": 1 } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.hash.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "starkware.cairo.common.keccak_state.KeccakBuiltinState": { - "full_name": "starkware.cairo.common.keccak_state.KeccakBuiltinState", - "members": { - "s0": { "cairo_type": "felt", "offset": 0 }, - "s1": { "cairo_type": "felt", "offset": 1 }, - "s2": { "cairo_type": "felt", "offset": 2 }, - "s3": { "cairo_type": "felt", "offset": 3 }, - "s4": { "cairo_type": "felt", "offset": 4 }, - "s5": { "cairo_type": "felt", "offset": 5 }, - "s6": { "cairo_type": "felt", "offset": 6 }, - "s7": { "cairo_type": "felt", "offset": 7 } - }, - "size": 8, - "type": "struct" - }, - "starkware.cairo.common.math.FALSE": { - "destination": "starkware.cairo.common.bool.FALSE", - "type": "alias" - }, - "starkware.cairo.common.math.TRUE": { - "destination": "starkware.cairo.common.bool.TRUE", - "type": "alias" - }, - "starkware.cairo.common.math.assert_le_felt": { - "decorators": ["known_ap_change"], - "pc": 18, - "type": "function" - }, - "starkware.cairo.common.math.assert_le_felt.Args": { - "full_name": "starkware.cairo.common.math.assert_le_felt.Args", - "members": { - "a": { "cairo_type": "felt", "offset": 0 }, - "b": { "cairo_type": "felt", "offset": 1 } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.math.assert_le_felt.ImplicitArgs": { - "full_name": "starkware.cairo.common.math.assert_le_felt.ImplicitArgs", - "members": { "range_check_ptr": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.math.assert_le_felt.PRIME_OVER_2_HIGH": { - "type": "const", - "value": 5316911983139663648412552867652567041 - }, - "starkware.cairo.common.math.assert_le_felt.PRIME_OVER_3_HIGH": { - "type": "const", - "value": 3544607988759775765608368578435044694 - }, - "starkware.cairo.common.math.assert_le_felt.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.math.assert_le_felt.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.math.assert_le_felt.a": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_le_felt.a", - "references": [ - { - "ap_tracking_data": { "group": 2, "offset": 0 }, - "pc": 18, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_le_felt.b": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_le_felt.b", - "references": [ - { - "ap_tracking_data": { "group": 2, "offset": 0 }, - "pc": 18, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_le_felt.range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_le_felt.range_check_ptr", - "references": [ - { - "ap_tracking_data": { "group": 2, "offset": 0 }, - "pc": 18, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { "group": 2, "offset": 8 }, - "pc": 28, - "value": "cast([fp + (-5)] + 4, felt)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_le_felt.skip_exclude_a": { - "pc": 42, - "type": "label" - }, - "starkware.cairo.common.math.assert_le_felt.skip_exclude_b_minus_a": { - "pc": 54, - "type": "label" - }, - "starkware.cairo.common.math.assert_lt_felt": { - "decorators": ["known_ap_change"], - "pc": 63, - "type": "function" - }, - "starkware.cairo.common.math.assert_lt_felt.Args": { - "full_name": "starkware.cairo.common.math.assert_lt_felt.Args", - "members": { - "a": { "cairo_type": "felt", "offset": 0 }, - "b": { "cairo_type": "felt", "offset": 1 } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.math.assert_lt_felt.ImplicitArgs": { - "full_name": "starkware.cairo.common.math.assert_lt_felt.ImplicitArgs", - "members": { "range_check_ptr": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.math.assert_lt_felt.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.math.assert_lt_felt.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.math.assert_lt_felt.a": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_lt_felt.a", - "references": [ - { - "ap_tracking_data": { "group": 3, "offset": 0 }, - "pc": 63, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_lt_felt.b": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_lt_felt.b", - "references": [ - { - "ap_tracking_data": { "group": 3, "offset": 0 }, - "pc": 63, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math_cmp.RC_BOUND": { - "type": "const", - "value": 340282366920938463463374607431768211456 - }, - "starkware.cairo.common.math_cmp.assert_le_felt": { - "destination": "starkware.cairo.common.math.assert_le_felt", - "type": "alias" - }, - "starkware.cairo.common.math_cmp.assert_lt_felt": { - "destination": "starkware.cairo.common.math.assert_lt_felt", - "type": "alias" - }, - "starkware.cairo.common.math_cmp.is_le_felt": { - "decorators": ["known_ap_change"], - "pc": 128, - "type": "function" - }, - "starkware.cairo.common.math_cmp.is_le_felt.Args": { - "full_name": "starkware.cairo.common.math_cmp.is_le_felt.Args", - "members": { - "a": { "cairo_type": "felt", "offset": 0 }, - "b": { "cairo_type": "felt", "offset": 1 } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.math_cmp.is_le_felt.ImplicitArgs": { - "full_name": "starkware.cairo.common.math_cmp.is_le_felt.ImplicitArgs", - "members": { "range_check_ptr": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.math_cmp.is_le_felt.Return": { - "cairo_type": "felt", - "type": "type_definition" - }, - "starkware.cairo.common.math_cmp.is_le_felt.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.math_cmp.is_le_felt.a": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math_cmp.is_le_felt.a", - "references": [ - { - "ap_tracking_data": { "group": 11, "offset": 0 }, - "pc": 128, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math_cmp.is_le_felt.b": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math_cmp.is_le_felt.b", - "references": [ - { - "ap_tracking_data": { "group": 11, "offset": 0 }, - "pc": 128, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math_cmp.is_le_felt.not_le": { - "pc": 140, - "type": "label" - }, - "starkware.cairo.common.memcpy.memcpy": { - "decorators": [], - "pc": 3, - "type": "function" - }, - "starkware.cairo.common.memcpy.memcpy.Args": { - "full_name": "starkware.cairo.common.memcpy.memcpy.Args", - "members": { - "dst": { "cairo_type": "felt*", "offset": 0 }, - "len": { "cairo_type": "felt", "offset": 2 }, - "src": { "cairo_type": "felt*", "offset": 1 } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.memcpy.memcpy.ImplicitArgs": { - "full_name": "starkware.cairo.common.memcpy.memcpy.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.common.memcpy.memcpy.LoopFrame": { - "full_name": "starkware.cairo.common.memcpy.memcpy.LoopFrame", - "members": { - "dst": { "cairo_type": "felt*", "offset": 0 }, - "src": { "cairo_type": "felt*", "offset": 1 } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.memcpy.memcpy.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.memcpy.memcpy.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.memcpy.memcpy.continue_copying": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.memcpy.memcpy.continue_copying", - "references": [ - { - "ap_tracking_data": { "group": 1, "offset": 3 }, - "pc": 10, - "value": "[cast(ap, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy.len": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.memcpy.memcpy.len", - "references": [ - { - "ap_tracking_data": { "group": 1, "offset": 0 }, - "pc": 3, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy.loop": { "pc": 8, "type": "label" }, - "starkware.cairo.common.pow.assert_le": { - "destination": "starkware.cairo.common.math.assert_le", - "type": "alias" - }, - "starkware.cairo.common.pow.get_ap": { - "destination": "starkware.cairo.common.registers.get_ap", - "type": "alias" - }, - "starkware.cairo.common.pow.get_fp_and_pc": { - "destination": "starkware.cairo.common.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.common.registers.get_ap": { - "destination": "starkware.cairo.lang.compiler.lib.registers.get_ap", - "type": "alias" - }, - "starkware.cairo.common.registers.get_fp_and_pc": { - "destination": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.common.signature.EcOpBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", - "type": "alias" - }, - "starkware.cairo.common.signature.EcPoint": { - "destination": "starkware.cairo.common.ec_point.EcPoint", - "type": "alias" - }, - "starkware.cairo.common.signature.FALSE": { - "destination": "starkware.cairo.common.bool.FALSE", - "type": "alias" - }, - "starkware.cairo.common.signature.SignatureBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", - "type": "alias" - }, - "starkware.cairo.common.signature.StarkCurve": { - "destination": "starkware.cairo.common.ec.StarkCurve", - "type": "alias" - }, - "starkware.cairo.common.signature.TRUE": { - "destination": "starkware.cairo.common.bool.TRUE", - "type": "alias" - }, - "starkware.cairo.common.signature.ec_add": { - "destination": "starkware.cairo.common.ec.ec_add", - "type": "alias" - }, - "starkware.cairo.common.signature.ec_mul": { - "destination": "starkware.cairo.common.ec.ec_mul", - "type": "alias" - }, - "starkware.cairo.common.signature.ec_sub": { - "destination": "starkware.cairo.common.ec.ec_sub", - "type": "alias" - }, - "starkware.cairo.common.signature.is_x_on_curve": { - "destination": "starkware.cairo.common.ec.is_x_on_curve", - "type": "alias" - }, - "starkware.cairo.common.signature.recover_y": { - "destination": "starkware.cairo.common.ec.recover_y", - "type": "alias" - }, - "starkware.cairo.common.signature.verify_ecdsa_signature": { - "decorators": [], - "pc": 123, - "type": "function" - }, - "starkware.cairo.common.signature.verify_ecdsa_signature.Args": { - "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.Args", - "members": { - "message": { "cairo_type": "felt", "offset": 0 }, - "public_key": { "cairo_type": "felt", "offset": 1 }, - "signature_r": { "cairo_type": "felt", "offset": 2 }, - "signature_s": { "cairo_type": "felt", "offset": 3 } - }, - "size": 4, - "type": "struct" - }, - "starkware.cairo.common.signature.verify_ecdsa_signature.ImplicitArgs": { - "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.ImplicitArgs", - "members": { - "ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.signature.verify_ecdsa_signature.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.signature.verify_ecdsa_signature.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.signature.verify_ecdsa_signature.ecdsa_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", - "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.ecdsa_ptr", - "references": [ - { - "ap_tracking_data": { "group": 10, "offset": 0 }, - "pc": 123, - "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.SignatureBuiltin**)]" - }, - { - "ap_tracking_data": { "group": 10, "offset": 0 }, - "pc": 125, - "value": "cast([fp + (-7)] + 2, starkware.cairo.common.cairo_builtins.SignatureBuiltin*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.signature.verify_ecdsa_signature.signature_r": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.signature_r", - "references": [ - { - "ap_tracking_data": { "group": 10, "offset": 0 }, - "pc": 123, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.signature.verify_ecdsa_signature.signature_s": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.signature_s", - "references": [ - { - "ap_tracking_data": { "group": 10, "offset": 0 }, - "pc": 123, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.uint256.ALL_ONES": { - "type": "const", - "value": 340282366920938463463374607431768211455 - }, - "starkware.cairo.common.uint256.BitwiseBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "type": "alias" - }, - "starkware.cairo.common.uint256.HALF_SHIFT": { - "type": "const", - "value": 18446744073709551616 - }, - "starkware.cairo.common.uint256.SHIFT": { - "type": "const", - "value": 340282366920938463463374607431768211456 - }, - "starkware.cairo.common.uint256.Uint256": { - "full_name": "starkware.cairo.common.uint256.Uint256", - "members": { - "high": { "cairo_type": "felt", "offset": 1 }, - "low": { "cairo_type": "felt", "offset": 0 } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.uint256.assert_in_range": { - "destination": "starkware.cairo.common.math.assert_in_range", - "type": "alias" - }, - "starkware.cairo.common.uint256.assert_le": { - "destination": "starkware.cairo.common.math.assert_le", - "type": "alias" - }, - "starkware.cairo.common.uint256.assert_nn_le": { - "destination": "starkware.cairo.common.math.assert_nn_le", - "type": "alias" - }, - "starkware.cairo.common.uint256.assert_not_zero": { - "destination": "starkware.cairo.common.math.assert_not_zero", - "type": "alias" - }, - "starkware.cairo.common.uint256.bitwise_and": { - "destination": "starkware.cairo.common.bitwise.bitwise_and", - "type": "alias" - }, - "starkware.cairo.common.uint256.bitwise_or": { - "destination": "starkware.cairo.common.bitwise.bitwise_or", - "type": "alias" - }, - "starkware.cairo.common.uint256.bitwise_xor": { - "destination": "starkware.cairo.common.bitwise.bitwise_xor", - "type": "alias" - }, - "starkware.cairo.common.uint256.get_ap": { - "destination": "starkware.cairo.common.registers.get_ap", - "type": "alias" - }, - "starkware.cairo.common.uint256.get_fp_and_pc": { - "destination": "starkware.cairo.common.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.common.uint256.is_le": { - "destination": "starkware.cairo.common.math_cmp.is_le", - "type": "alias" - }, - "starkware.cairo.common.uint256.pow": { - "destination": "starkware.cairo.common.pow.pow", - "type": "alias" - }, - "starkware.starknet.common.storage.ADDR_BOUND": { - "type": "const", - "value": -106710729501573572985208420194530329073740042555888586719489 - }, - "starkware.starknet.common.storage.MAX_STORAGE_ITEM_SIZE": { - "type": "const", - "value": 256 - }, - "starkware.starknet.common.storage.assert_250_bit": { - "destination": "starkware.cairo.common.math.assert_250_bit", - "type": "alias" - }, - "starkware.starknet.common.syscalls.CALL_CONTRACT_SELECTOR": { - "type": "const", - "value": 20853273475220472486191784820 - }, - "starkware.starknet.common.syscalls.CallContract": { - "full_name": "starkware.starknet.common.syscalls.CallContract", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.CallContractRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.CallContractResponse", - "offset": 5 - } - }, - "size": 7, - "type": "struct" - }, - "starkware.starknet.common.syscalls.CallContractRequest": { - "full_name": "starkware.starknet.common.syscalls.CallContractRequest", - "members": { - "calldata": { "cairo_type": "felt*", "offset": 4 }, - "calldata_size": { "cairo_type": "felt", "offset": 3 }, - "contract_address": { "cairo_type": "felt", "offset": 1 }, - "function_selector": { "cairo_type": "felt", "offset": 2 }, - "selector": { "cairo_type": "felt", "offset": 0 } - }, - "size": 5, - "type": "struct" - }, - "starkware.starknet.common.syscalls.CallContractResponse": { - "full_name": "starkware.starknet.common.syscalls.CallContractResponse", - "members": { - "retdata": { "cairo_type": "felt*", "offset": 1 }, - "retdata_size": { "cairo_type": "felt", "offset": 0 } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.DELEGATE_CALL_SELECTOR": { - "type": "const", - "value": 21167594061783206823196716140 - }, - "starkware.starknet.common.syscalls.DELEGATE_L1_HANDLER_SELECTOR": { - "type": "const", - "value": 23274015802972845247556842986379118667122 - }, - "starkware.starknet.common.syscalls.DEPLOY_SELECTOR": { - "type": "const", - "value": 75202468540281 - }, - "starkware.starknet.common.syscalls.Deploy": { - "full_name": "starkware.starknet.common.syscalls.Deploy", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.DeployRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.DeployResponse", - "offset": 6 - } - }, - "size": 9, - "type": "struct" - }, - "starkware.starknet.common.syscalls.DeployRequest": { - "full_name": "starkware.starknet.common.syscalls.DeployRequest", - "members": { - "class_hash": { "cairo_type": "felt", "offset": 1 }, - "constructor_calldata": { "cairo_type": "felt*", "offset": 4 }, - "constructor_calldata_size": { "cairo_type": "felt", "offset": 3 }, - "contract_address_salt": { "cairo_type": "felt", "offset": 2 }, - "deploy_from_zero": { "cairo_type": "felt", "offset": 5 }, - "selector": { "cairo_type": "felt", "offset": 0 } - }, - "size": 6, - "type": "struct" - }, - "starkware.starknet.common.syscalls.DeployResponse": { - "full_name": "starkware.starknet.common.syscalls.DeployResponse", - "members": { - "constructor_retdata": { "cairo_type": "felt*", "offset": 2 }, - "constructor_retdata_size": { "cairo_type": "felt", "offset": 1 }, - "contract_address": { "cairo_type": "felt", "offset": 0 } - }, - "size": 3, - "type": "struct" - }, - "starkware.starknet.common.syscalls.DictAccess": { - "destination": "starkware.cairo.common.dict_access.DictAccess", - "type": "alias" - }, - "starkware.starknet.common.syscalls.EMIT_EVENT_SELECTOR": { - "type": "const", - "value": 1280709301550335749748 - }, - "starkware.starknet.common.syscalls.EmitEvent": { - "full_name": "starkware.starknet.common.syscalls.EmitEvent", - "members": { - "data": { "cairo_type": "felt*", "offset": 4 }, - "data_len": { "cairo_type": "felt", "offset": 3 }, - "keys": { "cairo_type": "felt*", "offset": 2 }, - "keys_len": { "cairo_type": "felt", "offset": 1 }, - "selector": { "cairo_type": "felt", "offset": 0 } - }, - "size": 5, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GET_BLOCK_NUMBER_SELECTOR": { - "type": "const", - "value": 1448089106835523001438702345020786 - }, - "starkware.starknet.common.syscalls.GET_BLOCK_TIMESTAMP_SELECTOR": { - "type": "const", - "value": 24294903732626645868215235778792757751152 - }, - "starkware.starknet.common.syscalls.GET_CALLER_ADDRESS_SELECTOR": { - "type": "const", - "value": 94901967781393078444254803017658102643 - }, - "starkware.starknet.common.syscalls.GET_CONTRACT_ADDRESS_SELECTOR": { - "type": "const", - "value": 6219495360805491471215297013070624192820083 - }, - "starkware.starknet.common.syscalls.GET_SEQUENCER_ADDRESS_SELECTOR": { - "type": "const", - "value": 1592190833581991703053805829594610833820054387 - }, - "starkware.starknet.common.syscalls.GET_TX_INFO_SELECTOR": { - "type": "const", - "value": 1317029390204112103023 - }, - "starkware.starknet.common.syscalls.GET_TX_SIGNATURE_SELECTOR": { - "type": "const", - "value": 1448089128652340074717162277007973 - }, - "starkware.starknet.common.syscalls.GetBlockNumber": { - "full_name": "starkware.starknet.common.syscalls.GetBlockNumber", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.GetBlockNumberRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.GetBlockNumberResponse", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetBlockNumberRequest": { - "full_name": "starkware.starknet.common.syscalls.GetBlockNumberRequest", - "members": { "selector": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetBlockNumberResponse": { - "full_name": "starkware.starknet.common.syscalls.GetBlockNumberResponse", - "members": { "block_number": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetBlockTimestamp": { - "full_name": "starkware.starknet.common.syscalls.GetBlockTimestamp", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.GetBlockTimestampRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.GetBlockTimestampResponse", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetBlockTimestampRequest": { - "full_name": "starkware.starknet.common.syscalls.GetBlockTimestampRequest", - "members": { "selector": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetBlockTimestampResponse": { - "full_name": "starkware.starknet.common.syscalls.GetBlockTimestampResponse", - "members": { "block_timestamp": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetCallerAddress": { - "full_name": "starkware.starknet.common.syscalls.GetCallerAddress", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.GetCallerAddressRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.GetCallerAddressResponse", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetCallerAddressRequest": { - "full_name": "starkware.starknet.common.syscalls.GetCallerAddressRequest", - "members": { "selector": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetCallerAddressResponse": { - "full_name": "starkware.starknet.common.syscalls.GetCallerAddressResponse", - "members": { "caller_address": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetContractAddress": { - "full_name": "starkware.starknet.common.syscalls.GetContractAddress", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.GetContractAddressRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.GetContractAddressResponse", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetContractAddressRequest": { - "full_name": "starkware.starknet.common.syscalls.GetContractAddressRequest", - "members": { "selector": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetContractAddressResponse": { - "full_name": "starkware.starknet.common.syscalls.GetContractAddressResponse", - "members": { "contract_address": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetSequencerAddress": { - "full_name": "starkware.starknet.common.syscalls.GetSequencerAddress", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.GetSequencerAddressRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.GetSequencerAddressResponse", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetSequencerAddressRequest": { - "full_name": "starkware.starknet.common.syscalls.GetSequencerAddressRequest", - "members": { "selector": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetSequencerAddressResponse": { - "full_name": "starkware.starknet.common.syscalls.GetSequencerAddressResponse", - "members": { "sequencer_address": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetTxInfo": { - "full_name": "starkware.starknet.common.syscalls.GetTxInfo", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.GetTxInfoRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.GetTxInfoResponse", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetTxInfoRequest": { - "full_name": "starkware.starknet.common.syscalls.GetTxInfoRequest", - "members": { "selector": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetTxInfoResponse": { - "full_name": "starkware.starknet.common.syscalls.GetTxInfoResponse", - "members": { - "tx_info": { - "cairo_type": "starkware.starknet.common.syscalls.TxInfo*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetTxSignature": { - "full_name": "starkware.starknet.common.syscalls.GetTxSignature", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.GetTxSignatureRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.GetTxSignatureResponse", - "offset": 1 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetTxSignatureRequest": { - "full_name": "starkware.starknet.common.syscalls.GetTxSignatureRequest", - "members": { "selector": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.GetTxSignatureResponse": { - "full_name": "starkware.starknet.common.syscalls.GetTxSignatureResponse", - "members": { - "signature": { "cairo_type": "felt*", "offset": 1 }, - "signature_len": { "cairo_type": "felt", "offset": 0 } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.LIBRARY_CALL_L1_HANDLER_SELECTOR": { - "type": "const", - "value": 436233452754198157705746250789557519228244616562 - }, - "starkware.starknet.common.syscalls.LIBRARY_CALL_SELECTOR": { - "type": "const", - "value": 92376026794327011772951660 - }, - "starkware.starknet.common.syscalls.LibraryCall": { - "full_name": "starkware.starknet.common.syscalls.LibraryCall", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.LibraryCallRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.CallContractResponse", - "offset": 5 - } - }, - "size": 7, - "type": "struct" - }, - "starkware.starknet.common.syscalls.LibraryCallRequest": { - "full_name": "starkware.starknet.common.syscalls.LibraryCallRequest", - "members": { - "calldata": { "cairo_type": "felt*", "offset": 4 }, - "calldata_size": { "cairo_type": "felt", "offset": 3 }, - "class_hash": { "cairo_type": "felt", "offset": 1 }, - "function_selector": { "cairo_type": "felt", "offset": 2 }, - "selector": { "cairo_type": "felt", "offset": 0 } - }, - "size": 5, - "type": "struct" - }, - "starkware.starknet.common.syscalls.SEND_MESSAGE_TO_L1_SELECTOR": { - "type": "const", - "value": 433017908768303439907196859243777073 - }, - "starkware.starknet.common.syscalls.STORAGE_READ_SELECTOR": { - "type": "const", - "value": 100890693370601760042082660 - }, - "starkware.starknet.common.syscalls.STORAGE_WRITE_SELECTOR": { - "type": "const", - "value": 25828017502874050592466629733 - }, - "starkware.starknet.common.syscalls.SendMessageToL1SysCall": { - "full_name": "starkware.starknet.common.syscalls.SendMessageToL1SysCall", - "members": { - "payload_ptr": { "cairo_type": "felt*", "offset": 3 }, - "payload_size": { "cairo_type": "felt", "offset": 2 }, - "selector": { "cairo_type": "felt", "offset": 0 }, - "to_address": { "cairo_type": "felt", "offset": 1 } - }, - "size": 4, - "type": "struct" - }, - "starkware.starknet.common.syscalls.StorageRead": { - "full_name": "starkware.starknet.common.syscalls.StorageRead", - "members": { - "request": { - "cairo_type": "starkware.starknet.common.syscalls.StorageReadRequest", - "offset": 0 - }, - "response": { - "cairo_type": "starkware.starknet.common.syscalls.StorageReadResponse", - "offset": 2 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.starknet.common.syscalls.StorageReadRequest": { - "full_name": "starkware.starknet.common.syscalls.StorageReadRequest", - "members": { - "address": { "cairo_type": "felt", "offset": 1 }, - "selector": { "cairo_type": "felt", "offset": 0 } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.StorageReadResponse": { - "full_name": "starkware.starknet.common.syscalls.StorageReadResponse", - "members": { "value": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.StorageWrite": { - "full_name": "starkware.starknet.common.syscalls.StorageWrite", - "members": { - "address": { "cairo_type": "felt", "offset": 1 }, - "selector": { "cairo_type": "felt", "offset": 0 }, - "value": { "cairo_type": "felt", "offset": 2 } - }, - "size": 3, - "type": "struct" - }, - "starkware.starknet.common.syscalls.TxInfo": { - "full_name": "starkware.starknet.common.syscalls.TxInfo", - "members": { - "account_contract_address": { "cairo_type": "felt", "offset": 1 }, - "chain_id": { "cairo_type": "felt", "offset": 6 }, - "max_fee": { "cairo_type": "felt", "offset": 2 }, - "nonce": { "cairo_type": "felt", "offset": 7 }, - "signature": { "cairo_type": "felt*", "offset": 4 }, - "signature_len": { "cairo_type": "felt", "offset": 3 }, - "transaction_hash": { "cairo_type": "felt", "offset": 5 }, - "version": { "cairo_type": "felt", "offset": 0 } - }, - "size": 8, - "type": "struct" - }, - "starkware.starknet.common.syscalls.call_contract": { - "decorators": [], - "pc": 74, - "type": "function" - }, - "starkware.starknet.common.syscalls.call_contract.Args": { - "full_name": "starkware.starknet.common.syscalls.call_contract.Args", - "members": { - "calldata": { "cairo_type": "felt*", "offset": 3 }, - "calldata_size": { "cairo_type": "felt", "offset": 2 }, - "contract_address": { "cairo_type": "felt", "offset": 0 }, - "function_selector": { "cairo_type": "felt", "offset": 1 } - }, - "size": 4, - "type": "struct" - }, - "starkware.starknet.common.syscalls.call_contract.ImplicitArgs": { - "full_name": "starkware.starknet.common.syscalls.call_contract.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.call_contract.Return": { - "cairo_type": "(retdata_size: felt, retdata: felt*)", - "type": "type_definition" - }, - "starkware.starknet.common.syscalls.call_contract.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.starknet.common.syscalls.call_contract.syscall_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.starknet.common.syscalls.call_contract.syscall_ptr", - "references": [ - { - "ap_tracking_data": { "group": 4, "offset": 0 }, - "pc": 74, - "value": "[cast(fp + (-7), felt**)]" - }, - { - "ap_tracking_data": { "group": 4, "offset": 1 }, - "pc": 81, - "value": "cast([fp + (-7)] + 7, felt*)" - } - ], - "type": "reference" - }, - "starkware.starknet.common.syscalls.get_caller_address": { - "decorators": [], - "pc": 86, - "type": "function" - }, - "starkware.starknet.common.syscalls.get_caller_address.Args": { - "full_name": "starkware.starknet.common.syscalls.get_caller_address.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.starknet.common.syscalls.get_caller_address.ImplicitArgs": { - "full_name": "starkware.starknet.common.syscalls.get_caller_address.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.get_caller_address.Return": { - "cairo_type": "(caller_address: felt)", - "type": "type_definition" - }, - "starkware.starknet.common.syscalls.get_caller_address.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr", - "references": [ - { - "ap_tracking_data": { "group": 5, "offset": 0 }, - "pc": 86, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { "group": 5, "offset": 1 }, - "pc": 89, - "value": "cast([fp + (-3)] + 2, felt*)" - } - ], - "type": "reference" - }, - "starkware.starknet.common.syscalls.get_contract_address": { - "decorators": [], - "pc": 93, - "type": "function" - }, - "starkware.starknet.common.syscalls.get_contract_address.Args": { - "full_name": "starkware.starknet.common.syscalls.get_contract_address.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.starknet.common.syscalls.get_contract_address.ImplicitArgs": { - "full_name": "starkware.starknet.common.syscalls.get_contract_address.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.get_contract_address.Return": { - "cairo_type": "(contract_address: felt)", - "type": "type_definition" - }, - "starkware.starknet.common.syscalls.get_contract_address.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.starknet.common.syscalls.get_contract_address.syscall_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.starknet.common.syscalls.get_contract_address.syscall_ptr", - "references": [ - { - "ap_tracking_data": { "group": 6, "offset": 0 }, - "pc": 93, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { "group": 6, "offset": 1 }, - "pc": 96, - "value": "cast([fp + (-3)] + 2, felt*)" - } - ], - "type": "reference" - }, - "starkware.starknet.common.syscalls.get_tx_info": { - "decorators": [], - "pc": 116, - "type": "function" - }, - "starkware.starknet.common.syscalls.get_tx_info.Args": { - "full_name": "starkware.starknet.common.syscalls.get_tx_info.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.starknet.common.syscalls.get_tx_info.ImplicitArgs": { - "full_name": "starkware.starknet.common.syscalls.get_tx_info.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.get_tx_info.Return": { - "cairo_type": "(tx_info: starkware.starknet.common.syscalls.TxInfo*)", - "type": "type_definition" - }, - "starkware.starknet.common.syscalls.get_tx_info.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.starknet.common.syscalls.get_tx_info.syscall_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.starknet.common.syscalls.get_tx_info.syscall_ptr", - "references": [ - { - "ap_tracking_data": { "group": 9, "offset": 0 }, - "pc": 116, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { "group": 9, "offset": 1 }, - "pc": 119, - "value": "cast([fp + (-3)] + 2, felt*)" - } - ], - "type": "reference" - }, - "starkware.starknet.common.syscalls.storage_read": { - "decorators": [], - "pc": 100, - "type": "function" - }, - "starkware.starknet.common.syscalls.storage_read.Args": { - "full_name": "starkware.starknet.common.syscalls.storage_read.Args", - "members": { "address": { "cairo_type": "felt", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.storage_read.ImplicitArgs": { - "full_name": "starkware.starknet.common.syscalls.storage_read.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.storage_read.Return": { - "cairo_type": "(value: felt)", - "type": "type_definition" - }, - "starkware.starknet.common.syscalls.storage_read.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.starknet.common.syscalls.storage_read.syscall_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.starknet.common.syscalls.storage_read.syscall_ptr", - "references": [ - { - "ap_tracking_data": { "group": 7, "offset": 0 }, - "pc": 100, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { "group": 7, "offset": 1 }, - "pc": 104, - "value": "cast([fp + (-4)] + 3, felt*)" - } - ], - "type": "reference" - }, - "starkware.starknet.common.syscalls.storage_write": { - "decorators": [], - "pc": 108, - "type": "function" - }, - "starkware.starknet.common.syscalls.storage_write.Args": { - "full_name": "starkware.starknet.common.syscalls.storage_write.Args", - "members": { - "address": { "cairo_type": "felt", "offset": 0 }, - "value": { "cairo_type": "felt", "offset": 1 } - }, - "size": 2, - "type": "struct" - }, - "starkware.starknet.common.syscalls.storage_write.ImplicitArgs": { - "full_name": "starkware.starknet.common.syscalls.storage_write.ImplicitArgs", - "members": { "syscall_ptr": { "cairo_type": "felt*", "offset": 0 } }, - "size": 1, - "type": "struct" - }, - "starkware.starknet.common.syscalls.storage_write.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.starknet.common.syscalls.storage_write.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.starknet.common.syscalls.storage_write.syscall_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.starknet.common.syscalls.storage_write.syscall_ptr", - "references": [ - { - "ap_tracking_data": { "group": 8, "offset": 0 }, - "pc": 108, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { "group": 8, "offset": 1 }, - "pc": 113, - "value": "cast([fp + (-5)] + 3, felt*)" - } - ], - "type": "reference" - } - }, - "main_scope": "__main__", - "prime": "0x800000000000011000000000000000000000000000000000000000000000001", - "reference_manager": { - "references": [ - { - "ap_tracking_data": { "group": 1, "offset": 0 }, - "pc": 3, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { "group": 1, "offset": 3 }, - "pc": 10, - "value": "[cast(ap, felt*)]" - }, - { - "ap_tracking_data": { "group": 2, "offset": 0 }, - "pc": 18, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { "group": 2, "offset": 0 }, - "pc": 18, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { "group": 2, "offset": 0 }, - "pc": 18, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { "group": 3, "offset": 0 }, - "pc": 63, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { "group": 3, "offset": 0 }, - "pc": 63, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { "group": 4, "offset": 0 }, - "pc": 74, - "value": "[cast(fp + (-7), felt**)]" - }, - { - "ap_tracking_data": { "group": 5, "offset": 0 }, - "pc": 86, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { "group": 6, "offset": 0 }, - "pc": 93, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { "group": 7, "offset": 0 }, - "pc": 100, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { "group": 8, "offset": 0 }, - "pc": 108, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { "group": 9, "offset": 0 }, - "pc": 116, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { "group": 10, "offset": 0 }, - "pc": 123, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { "group": 10, "offset": 0 }, - "pc": 123, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { "group": 10, "offset": 0 }, - "pc": 123, - "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.SignatureBuiltin**)]" - }, - { - "ap_tracking_data": { "group": 11, "offset": 0 }, - "pc": 128, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { "group": 11, "offset": 0 }, - "pc": 128, - "value": "[cast(fp + (-3), felt*)]" - } - ] - } - } + "abi": [ + { + "members": [ + { + "name": "to", + "offset": 0, + "type": "felt" + }, + { + "name": "selector", + "offset": 1, + "type": "felt" + }, + { + "name": "data_offset", + "offset": 2, + "type": "felt" + }, + { + "name": "data_len", + "offset": 3, + "type": "felt" + } + ], + "name": "AccountCallArray", + "size": 4, + "type": "struct" + }, + { + "inputs": [ + { + "name": "publicKey", + "type": "felt" + } + ], + "name": "constructor", + "outputs": [], + "type": "constructor" + }, + { + "inputs": [], + "name": "getPublicKey", + "outputs": [ + { + "name": "publicKey", + "type": "felt" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "interfaceId", + "type": "felt" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "name": "success", + "type": "felt" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "newPublicKey", + "type": "felt" + } + ], + "name": "setPublicKey", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "hash", + "type": "felt" + }, + { + "name": "signature_len", + "type": "felt" + }, + { + "name": "signature", + "type": "felt*" + } + ], + "name": "isValidSignature", + "outputs": [ + { + "name": "isValid", + "type": "felt" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "call_array_len", + "type": "felt" + }, + { + "name": "call_array", + "type": "AccountCallArray*" + }, + { + "name": "calldata_len", + "type": "felt" + }, + { + "name": "calldata", + "type": "felt*" + } + ], + "name": "__validate__", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "class_hash", + "type": "felt" + } + ], + "name": "__validate_declare__", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "class_hash", + "type": "felt" + }, + { + "name": "salt", + "type": "felt" + }, + { + "name": "publicKey", + "type": "felt" + } + ], + "name": "__validate_deploy__", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "call_array_len", + "type": "felt" + }, + { + "name": "call_array", + "type": "AccountCallArray*" + }, + { + "name": "calldata_len", + "type": "felt" + }, + { + "name": "calldata", + "type": "felt*" + } + ], + "name": "__execute__", + "outputs": [ + { + "name": "response_len", + "type": "felt" + }, + { + "name": "response", + "type": "felt*" + } + ], + "type": "function" + } + ], + "entry_points_by_type": { + "CONSTRUCTOR": [ + { + "offset": "0x16e", + "selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194" + } + ], + "EXTERNAL": [ + { + "offset": "0x1cd", + "selector": "0xbc0eb87884ab91e330445c3584a50d7ddf4b568f02fbeb456a6242cce3f5d9" + }, + { + "offset": "0x2bb", + "selector": "0x15d40a3d6ca2ac30f4031e42be28da9b056fef9bb7357ac5e85627ee876e5ad" + }, + { + "offset": "0x224", + "selector": "0x162da33a4585851fe8d3af3c2a9c60b557814e221e0d4f30ff0b2189d9c7775" + }, + { + "offset": "0x191", + "selector": "0x1a6c6a0bdec86cc645c91997d8eea83e87148659e3e61122f72361fd5e94079" + }, + { + "offset": "0x1f4", + "selector": "0x213dfe25e2ca309c4d615a09cfc95fdb2fc7dc73fbcad12c450fe93b1f2ff9e" + }, + { + "offset": "0x25f", + "selector": "0x289da278a8dc833409cabfdad1581e8e7d40e42dcaed693fa4008dcdb4963b3" + }, + { + "offset": "0x1b2", + "selector": "0x29e211664c0b63c79638fbea474206ca74016b3e9a3dc4f9ac300ffd8bdf2cd" + }, + { + "offset": "0x285", + "selector": "0x36fcbf06cd96843058359e1a75928beacfac10727dab22a3972f0af8aa92895" + } + ], + "L1_HANDLER": [] + }, + "program": { + "debug_info": { + "file_contents": {}, + "instruction_locations": {} + }, + "attributes": [ + { + "accessible_scopes": [ + "openzeppelin.account.library", + "openzeppelin.account.library.Account", + "openzeppelin.account.library.Account.assert_only_self" + ], + "end_pc": 192, + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 12 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 191, + "value": "Account: caller is not this account" + }, + { + "accessible_scopes": [ + "openzeppelin.account.library", + "openzeppelin.account.library.Account", + "openzeppelin.account.library.Account.execute" + ], + "end_pc": 269, + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 9 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 259, + "value": "Account: deprecated tx version" + }, + { + "accessible_scopes": [ + "openzeppelin.account.library", + "openzeppelin.account.library.Account", + "openzeppelin.account.library.Account.execute" + ], + "end_pc": 274, + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 49 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 272, + "value": "Account: reentrant call" + } + ], + "builtins": [ + "pedersen", + "range_check", + "ecdsa", + "bitwise" + ], + "compiler_version": "0.10.2", + "data": [ + "0x40780017fff7fff", + "0x1", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x3", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480080007fff8000", + "0x400080007ffd7fff", + "0x482480017ffd8001", + "0x1", + "0x482480017ffd8001", + "0x1", + "0xa0680017fff7ffe", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", + "0x402a7ffc7ffd7fff", + "0x208b7fff7fff7ffe", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x484480017fff8000", + "0x2aaaaaaaaaaaab05555555555555556", + "0x48307fff7ffd8000", + "0x480280027ffb8000", + "0x480280037ffb8000", + "0x484480017fff8000", + "0x4000000000000088000000000000001", + "0x48307fff7ffd8000", + "0xa0680017fff8000", + "0xe", + "0x480680017fff8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x48287ffc80007fff", + "0x40307ffc7ff87fff", + "0x48297ffd80007ffc", + "0x482680017ffd8000", + "0x1", + "0x48507fff7ffe8000", + "0x40507ff97ff57fff", + "0x482680017ffb8000", + "0x4", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0xc", + "0x480680017fff8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x48287ffd80007fff", + "0x48327fff7ffc8000", + "0x40307ffa7ff67fff", + "0x48527ffe7ffc8000", + "0x40507ff97ff57fff", + "0x482680017ffb8000", + "0x4", + "0x208b7fff7fff7ffe", + "0x40317ffd7ff97ffd", + "0x48297ffc80007ffd", + "0x48527fff7ffc8000", + "0x40507ffb7ff77fff", + "0x40780017fff7fff", + "0x2", + "0x482680017ffb8000", + "0x4", + "0x208b7fff7fff7ffe", + "0x48297ffd80007ffc", + "0x20680017fff7fff", + "0x4", + "0x402780017ffc7ffc", + "0x1", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcc", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ff97fff", + "0x400380017ff97ffa", + "0x400380027ff97ffb", + "0x400380037ff97ffc", + "0x400380047ff97ffd", + "0x482680017ff98000", + "0x7", + "0x480280057ff98000", + "0x480280067ff98000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x47657443616c6c657241646472657373", + "0x400280007ffd7fff", + "0x482680017ffd8000", + "0x2", + "0x480280017ffd8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x476574436f6e747261637441646472657373", + "0x400280007ffd7fff", + "0x482680017ffd8000", + "0x2", + "0x480280017ffd8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280007ffc7fff", + "0x400380017ffc7ffd", + "0x482680017ffc8000", + "0x3", + "0x480280027ffc8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280007ffb7fff", + "0x400380017ffb7ffc", + "0x400380027ffb7ffd", + "0x482680017ffb8000", + "0x3", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x4765745478496e666f", + "0x400280007ffd7fff", + "0x482680017ffd8000", + "0x2", + "0x480280017ffd8000", + "0x208b7fff7fff7ffe", + "0x400380017ff97ffa", + "0x400380007ff97ffb", + "0x482680017ff98000", + "0x2", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0xc", + "0x40780017fff7fff", + "0x6", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff8c", + "0x480680017fff8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffd7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffb1", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1379ac0624b939ceb9dede92211d7db5ee174fe28be72245b0a1a2abd81c98f", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffa", + "0x480a7ffb7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc6", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffed", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc0", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff1", + "0x208b7fff7fff7ffe", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffa4", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff9a", + "0x40127fff7fff7ff9", + "0x48127ffe7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd5", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffe00365a", + "0x20680017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffff59942a8c", + "0x20680017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd7", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffbf", + "0x208b7fff7fff7ffe", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ffa7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffac", + "0x480a7ff97fff8000", + "0x480a7ffb7fff8000", + "0x48127ffd7fff8000", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff87", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffd7fff8000", + "0x48127ff37fff8000", + "0x480680017fff8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x480a7ff57fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff74", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480080007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff7a", + "0x480680017fff8000", + "0x1", + "0x40127fff7fff7ffe", + "0x40137ffd7fff8000", + "0x48127fdc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff49", + "0x400680017fff7fff", + "0x0", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffeef", + "0x40137fff7fff8001", + "0x48127ffb7fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffd7fff8000", + "0x480a80017fff8000", + "0x1104800180018000", + "0x35", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffee5", + "0x40137fff7fff8002", + "0x48127ffc7fff8000", + "0x480a7ffa7fff8000", + "0x480a80017fff8000", + "0x480a80027fff8000", + "0x1104800180018000", + "0xa", + "0x48127ffe7fff8000", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a80007fff8000", + "0x48127ffa7fff8000", + "0x480a80027fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x20780017fff7ffb", + "0x6", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480280007ffc8000", + "0x480280017ffc8000", + "0x480280027ffc8000", + "0x480280037ffc8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff11", + "0x40137ffe7fff8000", + "0x40137fff7fff8001", + "0x40137ffd7fff8002", + "0x480a7ffd7fff8000", + "0x480a80017fff8000", + "0x480a80007fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffec2", + "0x480a80027fff8000", + "0x482680017ffb8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x482680017ffc8000", + "0x4", + "0x482a80007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe4", + "0x48127ffe7fff8000", + "0x482880007ffe8000", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffa", + "0x4", + "0x480a7ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480280007ffb8000", + "0x400280007ffd7fff", + "0x480280017ffb8000", + "0x400280017ffd7fff", + "0x480280037ffb8000", + "0x400280027ffd7fff", + "0x480280027ffb8000", + "0x48327fff7ffc8000", + "0x400280037ffd7fff", + "0x480a7ff97fff8000", + "0x482680017ffa8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x482680017ffb8000", + "0x4", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0x4", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffec", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff48", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480280037ffb8000", + "0x480280047ffb8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff3e", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x4003800080007ffc", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4828800080007ffe", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x402b7ffd7ffc7ffd", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff1", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffb7fff8000", + "0x480280037ffb8000", + "0x480280047ffb8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff23", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x4003800080007ffc", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4828800080007ffe", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffea", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffb7fff8000", + "0x480280037ffb8000", + "0x480280047ffb8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff19", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480280037ffb8000", + "0x480280047ffb8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff04", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x4003800080007ffc", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4828800080007ffe", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x480280027ffb8000", + "0x480280017ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x2", + "0x480280017ffd8000", + "0x48307fff7ffe8000", + "0x402a7ffd7ffc7fff", + "0x480280027ffb8000", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280037ffb8000", + "0x482480017ffc8000", + "0x1", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x482680017ffd8000", + "0x2", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdc", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe3", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x48127ffb7fff8000", + "0x48127ff27fff8000", + "0x480280047ffb8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff67fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe61", + "0x48127ffe7fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480080057ffb8000", + "0x480080037ffa8000", + "0x480080047ff98000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffecf", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x1", + "0x480280007ffd8000", + "0x484480017fff8000", + "0x4", + "0x48307fff7ffd8000", + "0x480280027ffb8000", + "0x480080007ffe8000", + "0x400080017ffe7fff", + "0x482480017ffd8000", + "0x1", + "0x480080007ffc8000", + "0x48307fff7ffe8000", + "0x402a7ffd7ffc7fff", + "0x480280027ffb8000", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280037ffb8000", + "0x482480017ffc8000", + "0x2", + "0x480280007ffd8000", + "0x482680017ffd8000", + "0x1", + "0x480080007ff38000", + "0x482480017ff28000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd3", + "0x40780017fff7fff", + "0x1", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x480280047ffb8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff97fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe26", + "0x48127ffe7fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480080057ffb8000", + "0x480080037ffa8000", + "0x480080047ff98000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe94", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280037ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe8", + "0x40780017fff7fff", + "0x1", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x480280047ffb8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff77fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe00", + "0x48127ffe7fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480080057ffb8000", + "0x480080037ffa8000", + "0x480080047ff98000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe6e", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x3", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280037ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x480280027ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe6", + "0x40780017fff7fff", + "0x1", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x480280047ffb8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff57fff8000", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe5a", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x4003800080007ffb", + "0x400380007ffd7ffb", + "0x402780017ffd8001", + "0x1", + "0x4826800180008000", + "0x1", + "0x40297ffb7fff8002", + "0x4826800180008000", + "0x1", + "0x480a7ffc7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd4f", + "0x480a80017fff8000", + "0x4829800080008002", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x1", + "0x480280007ffd8000", + "0x484480017fff8000", + "0x4", + "0x48307fff7ffd8000", + "0x480280027ffb8000", + "0x480080007ffe8000", + "0x400080017ffe7fff", + "0x482480017ffd8000", + "0x1", + "0x480080007ffc8000", + "0x48307fff7ffe8000", + "0x402a7ffd7ffc7fff", + "0x480280027ffb8000", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280037ffb8000", + "0x480280047ffb8000", + "0x482480017ffb8000", + "0x2", + "0x480280007ffd8000", + "0x482680017ffd8000", + "0x1", + "0x480080007ff28000", + "0x482480017ff18000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc2", + "0x40137ff97fff8000", + "0x40137ffa7fff8001", + "0x40137ffb7fff8002", + "0x40137ffc7fff8003", + "0x48127ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc7", + "0x480a80007fff8000", + "0x480a80017fff8000", + "0x48127ffb7fff8000", + "0x480a80027fff8000", + "0x480a80037fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe" + ], + "hints": { + "0": [ + { + "accessible_scopes": [ + "starkware.cairo.common.alloc", + "starkware.cairo.common.alloc.alloc" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 0, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "6": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "vm_enter_scope({'n': ids.len})", + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.len": 0 + } + } + } + ], + "14": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "n -= 1\nids.continue_copying = 1 if n > 0 else 0", + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.continue_copying": 1 + } + } + } + ], + "17": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 6 + }, + "reference_ids": {} + } + } + ], + "18": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le_felt" + ], + "code": "import itertools\n\nfrom starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\na = ids.a % PRIME\nb = ids.b % PRIME\nassert a <= b, f'a = {a} is not less than or equal to b = {b}.'\n\n# Find an arc less than PRIME / 3, and another less than PRIME / 2.\nlengths_and_indices = [(a, 0), (b - a, 1), (PRIME - 1 - b, 2)]\nlengths_and_indices.sort()\nassert lengths_and_indices[0][0] <= PRIME // 3 and lengths_and_indices[1][0] <= PRIME // 2\nexcluded = lengths_and_indices[2][1]\n\nmemory[ids.range_check_ptr + 1], memory[ids.range_check_ptr + 0] = (\n divmod(lengths_and_indices[0][0], ids.PRIME_OVER_3_HIGH))\nmemory[ids.range_check_ptr + 3], memory[ids.range_check_ptr + 2] = (\n divmod(lengths_and_indices[1][0], ids.PRIME_OVER_2_HIGH))", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le_felt.a": 2, + "starkware.cairo.common.math.assert_le_felt.b": 3, + "starkware.cairo.common.math.assert_le_felt.range_check_ptr": 4 + } + } + } + ], + "28": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le_felt" + ], + "code": "memory[ap] = 1 if excluded != 0 else 0", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 8 + }, + "reference_ids": {} + } + } + ], + "42": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le_felt" + ], + "code": "memory[ap] = 1 if excluded != 1 else 0", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 9 + }, + "reference_ids": {} + } + } + ], + "54": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le_felt" + ], + "code": "assert excluded == 2", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 10 + }, + "reference_ids": {} + } + } + ], + "63": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_lt_felt" + ], + "code": "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert_integer(ids.b)\nassert (ids.a % PRIME) < (ids.b % PRIME), \\\n f'a = {ids.a % PRIME} is not less than b = {ids.b % PRIME}.'", + "flow_tracking_data": { + "ap_tracking": { + "group": 3, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_lt_felt.a": 5, + "starkware.cairo.common.math.assert_lt_felt.b": 6 + } + } + } + ], + "81": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.call_contract" + ], + "code": "syscall_handler.call_contract(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.call_contract.syscall_ptr": 7 + } + } + } + ], + "89": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_caller_address" + ], + "code": "syscall_handler.get_caller_address(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 5, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr": 8 + } + } + } + ], + "96": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_contract_address" + ], + "code": "syscall_handler.get_contract_address(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 6, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.get_contract_address.syscall_ptr": 9 + } + } + } + ], + "104": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "code": "syscall_handler.storage_read(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.storage_read.syscall_ptr": 10 + } + } + } + ], + "113": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "code": "syscall_handler.storage_write(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.storage_write.syscall_ptr": 11 + } + } + } + ], + "119": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_tx_info" + ], + "code": "syscall_handler.get_tx_info(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 9, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.get_tx_info.syscall_ptr": 12 + } + } + } + ], + "123": [ + { + "accessible_scopes": [ + "starkware.cairo.common.signature", + "starkware.cairo.common.signature.verify_ecdsa_signature" + ], + "code": "ecdsa_builtin.add_signature(ids.ecdsa_ptr.address_, (ids.signature_r, ids.signature_s))", + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.signature.verify_ecdsa_signature.ecdsa_ptr": 15, + "starkware.cairo.common.signature.verify_ecdsa_signature.signature_r": 13, + "starkware.cairo.common.signature.verify_ecdsa_signature.signature_s": 14 + } + } + } + ], + "128": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math_cmp", + "starkware.cairo.common.math_cmp.is_le_felt" + ], + "code": "memory[ap] = 0 if (ids.a % PRIME) <= (ids.b % PRIME) else 1", + "flow_tracking_data": { + "ap_tracking": { + "group": 11, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math_cmp.is_le_felt.a": 16, + "starkware.cairo.common.math_cmp.is_le_felt.b": 17 + } + } + } + ], + "375": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 35 + }, + "reference_ids": {} + } + } + ], + "392": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.getPublicKey_encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "425": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.supportsInterface_encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "470": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.setPublicKey" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 50 + }, + "reference_ids": {} + } + } + ], + "491": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.isValidSignature_encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "579": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__validate__" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 77 + }, + "reference_ids": {} + } + } + ], + "617": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__validate_declare__" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 63 + }, + "reference_ids": {} + } + } + ], + "657": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__validate_deploy__" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 49, + "offset": 65 + }, + "reference_ids": {} + } + } + ], + "680": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__execute___encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 0 + }, + "reference_ids": {} + } + } + ] + }, + "identifiers": { + "__main__.Account": { + "destination": "openzeppelin.account.library.Account", + "type": "alias" + }, + "__main__.AccountCallArray": { + "destination": "openzeppelin.account.library.AccountCallArray", + "type": "alias" + }, + "__main__.BitwiseBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "type": "alias" + }, + "__main__.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "__main__.SignatureBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", + "type": "alias" + }, + "__main__.__execute__": { + "decorators": [ + "external" + ], + "pc": 668, + "type": "function" + }, + "__main__.__execute__.Args": { + "full_name": "__main__.__execute__.Args", + "members": { + "call_array": { + "cairo_type": "openzeppelin.account.library.AccountCallArray*", + "offset": 1 + }, + "call_array_len": { + "cairo_type": "felt", + "offset": 0 + }, + "calldata": { + "cairo_type": "felt*", + "offset": 3 + }, + "calldata_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 4, + "type": "struct" + }, + "__main__.__execute__.ImplicitArgs": { + "full_name": "__main__.__execute__.ImplicitArgs", + "members": { + "bitwise_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin*", + "offset": 3 + }, + "ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "offset": 2 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 4 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 5, + "type": "struct" + }, + "__main__.__execute__.Return": { + "cairo_type": "(response_len: felt, response: felt*)", + "type": "type_definition" + }, + "__main__.__execute__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.__validate__": { + "decorators": [ + "external" + ], + "pc": 531, + "type": "function" + }, + "__main__.__validate__.Args": { + "full_name": "__main__.__validate__.Args", + "members": { + "call_array": { + "cairo_type": "openzeppelin.account.library.AccountCallArray*", + "offset": 1 + }, + "call_array_len": { + "cairo_type": "felt", + "offset": 0 + }, + "calldata": { + "cairo_type": "felt*", + "offset": 3 + }, + "calldata_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 4, + "type": "struct" + }, + "__main__.__validate__.ImplicitArgs": { + "full_name": "__main__.__validate__.ImplicitArgs", + "members": { + "ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "offset": 2 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "__main__.__validate__.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.__validate__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.__validate_declare__": { + "decorators": [ + "external" + ], + "pc": 590, + "type": "function" + }, + "__main__.__validate_declare__.Args": { + "full_name": "__main__.__validate_declare__.Args", + "members": { + "class_hash": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.__validate_declare__.ImplicitArgs": { + "full_name": "__main__.__validate_declare__.ImplicitArgs", + "members": { + "ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "offset": 2 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "__main__.__validate_declare__.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.__validate_declare__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.__validate_deploy__": { + "decorators": [ + "external" + ], + "pc": 628, + "type": "function" + }, + "__main__.__validate_deploy__.Args": { + "full_name": "__main__.__validate_deploy__.Args", + "members": { + "class_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "publicKey": { + "cairo_type": "felt", + "offset": 2 + }, + "salt": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.__validate_deploy__.ImplicitArgs": { + "full_name": "__main__.__validate_deploy__.ImplicitArgs", + "members": { + "ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "offset": 2 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "__main__.__validate_deploy__.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.__validate_deploy__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.constructor": { + "decorators": [ + "constructor" + ], + "pc": 359, + "type": "function" + }, + "__main__.constructor.Args": { + "full_name": "__main__.constructor.Args", + "members": { + "publicKey": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.constructor.ImplicitArgs": { + "full_name": "__main__.constructor.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.constructor.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.constructor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.getPublicKey": { + "decorators": [ + "view" + ], + "pc": 386, + "type": "function" + }, + "__main__.getPublicKey.Args": { + "full_name": "__main__.getPublicKey.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.getPublicKey.ImplicitArgs": { + "full_name": "__main__.getPublicKey.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.getPublicKey.Return": { + "cairo_type": "(publicKey: felt)", + "type": "type_definition" + }, + "__main__.getPublicKey.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.get_tx_info": { + "destination": "starkware.starknet.common.syscalls.get_tx_info", + "type": "alias" + }, + "__main__.isValidSignature": { + "decorators": [ + "view" + ], + "pc": 481, + "type": "function" + }, + "__main__.isValidSignature.Args": { + "full_name": "__main__.isValidSignature.Args", + "members": { + "hash": { + "cairo_type": "felt", + "offset": 0 + }, + "signature": { + "cairo_type": "felt*", + "offset": 2 + }, + "signature_len": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.isValidSignature.ImplicitArgs": { + "full_name": "__main__.isValidSignature.ImplicitArgs", + "members": { + "ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "offset": 2 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "__main__.isValidSignature.Return": { + "cairo_type": "(isValid: felt)", + "type": "type_definition" + }, + "__main__.isValidSignature.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.setPublicKey": { + "decorators": [ + "external" + ], + "pc": 454, + "type": "function" + }, + "__main__.setPublicKey.Args": { + "full_name": "__main__.setPublicKey.Args", + "members": { + "newPublicKey": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.setPublicKey.ImplicitArgs": { + "full_name": "__main__.setPublicKey.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.setPublicKey.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.setPublicKey.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.supportsInterface": { + "decorators": [ + "view" + ], + "pc": 418, + "type": "function" + }, + "__main__.supportsInterface.Args": { + "full_name": "__main__.supportsInterface.Args", + "members": { + "interfaceId": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.supportsInterface.ImplicitArgs": { + "full_name": "__main__.supportsInterface.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.supportsInterface.Return": { + "cairo_type": "(success: felt)", + "type": "type_definition" + }, + "__main__.supportsInterface.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.__execute__": { + "decorators": [ + "external" + ], + "pc": 699, + "type": "function" + }, + "__wrappers__.__execute__.Args": { + "full_name": "__wrappers__.__execute__.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__execute__.ImplicitArgs": { + "full_name": "__wrappers__.__execute__.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__execute__.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: starkware.cairo.common.cairo_builtins.BitwiseBuiltin*, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.__execute__.SIZEOF_LOCALS": { + "type": "const", + "value": 4 + }, + "__wrappers__.__execute__.__wrapped_func": { + "destination": "__main__.__execute__", + "type": "alias" + }, + "__wrappers__.__execute___encode_return": { + "decorators": [], + "pc": 680, + "type": "function" + }, + "__wrappers__.__execute___encode_return.Args": { + "full_name": "__wrappers__.__execute___encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "ret_value": { + "cairo_type": "(response_len: felt, response: felt*)", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__wrappers__.__execute___encode_return.ImplicitArgs": { + "full_name": "__wrappers__.__execute___encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__execute___encode_return.Return": { + "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", + "type": "type_definition" + }, + "__wrappers__.__execute___encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 3 + }, + "__wrappers__.__execute___encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.__validate__": { + "decorators": [ + "external" + ], + "pc": 548, + "type": "function" + }, + "__wrappers__.__validate__.Args": { + "full_name": "__wrappers__.__validate__.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__validate__.ImplicitArgs": { + "full_name": "__wrappers__.__validate__.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__validate__.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.__validate__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.__validate__.__wrapped_func": { + "destination": "__main__.__validate__", + "type": "alias" + }, + "__wrappers__.__validate___encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.__validate_declare__": { + "decorators": [ + "external" + ], + "pc": 607, + "type": "function" + }, + "__wrappers__.__validate_declare__.Args": { + "full_name": "__wrappers__.__validate_declare__.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__validate_declare__.ImplicitArgs": { + "full_name": "__wrappers__.__validate_declare__.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__validate_declare__.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.__validate_declare__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.__validate_declare__.__wrapped_func": { + "destination": "__main__.__validate_declare__", + "type": "alias" + }, + "__wrappers__.__validate_declare___encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.__validate_deploy__": { + "decorators": [ + "external" + ], + "pc": 645, + "type": "function" + }, + "__wrappers__.__validate_deploy__.Args": { + "full_name": "__wrappers__.__validate_deploy__.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__validate_deploy__.ImplicitArgs": { + "full_name": "__wrappers__.__validate_deploy__.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__validate_deploy__.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.__validate_deploy__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.__validate_deploy__.__wrapped_func": { + "destination": "__main__.__validate_deploy__", + "type": "alias" + }, + "__wrappers__.__validate_deploy___encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.constructor": { + "decorators": [ + "constructor" + ], + "pc": 366, + "type": "function" + }, + "__wrappers__.constructor.Args": { + "full_name": "__wrappers__.constructor.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.constructor.ImplicitArgs": { + "full_name": "__wrappers__.constructor.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.constructor.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: felt, bitwise_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.constructor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.constructor.__wrapped_func": { + "destination": "__main__.constructor", + "type": "alias" + }, + "__wrappers__.constructor_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.getPublicKey": { + "decorators": [ + "view" + ], + "pc": 401, + "type": "function" + }, + "__wrappers__.getPublicKey.Args": { + "full_name": "__wrappers__.getPublicKey.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.getPublicKey.ImplicitArgs": { + "full_name": "__wrappers__.getPublicKey.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.getPublicKey.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: felt, bitwise_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.getPublicKey.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.getPublicKey.__wrapped_func": { + "destination": "__main__.getPublicKey", + "type": "alias" + }, + "__wrappers__.getPublicKey_encode_return": { + "decorators": [], + "pc": 392, + "type": "function" + }, + "__wrappers__.getPublicKey_encode_return.Args": { + "full_name": "__wrappers__.getPublicKey_encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "ret_value": { + "cairo_type": "(publicKey: felt)", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__wrappers__.getPublicKey_encode_return.ImplicitArgs": { + "full_name": "__wrappers__.getPublicKey_encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.getPublicKey_encode_return.Return": { + "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", + "type": "type_definition" + }, + "__wrappers__.getPublicKey_encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "__wrappers__.getPublicKey_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.isValidSignature": { + "decorators": [ + "view" + ], + "pc": 500, + "type": "function" + }, + "__wrappers__.isValidSignature.Args": { + "full_name": "__wrappers__.isValidSignature.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.isValidSignature.ImplicitArgs": { + "full_name": "__wrappers__.isValidSignature.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.isValidSignature.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: starkware.cairo.common.cairo_builtins.SignatureBuiltin*, bitwise_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.isValidSignature.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.isValidSignature.__wrapped_func": { + "destination": "__main__.isValidSignature", + "type": "alias" + }, + "__wrappers__.isValidSignature_encode_return": { + "decorators": [], + "pc": 491, + "type": "function" + }, + "__wrappers__.isValidSignature_encode_return.Args": { + "full_name": "__wrappers__.isValidSignature_encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "ret_value": { + "cairo_type": "(isValid: felt)", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__wrappers__.isValidSignature_encode_return.ImplicitArgs": { + "full_name": "__wrappers__.isValidSignature_encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.isValidSignature_encode_return.Return": { + "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", + "type": "type_definition" + }, + "__wrappers__.isValidSignature_encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "__wrappers__.isValidSignature_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.setPublicKey": { + "decorators": [ + "external" + ], + "pc": 461, + "type": "function" + }, + "__wrappers__.setPublicKey.Args": { + "full_name": "__wrappers__.setPublicKey.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.setPublicKey.ImplicitArgs": { + "full_name": "__wrappers__.setPublicKey.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.setPublicKey.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: felt, bitwise_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.setPublicKey.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.setPublicKey.__wrapped_func": { + "destination": "__main__.setPublicKey", + "type": "alias" + }, + "__wrappers__.setPublicKey_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.supportsInterface": { + "decorators": [ + "view" + ], + "pc": 434, + "type": "function" + }, + "__wrappers__.supportsInterface.Args": { + "full_name": "__wrappers__.supportsInterface.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.supportsInterface.ImplicitArgs": { + "full_name": "__wrappers__.supportsInterface.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.supportsInterface.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, ecdsa_ptr: felt, bitwise_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.supportsInterface.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.supportsInterface.__wrapped_func": { + "destination": "__main__.supportsInterface", + "type": "alias" + }, + "__wrappers__.supportsInterface_encode_return": { + "decorators": [], + "pc": 425, + "type": "function" + }, + "__wrappers__.supportsInterface_encode_return.Args": { + "full_name": "__wrappers__.supportsInterface_encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "ret_value": { + "cairo_type": "(success: felt)", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__wrappers__.supportsInterface_encode_return.ImplicitArgs": { + "full_name": "__wrappers__.supportsInterface_encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.supportsInterface_encode_return.Return": { + "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", + "type": "type_definition" + }, + "__wrappers__.supportsInterface_encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "__wrappers__.supportsInterface_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "openzeppelin.account.library.Account": { + "type": "namespace" + }, + "openzeppelin.account.library.Account.Args": { + "full_name": "openzeppelin.account.library.Account.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "openzeppelin.account.library.Account.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "openzeppelin.account.library.Account.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "openzeppelin.account.library.Account.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account._execute_list": { + "decorators": [], + "pc": 301, + "type": "function" + }, + "openzeppelin.account.library.Account._execute_list.Args": { + "full_name": "openzeppelin.account.library.Account._execute_list.Args", + "members": { + "calls": { + "cairo_type": "openzeppelin.account.library.Call*", + "offset": 1 + }, + "calls_len": { + "cairo_type": "felt", + "offset": 0 + }, + "response": { + "cairo_type": "felt*", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "openzeppelin.account.library.Account._execute_list.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account._execute_list.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "openzeppelin.account.library.Account._execute_list.Return": { + "cairo_type": "(response_len: felt)", + "type": "type_definition" + }, + "openzeppelin.account.library.Account._execute_list.SIZEOF_LOCALS": { + "type": "const", + "value": 3 + }, + "openzeppelin.account.library.Account._from_call_array_to_call": { + "decorators": [], + "pc": 335, + "type": "function" + }, + "openzeppelin.account.library.Account._from_call_array_to_call.Args": { + "full_name": "openzeppelin.account.library.Account._from_call_array_to_call.Args", + "members": { + "call_array": { + "cairo_type": "openzeppelin.account.library.AccountCallArray*", + "offset": 1 + }, + "call_array_len": { + "cairo_type": "felt", + "offset": 0 + }, + "calldata": { + "cairo_type": "felt*", + "offset": 2 + }, + "calls": { + "cairo_type": "openzeppelin.account.library.Call*", + "offset": 3 + } + }, + "size": 4, + "type": "struct" + }, + "openzeppelin.account.library.Account._from_call_array_to_call.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account._from_call_array_to_call.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "openzeppelin.account.library.Account._from_call_array_to_call.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "openzeppelin.account.library.Account._from_call_array_to_call.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account.assert_only_self": { + "decorators": [], + "pc": 185, + "type": "function" + }, + "openzeppelin.account.library.Account.assert_only_self.Args": { + "full_name": "openzeppelin.account.library.Account.assert_only_self.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "openzeppelin.account.library.Account.assert_only_self.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account.assert_only_self.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "openzeppelin.account.library.Account.assert_only_self.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "openzeppelin.account.library.Account.assert_only_self.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account.execute": { + "decorators": [], + "pc": 254, + "type": "function" + }, + "openzeppelin.account.library.Account.execute.Args": { + "full_name": "openzeppelin.account.library.Account.execute.Args", + "members": { + "call_array": { + "cairo_type": "openzeppelin.account.library.AccountCallArray*", + "offset": 1 + }, + "call_array_len": { + "cairo_type": "felt", + "offset": 0 + }, + "calldata": { + "cairo_type": "felt*", + "offset": 3 + }, + "calldata_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 4, + "type": "struct" + }, + "openzeppelin.account.library.Account.execute.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account.execute.ImplicitArgs", + "members": { + "bitwise_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin*", + "offset": 3 + }, + "ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "offset": 2 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 4 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 5, + "type": "struct" + }, + "openzeppelin.account.library.Account.execute.Return": { + "cairo_type": "(response_len: felt, response: felt*)", + "type": "type_definition" + }, + "openzeppelin.account.library.Account.execute.SIZEOF_LOCALS": { + "type": "const", + "value": 3 + }, + "openzeppelin.account.library.Account.get_public_key": { + "decorators": [], + "pc": 194, + "type": "function" + }, + "openzeppelin.account.library.Account.get_public_key.Args": { + "full_name": "openzeppelin.account.library.Account.get_public_key.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "openzeppelin.account.library.Account.get_public_key.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account.get_public_key.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "openzeppelin.account.library.Account.get_public_key.Return": { + "cairo_type": "(public_key: felt)", + "type": "type_definition" + }, + "openzeppelin.account.library.Account.get_public_key.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account.initializer": { + "decorators": [], + "pc": 178, + "type": "function" + }, + "openzeppelin.account.library.Account.initializer.Args": { + "full_name": "openzeppelin.account.library.Account.initializer.Args", + "members": { + "_public_key": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "openzeppelin.account.library.Account.initializer.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account.initializer.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "openzeppelin.account.library.Account.initializer.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "openzeppelin.account.library.Account.initializer.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account.is_valid_signature": { + "decorators": [], + "pc": 235, + "type": "function" + }, + "openzeppelin.account.library.Account.is_valid_signature.Args": { + "full_name": "openzeppelin.account.library.Account.is_valid_signature.Args", + "members": { + "hash": { + "cairo_type": "felt", + "offset": 0 + }, + "signature": { + "cairo_type": "felt*", + "offset": 2 + }, + "signature_len": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "openzeppelin.account.library.Account.is_valid_signature.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account.is_valid_signature.ImplicitArgs", + "members": { + "ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "offset": 2 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "openzeppelin.account.library.Account.is_valid_signature.Return": { + "cairo_type": "(is_valid: felt)", + "type": "type_definition" + }, + "openzeppelin.account.library.Account.is_valid_signature.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account.set_public_key": { + "decorators": [], + "pc": 226, + "type": "function" + }, + "openzeppelin.account.library.Account.set_public_key.Args": { + "full_name": "openzeppelin.account.library.Account.set_public_key.Args", + "members": { + "new_public_key": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "openzeppelin.account.library.Account.set_public_key.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account.set_public_key.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "openzeppelin.account.library.Account.set_public_key.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "openzeppelin.account.library.Account.set_public_key.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account.supports_interface": { + "decorators": [], + "pc": 200, + "type": "function" + }, + "openzeppelin.account.library.Account.supports_interface.Args": { + "full_name": "openzeppelin.account.library.Account.supports_interface.Args", + "members": { + "interface_id": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "openzeppelin.account.library.Account.supports_interface.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account.supports_interface.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "openzeppelin.account.library.Account.supports_interface.Return": { + "cairo_type": "(success: felt)", + "type": "type_definition" + }, + "openzeppelin.account.library.Account.supports_interface.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.AccountCallArray": { + "full_name": "openzeppelin.account.library.AccountCallArray", + "members": { + "data_len": { + "cairo_type": "felt", + "offset": 3 + }, + "data_offset": { + "cairo_type": "felt", + "offset": 2 + }, + "selector": { + "cairo_type": "felt", + "offset": 1 + }, + "to": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key": { + "type": "namespace" + }, + "openzeppelin.account.library.Account_public_key.Args": { + "full_name": "openzeppelin.account.library.Account_public_key.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "openzeppelin.account.library.Account_public_key.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account_public_key.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "openzeppelin.account.library.Account_public_key.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account_public_key.addr": { + "decorators": [], + "pc": 148, + "type": "function" + }, + "openzeppelin.account.library.Account_public_key.addr.Args": { + "full_name": "openzeppelin.account.library.Account_public_key.addr.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key.addr.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account_public_key.addr.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key.addr.Return": { + "cairo_type": "(res: felt)", + "type": "type_definition" + }, + "openzeppelin.account.library.Account_public_key.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account_public_key.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "openzeppelin.account.library.Account_public_key.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "openzeppelin.account.library.Account_public_key.read": { + "decorators": [], + "pc": 153, + "type": "function" + }, + "openzeppelin.account.library.Account_public_key.read.Args": { + "full_name": "openzeppelin.account.library.Account_public_key.read.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key.read.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account_public_key.read.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key.read.Return": { + "cairo_type": "(public_key: felt)", + "type": "type_definition" + }, + "openzeppelin.account.library.Account_public_key.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.Account_public_key.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "openzeppelin.account.library.Account_public_key.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "openzeppelin.account.library.Account_public_key.write": { + "decorators": [], + "pc": 166, + "type": "function" + }, + "openzeppelin.account.library.Account_public_key.write.Args": { + "full_name": "openzeppelin.account.library.Account_public_key.write.Args", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key.write.ImplicitArgs": { + "full_name": "openzeppelin.account.library.Account_public_key.write.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "openzeppelin.account.library.Account_public_key.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "openzeppelin.account.library.Account_public_key.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "openzeppelin.account.library.BitwiseBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "type": "alias" + }, + "openzeppelin.account.library.Call": { + "full_name": "openzeppelin.account.library.Call", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 3 + }, + "calldata_len": { + "cairo_type": "felt", + "offset": 2 + }, + "selector": { + "cairo_type": "felt", + "offset": 1 + }, + "to": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "openzeppelin.account.library.FALSE": { + "destination": "starkware.cairo.common.bool.FALSE", + "type": "alias" + }, + "openzeppelin.account.library.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "openzeppelin.account.library.IACCOUNT_ID": { + "destination": "openzeppelin.utils.constants.library.IACCOUNT_ID", + "type": "alias" + }, + "openzeppelin.account.library.IERC165_ID": { + "destination": "openzeppelin.utils.constants.library.IERC165_ID", + "type": "alias" + }, + "openzeppelin.account.library.SignatureBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", + "type": "alias" + }, + "openzeppelin.account.library.TRANSACTION_VERSION": { + "destination": "openzeppelin.utils.constants.library.TRANSACTION_VERSION", + "type": "alias" + }, + "openzeppelin.account.library.TRUE": { + "destination": "starkware.cairo.common.bool.TRUE", + "type": "alias" + }, + "openzeppelin.account.library.Uint256": { + "destination": "starkware.cairo.common.uint256.Uint256", + "type": "alias" + }, + "openzeppelin.account.library.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "openzeppelin.account.library.call_contract": { + "destination": "starkware.starknet.common.syscalls.call_contract", + "type": "alias" + }, + "openzeppelin.account.library.get_caller_address": { + "destination": "starkware.starknet.common.syscalls.get_caller_address", + "type": "alias" + }, + "openzeppelin.account.library.get_contract_address": { + "destination": "starkware.starknet.common.syscalls.get_contract_address", + "type": "alias" + }, + "openzeppelin.account.library.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "openzeppelin.account.library.get_tx_info": { + "destination": "starkware.starknet.common.syscalls.get_tx_info", + "type": "alias" + }, + "openzeppelin.account.library.is_le_felt": { + "destination": "starkware.cairo.common.math_cmp.is_le_felt", + "type": "alias" + }, + "openzeppelin.account.library.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "openzeppelin.account.library.split_felt": { + "destination": "starkware.cairo.common.math.split_felt", + "type": "alias" + }, + "openzeppelin.account.library.verify_ecdsa_signature": { + "destination": "starkware.cairo.common.signature.verify_ecdsa_signature", + "type": "alias" + }, + "openzeppelin.account.library.verify_eth_signature_uint256": { + "destination": "starkware.cairo.common.cairo_secp.signature.verify_eth_signature_uint256", + "type": "alias" + }, + "openzeppelin.utils.constants.library.DEFAULT_ADMIN_ROLE": { + "type": "const", + "value": 0 + }, + "openzeppelin.utils.constants.library.IACCESSCONTROL_ID": { + "type": "const", + "value": 2036718347 + }, + "openzeppelin.utils.constants.library.IACCOUNT_ID": { + "type": "const", + "value": 2792084853 + }, + "openzeppelin.utils.constants.library.IERC165_ID": { + "type": "const", + "value": 33540519 + }, + "openzeppelin.utils.constants.library.IERC721_ENUMERABLE_ID": { + "type": "const", + "value": 2014223715 + }, + "openzeppelin.utils.constants.library.IERC721_ID": { + "type": "const", + "value": 2158778573 + }, + "openzeppelin.utils.constants.library.IERC721_METADATA_ID": { + "type": "const", + "value": 1532892063 + }, + "openzeppelin.utils.constants.library.IERC721_RECEIVER_ID": { + "type": "const", + "value": 353073666 + }, + "openzeppelin.utils.constants.library.INVALID_ID": { + "type": "const", + "value": 4294967295 + }, + "openzeppelin.utils.constants.library.TRANSACTION_VERSION": { + "type": "const", + "value": 1 + }, + "openzeppelin.utils.constants.library.UINT8_MAX": { + "type": "const", + "value": 255 + }, + "starkware.cairo.common.alloc.alloc": { + "decorators": [], + "pc": 0, + "type": "function" + }, + "starkware.cairo.common.alloc.alloc.Args": { + "full_name": "starkware.cairo.common.alloc.alloc.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.alloc.alloc.ImplicitArgs": { + "full_name": "starkware.cairo.common.alloc.alloc.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.alloc.alloc.Return": { + "cairo_type": "(ptr: felt*)", + "type": "type_definition" + }, + "starkware.cairo.common.alloc.alloc.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.bitwise.ALL_ONES": { + "type": "const", + "value": -106710729501573572985208420194530329073740042555888586719234 + }, + "starkware.cairo.common.bitwise.BitwiseBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "type": "alias" + }, + "starkware.cairo.common.bool.FALSE": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.bool.TRUE": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.cairo_builtins.BitwiseBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "x_and_y": { + "cairo_type": "felt", + "offset": 2 + }, + "x_or_y": { + "cairo_type": "felt", + "offset": 4 + }, + "x_xor_y": { + "cairo_type": "felt", + "offset": 3 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.EcOpBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", + "members": { + "m": { + "cairo_type": "felt", + "offset": 4 + }, + "p": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 0 + }, + "q": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 2 + }, + "r": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 5 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.EcPoint": { + "destination": "starkware.cairo.common.ec_point.EcPoint", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.HashBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "members": { + "result": { + "cairo_type": "felt", + "offset": 2 + }, + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.KeccakBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.KeccakBuiltin", + "members": { + "input": { + "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "offset": 0 + }, + "output": { + "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "offset": 8 + } + }, + "size": 16, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.KeccakBuiltinState": { + "destination": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.SignatureBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", + "members": { + "message": { + "cairo_type": "felt", + "offset": 1 + }, + "pub_key": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.cairo_keccak.keccak.BLOCK_SIZE": { + "destination": "starkware.cairo.common.cairo_keccak.packed_keccak.BLOCK_SIZE", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.BYTES_IN_WORD": { + "type": "const", + "value": 8 + }, + "starkware.cairo.common.cairo_keccak.keccak.BitwiseBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.KECCAK_CAPACITY_IN_WORDS": { + "type": "const", + "value": 8 + }, + "starkware.cairo.common.cairo_keccak.keccak.KECCAK_FULL_RATE_IN_BYTES": { + "type": "const", + "value": 136 + }, + "starkware.cairo.common.cairo_keccak.keccak.KECCAK_FULL_RATE_IN_WORDS": { + "type": "const", + "value": 17 + }, + "starkware.cairo.common.cairo_keccak.keccak.KECCAK_STATE_SIZE_FELTS": { + "type": "const", + "value": 25 + }, + "starkware.cairo.common.cairo_keccak.keccak.Uint256": { + "destination": "starkware.cairo.common.uint256.Uint256", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.assert_lt": { + "destination": "starkware.cairo.common.math.assert_lt", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.assert_nn": { + "destination": "starkware.cairo.common.math.assert_nn", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.assert_nn_le": { + "destination": "starkware.cairo.common.math.assert_nn_le", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.assert_not_zero": { + "destination": "starkware.cairo.common.math.assert_not_zero", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.bitwise_and": { + "destination": "starkware.cairo.common.bitwise.bitwise_and", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.bitwise_or": { + "destination": "starkware.cairo.common.bitwise.bitwise_or", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.bitwise_xor": { + "destination": "starkware.cairo.common.bitwise.bitwise_xor", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.memset": { + "destination": "starkware.cairo.common.memset.memset", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.packed_keccak_func": { + "destination": "starkware.cairo.common.cairo_keccak.packed_keccak.packed_keccak_func", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.pow": { + "destination": "starkware.cairo.common.pow.pow", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.split_felt": { + "destination": "starkware.cairo.common.math.split_felt", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.uint256_reverse_endian": { + "destination": "starkware.cairo.common.uint256.uint256_reverse_endian", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.keccak.unsigned_div_rem": { + "destination": "starkware.cairo.common.math.unsigned_div_rem", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.packed_keccak.ALL_ONES": { + "type": "const", + "value": -106710729501573572985208420194530329073740042555888586719234 + }, + "starkware.cairo.common.cairo_keccak.packed_keccak.BLOCK_SIZE": { + "type": "const", + "value": 3 + }, + "starkware.cairo.common.cairo_keccak.packed_keccak.BitwiseBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.packed_keccak.SHIFTS": { + "type": "const", + "value": 340282366920938463481821351505477763073 + }, + "starkware.cairo.common.cairo_keccak.packed_keccak.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.cairo.common.cairo_keccak.packed_keccak.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.bigint.BASE": { + "destination": "starkware.cairo.common.cairo_secp.constants.BASE", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.bigint.BigInt3": { + "full_name": "starkware.cairo.common.cairo_secp.bigint.BigInt3", + "members": { + "d0": { + "cairo_type": "felt", + "offset": 0 + }, + "d1": { + "cairo_type": "felt", + "offset": 1 + }, + "d2": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.cairo_secp.bigint.RC_BOUND": { + "destination": "starkware.cairo.common.math_cmp.RC_BOUND", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.bigint.Uint256": { + "destination": "starkware.cairo.common.uint256.Uint256", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3": { + "full_name": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3", + "members": { + "d0": { + "cairo_type": "felt", + "offset": 0 + }, + "d1": { + "cairo_type": "felt", + "offset": 1 + }, + "d2": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt5": { + "full_name": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt5", + "members": { + "d0": { + "cairo_type": "felt", + "offset": 0 + }, + "d1": { + "cairo_type": "felt", + "offset": 1 + }, + "d2": { + "cairo_type": "felt", + "offset": 2 + }, + "d3": { + "cairo_type": "felt", + "offset": 3 + }, + "d4": { + "cairo_type": "felt", + "offset": 4 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.common.cairo_secp.bigint.assert_nn": { + "destination": "starkware.cairo.common.math.assert_nn", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.bigint.assert_nn_le": { + "destination": "starkware.cairo.common.math.assert_nn_le", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.bigint.unsigned_div_rem": { + "destination": "starkware.cairo.common.math.unsigned_div_rem", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.constants.BASE": { + "type": "const", + "value": 77371252455336267181195264 + }, + "starkware.cairo.common.cairo_secp.constants.BETA": { + "type": "const", + "value": 7 + }, + "starkware.cairo.common.cairo_secp.constants.N0": { + "type": "const", + "value": 10428087374290690730508609 + }, + "starkware.cairo.common.cairo_secp.constants.N1": { + "type": "const", + "value": 77371252455330678278691517 + }, + "starkware.cairo.common.cairo_secp.constants.N2": { + "type": "const", + "value": 19342813113834066795298815 + }, + "starkware.cairo.common.cairo_secp.constants.P0": { + "type": "const", + "value": 77371252455336262886226991 + }, + "starkware.cairo.common.cairo_secp.constants.P1": { + "type": "const", + "value": 77371252455336267181195263 + }, + "starkware.cairo.common.cairo_secp.constants.P2": { + "type": "const", + "value": 19342813113834066795298815 + }, + "starkware.cairo.common.cairo_secp.constants.SECP_REM": { + "type": "const", + "value": 4294968273 + }, + "starkware.cairo.common.cairo_secp.ec.BigInt3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.BigInt3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.ec.EcPoint": { + "full_name": "starkware.cairo.common.cairo_secp.ec.EcPoint", + "members": { + "x": { + "cairo_type": "starkware.cairo.common.cairo_secp.bigint.BigInt3", + "offset": 0 + }, + "y": { + "cairo_type": "starkware.cairo.common.cairo_secp.bigint.BigInt3", + "offset": 3 + } + }, + "size": 6, + "type": "struct" + }, + "starkware.cairo.common.cairo_secp.ec.UnreducedBigInt3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.ec.is_zero": { + "destination": "starkware.cairo.common.cairo_secp.field.is_zero", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.ec.nondet_bigint3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.nondet_bigint3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.ec.unreduced_mul": { + "destination": "starkware.cairo.common.cairo_secp.field.unreduced_mul", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.ec.unreduced_sqr": { + "destination": "starkware.cairo.common.cairo_secp.field.unreduced_sqr", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.ec.verify_zero": { + "destination": "starkware.cairo.common.cairo_secp.field.verify_zero", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.BASE": { + "destination": "starkware.cairo.common.cairo_secp.constants.BASE", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.BigInt3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.BigInt3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.P0": { + "destination": "starkware.cairo.common.cairo_secp.constants.P0", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.P1": { + "destination": "starkware.cairo.common.cairo_secp.constants.P1", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.P2": { + "destination": "starkware.cairo.common.cairo_secp.constants.P2", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.SECP_REM": { + "destination": "starkware.cairo.common.cairo_secp.constants.SECP_REM", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.UnreducedBigInt3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.assert_nn_le": { + "destination": "starkware.cairo.common.math.assert_nn_le", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.field.nondet_bigint3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.nondet_bigint3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.BASE": { + "destination": "starkware.cairo.common.cairo_secp.bigint.BASE", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.BETA": { + "destination": "starkware.cairo.common.cairo_secp.constants.BETA", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.BigInt3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.BigInt3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.BitwiseBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.EcPoint": { + "destination": "starkware.cairo.common.cairo_secp.ec.EcPoint", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.N0": { + "destination": "starkware.cairo.common.cairo_secp.constants.N0", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.N1": { + "destination": "starkware.cairo.common.cairo_secp.constants.N1", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.N2": { + "destination": "starkware.cairo.common.cairo_secp.constants.N2", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.RC_BOUND": { + "destination": "starkware.cairo.common.math_cmp.RC_BOUND", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.Uint256": { + "destination": "starkware.cairo.common.uint256.Uint256", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.UnreducedBigInt3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.UnreducedBigInt3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.assert_nn": { + "destination": "starkware.cairo.common.math.assert_nn", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.assert_nn_le": { + "destination": "starkware.cairo.common.math.assert_nn_le", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.assert_not_zero": { + "destination": "starkware.cairo.common.math.assert_not_zero", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.bigint_mul": { + "destination": "starkware.cairo.common.cairo_secp.bigint.bigint_mul", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.bigint_to_uint256": { + "destination": "starkware.cairo.common.cairo_secp.bigint.bigint_to_uint256", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.ec_add": { + "destination": "starkware.cairo.common.cairo_secp.ec.ec_add", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.ec_mul": { + "destination": "starkware.cairo.common.cairo_secp.ec.ec_mul", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.ec_negate": { + "destination": "starkware.cairo.common.cairo_secp.ec.ec_negate", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.finalize_keccak": { + "destination": "starkware.cairo.common.cairo_keccak.keccak.finalize_keccak", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.keccak_uint256s_bigend": { + "destination": "starkware.cairo.common.cairo_keccak.keccak.keccak_uint256s_bigend", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.nondet_bigint3": { + "destination": "starkware.cairo.common.cairo_secp.bigint.nondet_bigint3", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.reduce": { + "destination": "starkware.cairo.common.cairo_secp.field.reduce", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.uint256_to_bigint": { + "destination": "starkware.cairo.common.cairo_secp.bigint.uint256_to_bigint", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.unreduced_mul": { + "destination": "starkware.cairo.common.cairo_secp.field.unreduced_mul", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.unreduced_sqr": { + "destination": "starkware.cairo.common.cairo_secp.field.unreduced_sqr", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.unsigned_div_rem": { + "destination": "starkware.cairo.common.math.unsigned_div_rem", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.validate_reduced_field_element": { + "destination": "starkware.cairo.common.cairo_secp.field.validate_reduced_field_element", + "type": "alias" + }, + "starkware.cairo.common.cairo_secp.signature.verify_zero": { + "destination": "starkware.cairo.common.cairo_secp.field.verify_zero", + "type": "alias" + }, + "starkware.cairo.common.dict_access.DictAccess": { + "full_name": "starkware.cairo.common.dict_access.DictAccess", + "members": { + "key": { + "cairo_type": "felt", + "offset": 0 + }, + "new_value": { + "cairo_type": "felt", + "offset": 2 + }, + "prev_value": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.ec.EcOpBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", + "type": "alias" + }, + "starkware.cairo.common.ec.EcPoint": { + "destination": "starkware.cairo.common.ec_point.EcPoint", + "type": "alias" + }, + "starkware.cairo.common.ec.StarkCurve": { + "type": "namespace" + }, + "starkware.cairo.common.ec.StarkCurve.ALPHA": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.ec.StarkCurve.Args": { + "full_name": "starkware.cairo.common.ec.StarkCurve.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.ec.StarkCurve.BETA": { + "type": "const", + "value": -476910135076337975234679399815567221425937815956490878998147463828055613816 + }, + "starkware.cairo.common.ec.StarkCurve.GEN_X": { + "type": "const", + "value": 874739451078007766457464989774322083649278607533249481151382481072868806602 + }, + "starkware.cairo.common.ec.StarkCurve.GEN_Y": { + "type": "const", + "value": 152666792071518830868575557812948353041420400780739481342941381225525861407 + }, + "starkware.cairo.common.ec.StarkCurve.ImplicitArgs": { + "full_name": "starkware.cairo.common.ec.StarkCurve.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.ec.StarkCurve.ORDER": { + "type": "const", + "value": -96363463615509210819012598251359154898 + }, + "starkware.cairo.common.ec.StarkCurve.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.ec.StarkCurve.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.ec.is_quad_residue": { + "destination": "starkware.cairo.common.math.is_quad_residue", + "type": "alias" + }, + "starkware.cairo.common.ec_point.EcPoint": { + "full_name": "starkware.cairo.common.ec_point.EcPoint", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.keccak_state.KeccakBuiltinState": { + "full_name": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "members": { + "s0": { + "cairo_type": "felt", + "offset": 0 + }, + "s1": { + "cairo_type": "felt", + "offset": 1 + }, + "s2": { + "cairo_type": "felt", + "offset": 2 + }, + "s3": { + "cairo_type": "felt", + "offset": 3 + }, + "s4": { + "cairo_type": "felt", + "offset": 4 + }, + "s5": { + "cairo_type": "felt", + "offset": 5 + }, + "s6": { + "cairo_type": "felt", + "offset": 6 + }, + "s7": { + "cairo_type": "felt", + "offset": 7 + } + }, + "size": 8, + "type": "struct" + }, + "starkware.cairo.common.math.FALSE": { + "destination": "starkware.cairo.common.bool.FALSE", + "type": "alias" + }, + "starkware.cairo.common.math.TRUE": { + "destination": "starkware.cairo.common.bool.TRUE", + "type": "alias" + }, + "starkware.cairo.common.math.assert_le_felt": { + "decorators": [ + "known_ap_change" + ], + "pc": 18, + "type": "function" + }, + "starkware.cairo.common.math.assert_le_felt.Args": { + "full_name": "starkware.cairo.common.math.assert_le_felt.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math.assert_le_felt.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_le_felt.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_le_felt.PRIME_OVER_2_HIGH": { + "type": "const", + "value": 5316911983139663648412552867652567041 + }, + "starkware.cairo.common.math.assert_le_felt.PRIME_OVER_3_HIGH": { + "type": "const", + "value": 3544607988759775765608368578435044694 + }, + "starkware.cairo.common.math.assert_le_felt.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_le_felt.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_le_felt.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le_felt.a", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 18, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_le_felt.b": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le_felt.b", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 18, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_le_felt.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le_felt.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 18, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 8 + }, + "pc": 28, + "value": "cast([fp + (-5)] + 4, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_le_felt.skip_exclude_a": { + "pc": 42, + "type": "label" + }, + "starkware.cairo.common.math.assert_le_felt.skip_exclude_b_minus_a": { + "pc": 54, + "type": "label" + }, + "starkware.cairo.common.math.assert_lt_felt": { + "decorators": [ + "known_ap_change" + ], + "pc": 63, + "type": "function" + }, + "starkware.cairo.common.math.assert_lt_felt.Args": { + "full_name": "starkware.cairo.common.math.assert_lt_felt.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math.assert_lt_felt.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_lt_felt.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_lt_felt.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_lt_felt.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_lt_felt.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_lt_felt.a", + "references": [ + { + "ap_tracking_data": { + "group": 3, + "offset": 0 + }, + "pc": 63, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_lt_felt.b": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_lt_felt.b", + "references": [ + { + "ap_tracking_data": { + "group": 3, + "offset": 0 + }, + "pc": 63, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math_cmp.RC_BOUND": { + "type": "const", + "value": 340282366920938463463374607431768211456 + }, + "starkware.cairo.common.math_cmp.assert_le_felt": { + "destination": "starkware.cairo.common.math.assert_le_felt", + "type": "alias" + }, + "starkware.cairo.common.math_cmp.assert_lt_felt": { + "destination": "starkware.cairo.common.math.assert_lt_felt", + "type": "alias" + }, + "starkware.cairo.common.math_cmp.is_le_felt": { + "decorators": [ + "known_ap_change" + ], + "pc": 128, + "type": "function" + }, + "starkware.cairo.common.math_cmp.is_le_felt.Args": { + "full_name": "starkware.cairo.common.math_cmp.is_le_felt.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math_cmp.is_le_felt.ImplicitArgs": { + "full_name": "starkware.cairo.common.math_cmp.is_le_felt.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math_cmp.is_le_felt.Return": { + "cairo_type": "felt", + "type": "type_definition" + }, + "starkware.cairo.common.math_cmp.is_le_felt.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math_cmp.is_le_felt.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math_cmp.is_le_felt.a", + "references": [ + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 128, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math_cmp.is_le_felt.b": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math_cmp.is_le_felt.b", + "references": [ + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 128, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math_cmp.is_le_felt.not_le": { + "pc": 140, + "type": "label" + }, + "starkware.cairo.common.memcpy.memcpy": { + "decorators": [], + "pc": 3, + "type": "function" + }, + "starkware.cairo.common.memcpy.memcpy.Args": { + "full_name": "starkware.cairo.common.memcpy.memcpy.Args", + "members": { + "dst": { + "cairo_type": "felt*", + "offset": 0 + }, + "len": { + "cairo_type": "felt", + "offset": 2 + }, + "src": { + "cairo_type": "felt*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.ImplicitArgs": { + "full_name": "starkware.cairo.common.memcpy.memcpy.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.LoopFrame": { + "full_name": "starkware.cairo.common.memcpy.memcpy.LoopFrame", + "members": { + "dst": { + "cairo_type": "felt*", + "offset": 0 + }, + "src": { + "cairo_type": "felt*", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.memcpy.memcpy.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.memcpy.memcpy.continue_copying": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.continue_copying", + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 3 + }, + "pc": 10, + "value": "[cast(ap, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.len": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.len", + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 0 + }, + "pc": 3, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.loop": { + "pc": 8, + "type": "label" + }, + "starkware.cairo.common.pow.assert_le": { + "destination": "starkware.cairo.common.math.assert_le", + "type": "alias" + }, + "starkware.cairo.common.pow.get_ap": { + "destination": "starkware.cairo.common.registers.get_ap", + "type": "alias" + }, + "starkware.cairo.common.pow.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.common.registers.get_ap": { + "destination": "starkware.cairo.lang.compiler.lib.registers.get_ap", + "type": "alias" + }, + "starkware.cairo.common.registers.get_fp_and_pc": { + "destination": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.common.signature.EcOpBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", + "type": "alias" + }, + "starkware.cairo.common.signature.EcPoint": { + "destination": "starkware.cairo.common.ec_point.EcPoint", + "type": "alias" + }, + "starkware.cairo.common.signature.FALSE": { + "destination": "starkware.cairo.common.bool.FALSE", + "type": "alias" + }, + "starkware.cairo.common.signature.SignatureBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", + "type": "alias" + }, + "starkware.cairo.common.signature.StarkCurve": { + "destination": "starkware.cairo.common.ec.StarkCurve", + "type": "alias" + }, + "starkware.cairo.common.signature.TRUE": { + "destination": "starkware.cairo.common.bool.TRUE", + "type": "alias" + }, + "starkware.cairo.common.signature.ec_add": { + "destination": "starkware.cairo.common.ec.ec_add", + "type": "alias" + }, + "starkware.cairo.common.signature.ec_mul": { + "destination": "starkware.cairo.common.ec.ec_mul", + "type": "alias" + }, + "starkware.cairo.common.signature.ec_sub": { + "destination": "starkware.cairo.common.ec.ec_sub", + "type": "alias" + }, + "starkware.cairo.common.signature.is_x_on_curve": { + "destination": "starkware.cairo.common.ec.is_x_on_curve", + "type": "alias" + }, + "starkware.cairo.common.signature.recover_y": { + "destination": "starkware.cairo.common.ec.recover_y", + "type": "alias" + }, + "starkware.cairo.common.signature.verify_ecdsa_signature": { + "decorators": [], + "pc": 123, + "type": "function" + }, + "starkware.cairo.common.signature.verify_ecdsa_signature.Args": { + "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.Args", + "members": { + "message": { + "cairo_type": "felt", + "offset": 0 + }, + "public_key": { + "cairo_type": "felt", + "offset": 1 + }, + "signature_r": { + "cairo_type": "felt", + "offset": 2 + }, + "signature_s": { + "cairo_type": "felt", + "offset": 3 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.cairo.common.signature.verify_ecdsa_signature.ImplicitArgs": { + "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.ImplicitArgs", + "members": { + "ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.signature.verify_ecdsa_signature.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.signature.verify_ecdsa_signature.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.signature.verify_ecdsa_signature.ecdsa_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.SignatureBuiltin*", + "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.ecdsa_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 123, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.SignatureBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 125, + "value": "cast([fp + (-7)] + 2, starkware.cairo.common.cairo_builtins.SignatureBuiltin*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.signature.verify_ecdsa_signature.signature_r": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.signature_r", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 123, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.signature.verify_ecdsa_signature.signature_s": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.signature.verify_ecdsa_signature.signature_s", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 123, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.uint256.ALL_ONES": { + "type": "const", + "value": 340282366920938463463374607431768211455 + }, + "starkware.cairo.common.uint256.BitwiseBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "type": "alias" + }, + "starkware.cairo.common.uint256.HALF_SHIFT": { + "type": "const", + "value": 18446744073709551616 + }, + "starkware.cairo.common.uint256.SHIFT": { + "type": "const", + "value": 340282366920938463463374607431768211456 + }, + "starkware.cairo.common.uint256.Uint256": { + "full_name": "starkware.cairo.common.uint256.Uint256", + "members": { + "high": { + "cairo_type": "felt", + "offset": 1 + }, + "low": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.uint256.assert_in_range": { + "destination": "starkware.cairo.common.math.assert_in_range", + "type": "alias" + }, + "starkware.cairo.common.uint256.assert_le": { + "destination": "starkware.cairo.common.math.assert_le", + "type": "alias" + }, + "starkware.cairo.common.uint256.assert_nn_le": { + "destination": "starkware.cairo.common.math.assert_nn_le", + "type": "alias" + }, + "starkware.cairo.common.uint256.assert_not_zero": { + "destination": "starkware.cairo.common.math.assert_not_zero", + "type": "alias" + }, + "starkware.cairo.common.uint256.bitwise_and": { + "destination": "starkware.cairo.common.bitwise.bitwise_and", + "type": "alias" + }, + "starkware.cairo.common.uint256.bitwise_or": { + "destination": "starkware.cairo.common.bitwise.bitwise_or", + "type": "alias" + }, + "starkware.cairo.common.uint256.bitwise_xor": { + "destination": "starkware.cairo.common.bitwise.bitwise_xor", + "type": "alias" + }, + "starkware.cairo.common.uint256.get_ap": { + "destination": "starkware.cairo.common.registers.get_ap", + "type": "alias" + }, + "starkware.cairo.common.uint256.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.common.uint256.is_le": { + "destination": "starkware.cairo.common.math_cmp.is_le", + "type": "alias" + }, + "starkware.cairo.common.uint256.pow": { + "destination": "starkware.cairo.common.pow.pow", + "type": "alias" + }, + "starkware.starknet.common.storage.ADDR_BOUND": { + "type": "const", + "value": -106710729501573572985208420194530329073740042555888586719489 + }, + "starkware.starknet.common.storage.MAX_STORAGE_ITEM_SIZE": { + "type": "const", + "value": 256 + }, + "starkware.starknet.common.storage.assert_250_bit": { + "destination": "starkware.cairo.common.math.assert_250_bit", + "type": "alias" + }, + "starkware.starknet.common.syscalls.CALL_CONTRACT_SELECTOR": { + "type": "const", + "value": 20853273475220472486191784820 + }, + "starkware.starknet.common.syscalls.CallContract": { + "full_name": "starkware.starknet.common.syscalls.CallContract", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.CallContractRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.CallContractResponse", + "offset": 5 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.starknet.common.syscalls.CallContractRequest": { + "full_name": "starkware.starknet.common.syscalls.CallContractRequest", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 4 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 3 + }, + "contract_address": { + "cairo_type": "felt", + "offset": 1 + }, + "function_selector": { + "cairo_type": "felt", + "offset": 2 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.common.syscalls.CallContractResponse": { + "full_name": "starkware.starknet.common.syscalls.CallContractResponse", + "members": { + "retdata": { + "cairo_type": "felt*", + "offset": 1 + }, + "retdata_size": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.DELEGATE_CALL_SELECTOR": { + "type": "const", + "value": 21167594061783206823196716140 + }, + "starkware.starknet.common.syscalls.DELEGATE_L1_HANDLER_SELECTOR": { + "type": "const", + "value": 23274015802972845247556842986379118667122 + }, + "starkware.starknet.common.syscalls.DEPLOY_SELECTOR": { + "type": "const", + "value": 75202468540281 + }, + "starkware.starknet.common.syscalls.Deploy": { + "full_name": "starkware.starknet.common.syscalls.Deploy", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.DeployRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.DeployResponse", + "offset": 6 + } + }, + "size": 9, + "type": "struct" + }, + "starkware.starknet.common.syscalls.DeployRequest": { + "full_name": "starkware.starknet.common.syscalls.DeployRequest", + "members": { + "class_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "constructor_calldata": { + "cairo_type": "felt*", + "offset": 4 + }, + "constructor_calldata_size": { + "cairo_type": "felt", + "offset": 3 + }, + "contract_address_salt": { + "cairo_type": "felt", + "offset": 2 + }, + "deploy_from_zero": { + "cairo_type": "felt", + "offset": 5 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 6, + "type": "struct" + }, + "starkware.starknet.common.syscalls.DeployResponse": { + "full_name": "starkware.starknet.common.syscalls.DeployResponse", + "members": { + "constructor_retdata": { + "cairo_type": "felt*", + "offset": 2 + }, + "constructor_retdata_size": { + "cairo_type": "felt", + "offset": 1 + }, + "contract_address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.common.syscalls.DictAccess": { + "destination": "starkware.cairo.common.dict_access.DictAccess", + "type": "alias" + }, + "starkware.starknet.common.syscalls.EMIT_EVENT_SELECTOR": { + "type": "const", + "value": 1280709301550335749748 + }, + "starkware.starknet.common.syscalls.EmitEvent": { + "full_name": "starkware.starknet.common.syscalls.EmitEvent", + "members": { + "data": { + "cairo_type": "felt*", + "offset": 4 + }, + "data_len": { + "cairo_type": "felt", + "offset": 3 + }, + "keys": { + "cairo_type": "felt*", + "offset": 2 + }, + "keys_len": { + "cairo_type": "felt", + "offset": 1 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GET_BLOCK_NUMBER_SELECTOR": { + "type": "const", + "value": 1448089106835523001438702345020786 + }, + "starkware.starknet.common.syscalls.GET_BLOCK_TIMESTAMP_SELECTOR": { + "type": "const", + "value": 24294903732626645868215235778792757751152 + }, + "starkware.starknet.common.syscalls.GET_CALLER_ADDRESS_SELECTOR": { + "type": "const", + "value": 94901967781393078444254803017658102643 + }, + "starkware.starknet.common.syscalls.GET_CONTRACT_ADDRESS_SELECTOR": { + "type": "const", + "value": 6219495360805491471215297013070624192820083 + }, + "starkware.starknet.common.syscalls.GET_SEQUENCER_ADDRESS_SELECTOR": { + "type": "const", + "value": 1592190833581991703053805829594610833820054387 + }, + "starkware.starknet.common.syscalls.GET_TX_INFO_SELECTOR": { + "type": "const", + "value": 1317029390204112103023 + }, + "starkware.starknet.common.syscalls.GET_TX_SIGNATURE_SELECTOR": { + "type": "const", + "value": 1448089128652340074717162277007973 + }, + "starkware.starknet.common.syscalls.GetBlockNumber": { + "full_name": "starkware.starknet.common.syscalls.GetBlockNumber", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetBlockNumberRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetBlockNumberResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockNumberRequest": { + "full_name": "starkware.starknet.common.syscalls.GetBlockNumberRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockNumberResponse": { + "full_name": "starkware.starknet.common.syscalls.GetBlockNumberResponse", + "members": { + "block_number": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockTimestamp": { + "full_name": "starkware.starknet.common.syscalls.GetBlockTimestamp", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetBlockTimestampRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetBlockTimestampResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockTimestampRequest": { + "full_name": "starkware.starknet.common.syscalls.GetBlockTimestampRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockTimestampResponse": { + "full_name": "starkware.starknet.common.syscalls.GetBlockTimestampResponse", + "members": { + "block_timestamp": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetCallerAddress": { + "full_name": "starkware.starknet.common.syscalls.GetCallerAddress", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetCallerAddressRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetCallerAddressResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetCallerAddressRequest": { + "full_name": "starkware.starknet.common.syscalls.GetCallerAddressRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetCallerAddressResponse": { + "full_name": "starkware.starknet.common.syscalls.GetCallerAddressResponse", + "members": { + "caller_address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetContractAddress": { + "full_name": "starkware.starknet.common.syscalls.GetContractAddress", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetContractAddressRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetContractAddressResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetContractAddressRequest": { + "full_name": "starkware.starknet.common.syscalls.GetContractAddressRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetContractAddressResponse": { + "full_name": "starkware.starknet.common.syscalls.GetContractAddressResponse", + "members": { + "contract_address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetSequencerAddress": { + "full_name": "starkware.starknet.common.syscalls.GetSequencerAddress", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetSequencerAddressRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetSequencerAddressResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetSequencerAddressRequest": { + "full_name": "starkware.starknet.common.syscalls.GetSequencerAddressRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetSequencerAddressResponse": { + "full_name": "starkware.starknet.common.syscalls.GetSequencerAddressResponse", + "members": { + "sequencer_address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxInfo": { + "full_name": "starkware.starknet.common.syscalls.GetTxInfo", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetTxInfoRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetTxInfoResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxInfoRequest": { + "full_name": "starkware.starknet.common.syscalls.GetTxInfoRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxInfoResponse": { + "full_name": "starkware.starknet.common.syscalls.GetTxInfoResponse", + "members": { + "tx_info": { + "cairo_type": "starkware.starknet.common.syscalls.TxInfo*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxSignature": { + "full_name": "starkware.starknet.common.syscalls.GetTxSignature", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetTxSignatureRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetTxSignatureResponse", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxSignatureRequest": { + "full_name": "starkware.starknet.common.syscalls.GetTxSignatureRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxSignatureResponse": { + "full_name": "starkware.starknet.common.syscalls.GetTxSignatureResponse", + "members": { + "signature": { + "cairo_type": "felt*", + "offset": 1 + }, + "signature_len": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.LIBRARY_CALL_L1_HANDLER_SELECTOR": { + "type": "const", + "value": 436233452754198157705746250789557519228244616562 + }, + "starkware.starknet.common.syscalls.LIBRARY_CALL_SELECTOR": { + "type": "const", + "value": 92376026794327011772951660 + }, + "starkware.starknet.common.syscalls.LibraryCall": { + "full_name": "starkware.starknet.common.syscalls.LibraryCall", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.LibraryCallRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.CallContractResponse", + "offset": 5 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.starknet.common.syscalls.LibraryCallRequest": { + "full_name": "starkware.starknet.common.syscalls.LibraryCallRequest", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 4 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 3 + }, + "class_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "function_selector": { + "cairo_type": "felt", + "offset": 2 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.common.syscalls.SEND_MESSAGE_TO_L1_SELECTOR": { + "type": "const", + "value": 433017908768303439907196859243777073 + }, + "starkware.starknet.common.syscalls.STORAGE_READ_SELECTOR": { + "type": "const", + "value": 100890693370601760042082660 + }, + "starkware.starknet.common.syscalls.STORAGE_WRITE_SELECTOR": { + "type": "const", + "value": 25828017502874050592466629733 + }, + "starkware.starknet.common.syscalls.SendMessageToL1SysCall": { + "full_name": "starkware.starknet.common.syscalls.SendMessageToL1SysCall", + "members": { + "payload_ptr": { + "cairo_type": "felt*", + "offset": 3 + }, + "payload_size": { + "cairo_type": "felt", + "offset": 2 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + }, + "to_address": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.starknet.common.syscalls.StorageRead": { + "full_name": "starkware.starknet.common.syscalls.StorageRead", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.StorageReadRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.StorageReadResponse", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.common.syscalls.StorageReadRequest": { + "full_name": "starkware.starknet.common.syscalls.StorageReadRequest", + "members": { + "address": { + "cairo_type": "felt", + "offset": 1 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.StorageReadResponse": { + "full_name": "starkware.starknet.common.syscalls.StorageReadResponse", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.StorageWrite": { + "full_name": "starkware.starknet.common.syscalls.StorageWrite", + "members": { + "address": { + "cairo_type": "felt", + "offset": 1 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + }, + "value": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.common.syscalls.TxInfo": { + "full_name": "starkware.starknet.common.syscalls.TxInfo", + "members": { + "account_contract_address": { + "cairo_type": "felt", + "offset": 1 + }, + "chain_id": { + "cairo_type": "felt", + "offset": 6 + }, + "max_fee": { + "cairo_type": "felt", + "offset": 2 + }, + "nonce": { + "cairo_type": "felt", + "offset": 7 + }, + "signature": { + "cairo_type": "felt*", + "offset": 4 + }, + "signature_len": { + "cairo_type": "felt", + "offset": 3 + }, + "transaction_hash": { + "cairo_type": "felt", + "offset": 5 + }, + "version": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 8, + "type": "struct" + }, + "starkware.starknet.common.syscalls.call_contract": { + "decorators": [], + "pc": 74, + "type": "function" + }, + "starkware.starknet.common.syscalls.call_contract.Args": { + "full_name": "starkware.starknet.common.syscalls.call_contract.Args", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 3 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 2 + }, + "contract_address": { + "cairo_type": "felt", + "offset": 0 + }, + "function_selector": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.starknet.common.syscalls.call_contract.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.call_contract.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.call_contract.Return": { + "cairo_type": "(retdata_size: felt, retdata: felt*)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.call_contract.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.call_contract.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.call_contract.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 74, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 1 + }, + "pc": 81, + "value": "cast([fp + (-7)] + 7, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.get_caller_address": { + "decorators": [], + "pc": 86, + "type": "function" + }, + "starkware.starknet.common.syscalls.get_caller_address.Args": { + "full_name": "starkware.starknet.common.syscalls.get_caller_address.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_caller_address.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.get_caller_address.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_caller_address.Return": { + "cairo_type": "(caller_address: felt)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.get_caller_address.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 86, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 5, + "offset": 1 + }, + "pc": 89, + "value": "cast([fp + (-3)] + 2, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.get_contract_address": { + "decorators": [], + "pc": 93, + "type": "function" + }, + "starkware.starknet.common.syscalls.get_contract_address.Args": { + "full_name": "starkware.starknet.common.syscalls.get_contract_address.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_contract_address.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.get_contract_address.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_contract_address.Return": { + "cairo_type": "(contract_address: felt)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.get_contract_address.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.get_contract_address.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.get_contract_address.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 6, + "offset": 0 + }, + "pc": 93, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 6, + "offset": 1 + }, + "pc": 96, + "value": "cast([fp + (-3)] + 2, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.get_tx_info": { + "decorators": [], + "pc": 116, + "type": "function" + }, + "starkware.starknet.common.syscalls.get_tx_info.Args": { + "full_name": "starkware.starknet.common.syscalls.get_tx_info.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_tx_info.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.get_tx_info.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_tx_info.Return": { + "cairo_type": "(tx_info: starkware.starknet.common.syscalls.TxInfo*)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.get_tx_info.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.get_tx_info.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.get_tx_info.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 9, + "offset": 0 + }, + "pc": 116, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 1 + }, + "pc": 119, + "value": "cast([fp + (-3)] + 2, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.storage_read": { + "decorators": [], + "pc": 100, + "type": "function" + }, + "starkware.starknet.common.syscalls.storage_read.Args": { + "full_name": "starkware.starknet.common.syscalls.storage_read.Args", + "members": { + "address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.storage_read.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.storage_read.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.storage_read.Return": { + "cairo_type": "(value: felt)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.storage_read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.storage_read.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.storage_read.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 100, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 1 + }, + "pc": 104, + "value": "cast([fp + (-4)] + 3, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.storage_write": { + "decorators": [], + "pc": 108, + "type": "function" + }, + "starkware.starknet.common.syscalls.storage_write.Args": { + "full_name": "starkware.starknet.common.syscalls.storage_write.Args", + "members": { + "address": { + "cairo_type": "felt", + "offset": 0 + }, + "value": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.storage_write.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.storage_write.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.storage_write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.storage_write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.storage_write.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.storage_write.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 108, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 1 + }, + "pc": 113, + "value": "cast([fp + (-5)] + 3, felt*)" + } + ], + "type": "reference" + } + }, + "main_scope": "__main__", + "prime": "0x800000000000011000000000000000000000000000000000000000000000001", + "reference_manager": { + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 0 + }, + "pc": 3, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 1, + "offset": 3 + }, + "pc": 10, + "value": "[cast(ap, felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 18, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 18, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 18, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 3, + "offset": 0 + }, + "pc": 63, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 3, + "offset": 0 + }, + "pc": 63, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 74, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 86, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 6, + "offset": 0 + }, + "pc": 93, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 100, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 108, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 0 + }, + "pc": 116, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 123, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 123, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 123, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.SignatureBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 128, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 128, + "value": "[cast(fp + (-3), felt*)]" + } + ] + } + } } diff --git a/crates/katana/primitives/src/block.rs b/crates/katana/primitives/src/block.rs index a40b7c8433..1a53ef82d2 100644 --- a/crates/katana/primitives/src/block.rs +++ b/crates/katana/primitives/src/block.rs @@ -32,6 +32,7 @@ pub enum FinalityStatus { #[derive(Debug, Clone)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct PartialHeader { + pub number: BlockNumber, pub parent_hash: FieldElement, pub gas_prices: GasPrices, pub timestamp: u64, @@ -108,7 +109,7 @@ impl Header { } /// Represents a Starknet full block. -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Default, Clone, PartialEq, Eq)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] pub struct Block { pub header: Header, @@ -189,6 +190,7 @@ impl From for BlockHashOrNumber { /// A block that can executed. This is a block whose transactions includes /// all the necessary information to be executed. +#[derive(Debug, Clone)] pub struct ExecutableBlock { pub header: PartialHeader, pub body: Vec, diff --git a/crates/katana/rpc/rpc/src/starknet.rs b/crates/katana/rpc/rpc/src/starknet.rs index 85b273176a..ffd9a49c53 100644 --- a/crates/katana/rpc/rpc/src/starknet.rs +++ b/crates/katana/rpc/rpc/src/starknet.rs @@ -171,6 +171,7 @@ impl StarknetApiServer for StarknetApi { }; let header = PartialHeader { + number: block_env.number, gas_prices, parent_hash: latest_hash, version: CURRENT_STARKNET_VERSION, @@ -252,6 +253,7 @@ impl StarknetApiServer for StarknetApi { }; let header = PartialHeader { + number: block_env.number, gas_prices, parent_hash: latest_hash, version: CURRENT_STARKNET_VERSION, diff --git a/crates/katana/storage/provider/Cargo.toml b/crates/katana/storage/provider/Cargo.toml index 653628a59a..d4b7c26bf5 100644 --- a/crates/katana/storage/provider/Cargo.toml +++ b/crates/katana/storage/provider/Cargo.toml @@ -31,8 +31,8 @@ katana-core = { path = "../../core" } katana-runner.workspace = true lazy_static.workspace = true rand = "0.8.5" -rstest = "0.18.2" -rstest_reuse = "0.6.0" +rstest.workspace = true +rstest_reuse.workspace = true serde_json.workspace = true starknet.workspace = true tempfile = "3.8.1"