From f9f5f681380e859897beb58b9a0356fab0e3ceb5 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 29 Mar 2023 16:06:23 +0200 Subject: [PATCH 01/27] added conversion of StarkFelt to web3::types::U256 + unit test --- Cargo.toml | 2 +- src/hash.rs | 6 ++++++ src/hash_test.rs | 10 ++++++++++ 3 files changed, 17 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 1ba574b5..b9474023 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,7 +11,7 @@ hex = { version = "0.4.3" } indexmap = { version = "1.9.2", features = ["serde"] } once_cell = { version = "1.16.0" } serde = { version = "1.0.130", features = ["derive", "rc"] } -serde_json = { version = "1.0.81" } +serde_json = { version = "1.0.81", features = ["preserve_order"] } starknet-crypto = { version = "0.2.0" } thiserror = { version = "1.0.31" } web3 = { version = "0.18.0" } diff --git a/src/hash.rs b/src/hash.rs index ea6bd60a..95fd4823 100644 --- a/src/hash.rs +++ b/src/hash.rs @@ -200,6 +200,12 @@ impl TryFrom for usize { } } +impl From for web3::types::U256{ + fn from(felt: StarkFelt) -> Self { + return web3::types::U256::from_big_endian(&felt.0); + } +} + impl Debug for StarkFelt { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { self.str_format(f) diff --git a/src/hash_test.rs b/src/hash_test.rs index 207a9809..0535a70d 100644 --- a/src/hash_test.rs +++ b/src/hash_test.rs @@ -1,3 +1,5 @@ +use web3::types::U256; + use crate::hash::{pedersen_hash, pedersen_hash_array, StarkFelt}; use crate::stark_felt; @@ -67,3 +69,11 @@ fn hash_serde() { assert_eq!(bytes, d.0); } } + +#[test] +fn stark_felt_from_hex_to_decimal(){ + let felt = stark_felt!("0x264d6571d5f186bab2a9d5d8d30aa38bf5502bc4354870edbfe194c6f655c9b"); + let felt_decimal = U256::from(felt); + assert_eq!(felt_decimal, felt.into()); + assert_eq!(felt_decimal.to_string(), "1082789725971120866445625682125121757273101071727151005357998861560691645595"); +} From 793df440236fd74f1caf2415e8889e66f1a2d4ff Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 29 Mar 2023 20:43:52 +0200 Subject: [PATCH 02/27] Added a struct for starkfelt that serializes to decimal string --- src/hash.rs | 26 +++++++++++++++++++++++++- src/hash_test.rs | 7 ++----- 2 files changed, 27 insertions(+), 6 deletions(-) diff --git a/src/hash.rs b/src/hash.rs index 95fd4823..ccd732f1 100644 --- a/src/hash.rs +++ b/src/hash.rs @@ -7,6 +7,7 @@ use std::io::Error; use serde::{Deserialize, Serialize}; use starknet_crypto::{pedersen_hash as starknet_crypto_pedersen_hash, FieldElement}; +use web3::types::U256; use crate::serde_utils::{ bytes_from_hex_str, hex_str_from_bytes, BytesAsHex, NonPrefixedBytesAsHex, PrefixedBytesAsHex, @@ -49,6 +50,23 @@ pub fn pedersen_hash_array(felts: &[StarkFelt]) -> StarkHash { #[serde(try_from = "PrefixedBytesAsHex<32_usize>", into = "PrefixedBytesAsHex<32_usize>")] pub struct StarkFelt([u8; 32]); +#[derive(Clone, Copy, Eq, PartialEq, Default)] +pub struct StarkFeltAsDecimal(U256); + +impl Serialize for StarkFeltAsDecimal{ + fn serialize(&self, serializer: S) -> Result + where + S: serde::Serializer { + serializer.serialize_str(&self.0.to_string()) + } +} + +impl Display for StarkFeltAsDecimal{ + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + return f.write_str(&self.0.to_string()); + } +} + impl StarkFelt { /// Returns a new [`StarkFelt`]. pub fn new(bytes: [u8; 32]) -> Result { @@ -200,12 +218,18 @@ impl TryFrom for usize { } } -impl From for web3::types::U256{ +impl From for U256{ fn from(felt: StarkFelt) -> Self { return web3::types::U256::from_big_endian(&felt.0); } } +impl From for StarkFeltAsDecimal{ + fn from(felt: StarkFelt) -> Self { + return StarkFeltAsDecimal(U256::from(felt)); + } +} + impl Debug for StarkFelt { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { self.str_format(f) diff --git a/src/hash_test.rs b/src/hash_test.rs index 0535a70d..bcb82433 100644 --- a/src/hash_test.rs +++ b/src/hash_test.rs @@ -1,6 +1,4 @@ -use web3::types::U256; - -use crate::hash::{pedersen_hash, pedersen_hash_array, StarkFelt}; +use crate::hash::{pedersen_hash, pedersen_hash_array, StarkFelt, StarkFeltAsDecimal}; use crate::stark_felt; #[test] @@ -73,7 +71,6 @@ fn hash_serde() { #[test] fn stark_felt_from_hex_to_decimal(){ let felt = stark_felt!("0x264d6571d5f186bab2a9d5d8d30aa38bf5502bc4354870edbfe194c6f655c9b"); - let felt_decimal = U256::from(felt); - assert_eq!(felt_decimal, felt.into()); + let felt_decimal = StarkFeltAsDecimal::from(felt); assert_eq!(felt_decimal.to_string(), "1082789725971120866445625682125121757273101071727151005357998861560691645595"); } From 23fd213db9888aa046bf2e6166b8a3472d54b472 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Thu, 30 Mar 2023 10:41:05 +0200 Subject: [PATCH 03/27] added starknet_keccak function --- src/hash.rs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/src/hash.rs b/src/hash.rs index ccd732f1..b4bc501b 100644 --- a/src/hash.rs +++ b/src/hash.rs @@ -6,9 +6,9 @@ use std::fmt::{Debug, Display}; use std::io::Error; use serde::{Deserialize, Serialize}; +use sha3::Digest; use starknet_crypto::{pedersen_hash as starknet_crypto_pedersen_hash, FieldElement}; use web3::types::U256; - use crate::serde_utils::{ bytes_from_hex_str, hex_str_from_bytes, BytesAsHex, NonPrefixedBytesAsHex, PrefixedBytesAsHex, }; @@ -44,6 +44,18 @@ pub fn pedersen_hash_array(felts: &[StarkFelt]) -> StarkHash { pedersen_hash(¤t_hash, &data_len) } +/// Starknet Keccak Hash +pub fn sn_keccak(data: &[u8]) -> String{ + let keccak256 = sha3::Keccak256::digest(data); + let number = U256::from_big_endian(keccak256.as_slice()); + let mask = U256::pow(U256::from(2), U256::from(250)) - U256::from(1); + let masked_number = number & mask; + let mut res_bytes:[u8;32] = [0;32]; + masked_number.to_big_endian(&mut res_bytes); + + return format!("0x{}", hex::encode(res_bytes).trim_start_matches('0')); +} + // TODO: Move to a different crate. /// The StarkNet [field element](https://docs.starknet.io/documentation/architecture_and_concepts/Hashing/hash-functions/#domain_and_range). #[derive(Copy, Clone, Eq, PartialEq, Default, Hash, Deserialize, Serialize, PartialOrd, Ord)] From 5e4715b1767fea0b1e161a0840c910cb3dcd77b3 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Thu, 30 Mar 2023 10:49:41 +0200 Subject: [PATCH 04/27] made serde serde json use arbitrary precision --- Cargo.toml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index b9474023..87c6e802 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,8 +10,9 @@ testing = [] hex = { version = "0.4.3" } indexmap = { version = "1.9.2", features = ["serde"] } once_cell = { version = "1.16.0" } +sha3 = "0.10.6" serde = { version = "1.0.130", features = ["derive", "rc"] } -serde_json = { version = "1.0.81", features = ["preserve_order"] } +serde_json = { version = "1.0.81", features = ["preserve_order", "arbitrary_precision"] } starknet-crypto = { version = "0.2.0" } thiserror = { version = "1.0.31" } web3 = { version = "0.18.0" } From f010b317ef331a4cd5028f4cab4d785507a0fe32 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Thu, 30 Mar 2023 10:50:05 +0200 Subject: [PATCH 05/27] json formatter for starknet --- src/serde_utils.rs | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/src/serde_utils.rs b/src/serde_utils.rs index a040612b..8cc76907 100644 --- a/src/serde_utils.rs +++ b/src/serde_utils.rs @@ -125,3 +125,36 @@ pub fn hex_str_from_bytes(bytes: [u8; N]) hex_str = if hex_str.is_empty() { "0" } else { hex_str }; if PREFIXED { format!("0x{hex_str}") } else { hex_str.to_string() } } + +use std::io; + +use serde_json::ser::Formatter; +pub struct StarknetFormatter; + +impl Formatter for StarknetFormatter{ + fn begin_object_value(&mut self, writer: &mut W) -> io::Result<()> + where + W: ?Sized + io::Write, { + writer.write_all(b": ") + } + + fn begin_object_key(&mut self, writer: &mut W, first: bool) -> io::Result<()> + where + W: ?Sized + io::Write, { + if first { + Ok(()) + } else { + writer.write_all(b", ") + } + } + + fn begin_array_value(&mut self, writer: &mut W, first: bool) -> io::Result<()> + where + W: ?Sized + io::Write, { + if first { + Ok(()) + } else { + writer.write_all(b", ") + } + } +} \ No newline at end of file From f802d3183b11e43295aca27d21392d8642cdf032 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Thu, 30 Mar 2023 10:51:00 +0200 Subject: [PATCH 06/27] methods for removing entries from a json obj, when used with serde json feature "preserve_order" --- src/utils.rs | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 src/utils.rs diff --git a/src/utils.rs b/src/utils.rs new file mode 100644 index 00000000..7d85d7cb --- /dev/null +++ b/src/utils.rs @@ -0,0 +1,78 @@ +use serde_json::Value; + +/// because of the preserve_order feature enabled in the serde_json crate +/// removing a key from the object changes the order of the keys +/// When serde_json is not being used with the preserver order feature +/// deserializing to a serde_json::Value changes the order of the keys +/// +/// go through the object by visiting every key and value recursively, +/// and not including them into a new json obj if the condition is met +/// Empty objects are not included +pub fn traverse_and_exclude_recursively( + value: &Value, + new_object: &mut serde_json::Map, + condition: &F +) -> serde_json::Value where F: Fn(&String, &Value) -> bool{ + match value { + Value::Object(object) => { + for (key, value) in object { + let mut inner_obj = serde_json::Map::new(); + + if condition(key, &value){ + continue + } + + let inner_val = traverse_and_exclude_recursively(value, &mut inner_obj, condition); + + new_object.insert(key.to_string(), inner_val); + } + + return Value::Object(new_object.clone()); + } + // arrays are visited like the objects - recursively + Value::Array(array) => { + let mut inner_arr = Vec::::new(); + + for value in array { + let mut inner_obj = serde_json::Map::new(); + let inner_val = traverse_and_exclude_recursively(value, &mut inner_obj, condition); + + if !(inner_val.is_object() && inner_val.as_object().unwrap().is_empty()){ + inner_arr.push(inner_val) + } + } + + return Value::Array(inner_arr); + } + // handle non-object, non-array values + _ => { + return value.clone(); + } + } +} + +/// because of the preserve_order feature enabled in the serde_json crate +/// removing a key from the object changes the order of the keys +/// When serde_json is not being used with the preserver order feature +/// deserializing to a serde_json::Value changes the order of the keys +/// Go through object's top level keys and remove those that pass the condition +pub fn traverse_and_exclude_top_level_keys( + value: &Value, + condition: &F +) -> serde_json::Value where F: Fn(&String, &Value) -> bool{ + if !value.is_object(){ + return value.clone(); + } + + let mut new_obj = serde_json::Map::new(); + + for (key, value) in value.as_object().unwrap(){ + if condition(key, value) { + continue; + } + + new_obj.insert(key.clone(), value.clone()); + } + + return Value::Object(new_obj); +} From 90ebeb7e046ec80d291bd04e780d83db5c3d2e3c Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Thu, 30 Mar 2023 10:51:35 +0200 Subject: [PATCH 07/27] unit tests for json obj modification and convertion --- src/serde_utils_test.rs | 78 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) diff --git a/src/serde_utils_test.rs b/src/serde_utils_test.rs index d2edc3ad..49684724 100644 --- a/src/serde_utils_test.rs +++ b/src/serde_utils_test.rs @@ -3,6 +3,7 @@ use assert_matches::assert_matches; use crate::serde_utils::{ bytes_from_hex_str, hex_str_from_bytes, BytesAsHex, InnerDeserializationError, }; +use serde_json::Value; #[test] fn hex_str_from_bytes_scenarios() { @@ -108,3 +109,80 @@ fn hex_as_bytes_serde_not_prefixed() { serde_json::from_str(&serde_json::to_string(&hex_as_bytes).unwrap()).unwrap() ); } + + +#[test] +fn serde_deserialize_big_numbers_without_scientific_notation(){ + let input = r#"{ + "value": 20853273475220472486191784820 + }"#; + let json:serde_json::Value = serde_json::from_str(&input).unwrap(); + assert_eq!(json["value"].to_string(), "20853273475220472486191784820"); +} + +#[test] +fn serde_remove_elements_from_json(){ + let input = r#" + { + "name": "John Doe", + "isStudent": true, + "age":30, + "address": { + "street": "Vlvo", + "city": "Anytown", + "state": "Any" + }, + "should_be_removed": [], + "scores": + [ + { + "street": "AAA", + "age": 5, + "should_be_removed": [] + }, + { + "age": 5 + } + ], + "arr": [90, 85, 95] + } + "#; + + let expected_output = r#" + { + "name": "John Doe", + "isStudent": true, + "age":30, + "address": { + "street": "Vlvo", + "city": "Anytown", + "state": "Any" + }, + "scores": + [ + { + "street": "AAA", + "age": 5 + }, + { + "age": 5 + } + ], + "arr": [90, 85, 95] + } + "#; + + let value: Value = serde_json::from_str(input).unwrap(); + let mut new_object: serde_json::Map = serde_json::Map::new(); + + let res = crate::utils::traverse_and_exclude_recursively( + &value, + &mut new_object, + &|key, val| { + return key=="should_be_removed" && + val.is_array() && + val.as_array().unwrap().is_empty() + }); + + assert_eq!(res, serde_json::from_str::(expected_output).unwrap()); +} From 9362cb8c7f7063b97e4b34cfc7906e72249b473e Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Thu, 30 Mar 2023 10:52:08 +0200 Subject: [PATCH 08/27] method for computing contract class hash --- resources/contract_compiled.json | 4875 ++++++++++++++++++++++++++++++ src/core.rs | 111 + src/core_test.rs | 12 + src/lib.rs | 1 + 4 files changed, 4999 insertions(+) create mode 100644 resources/contract_compiled.json diff --git a/resources/contract_compiled.json b/resources/contract_compiled.json new file mode 100644 index 00000000..b1d17432 --- /dev/null +++ b/resources/contract_compiled.json @@ -0,0 +1,4875 @@ +{ + "abi": [ + { + "inputs": [ + { + "name": "amount", + "type": "felt" + } + ], + "name": "increase_balance", + "outputs": [], + "type": "function" + }, + { + "inputs": [], + "name": "get_balance", + "outputs": [ + { + "name": "res", + "type": "felt" + } + ], + "stateMutability": "view", + "type": "function" + } + ], + "entry_points_by_type": { + "CONSTRUCTOR": [], + "EXTERNAL": [ + { + "offset": "0x3a", + "selector": "0x362398bec32bc0ebb411203221a35a0301193a96f317ebe5e40be9f60d15320" + }, + { + "offset": "0x5b", + "selector": "0x39e11d48192e4333233c7eb19d10ad67c362bb28580c604d67884c85da39695" + } + ], + "L1_HANDLER": [] + }, + "program": { + "attributes": [], + "builtins": [ + "pedersen", + "range_check" + ], + "compiler_version": "0.10.3", + "data": [ + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280007ffc7fff", + "0x400380017ffc7ffd", + "0x482680017ffc8000", + "0x3", + "0x480280027ffc8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280007ffb7fff", + "0x400380017ffb7ffc", + "0x400380027ffb7ffd", + "0x482680017ffb8000", + "0x3", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x206f38f7e4f15e87567361213c28f235cccdaa1d7fd34c9db1dfe9489c6a091", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffa", + "0x480a7ffb7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe6", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffed", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe0", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe5", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48287ffd7ffc8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffec", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc7", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x4003800080007ffc", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4828800080007ffe", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x402b7ffd7ffc7ffd", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff1", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe" + ], + "debug_info": { + "file_contents": { + "autogen/starknet/arg_processor/01cba52f8515996bb9d7070bde81ff39281d096d7024a558efcba6e1fd2402cf.cairo": "assert [cast(fp + (-4), felt*)] = __calldata_actual_size;\n", + "autogen/starknet/arg_processor/293368f3a0e12cfcf22314a31e13b9801e95a5b8b2b71822a2fbbdf5a01ea795.cairo": "assert [__return_value_ptr] = ret_value.res;\nlet __return_value_ptr = __return_value_ptr + 1;\n", + "autogen/starknet/arg_processor/73e68c490b7650388f650e9e1ff9b2b3ced88dabf86213d6a0831077eb1a0800.cairo": "let __calldata_arg_amount = [__calldata_ptr];\nlet __calldata_ptr = __calldata_ptr + 1;\n", + "autogen/starknet/arg_processor/c31620b02d4d706f0542c989b2aadc01b0981d1f6a5933a8fe4937ace3d70d92.cairo": "let __calldata_actual_size = __calldata_ptr - cast([cast(fp + (-3), felt**)], felt*);\n", + "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}();\nlet (range_check_ptr, retdata_size, retdata) = get_balance_encode_return(ret_value, range_check_ptr);\n", + "autogen/starknet/external/get_balance/741ea357d6336b0bed7bf0472425acd0311d543883b803388880e60a232040c7.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)];\n", + "autogen/starknet/external/get_balance/9684a85e93c782014ca14293edea4eb2502039a5a7b6538ecd39c56faaf12529.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)];\n", + "autogen/starknet/external/get_balance/b2c52ca2d2a8fc8791a983086d8716c5eacd0c3d62934914d2286f84b98ff4cb.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)];\n", + "autogen/starknet/external/get_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata);\n", + "autogen/starknet/external/increase_balance/741ea357d6336b0bed7bf0472425acd0311d543883b803388880e60a232040c7.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)];\n", + "autogen/starknet/external/increase_balance/9684a85e93c782014ca14293edea4eb2502039a5a7b6538ecd39c56faaf12529.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)];\n", + "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(amount=__calldata_arg_amount,);\n%{ memory[ap] = segments.add() %} // Allocate memory for return value.\ntempvar retdata: felt*;\nlet retdata_size = 0;\n", + "autogen/starknet/external/increase_balance/b2c52ca2d2a8fc8791a983086d8716c5eacd0c3d62934914d2286f84b98ff4cb.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)];\n", + "autogen/starknet/external/increase_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata);\n", + "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo": "func get_balance_encode_return(ret_value: (res: felt), range_check_ptr) -> (\n range_check_ptr: felt, data_len: felt, data: felt*) {\n %{ memory[ap] = segments.add() %}\n alloc_locals;\n local __return_value_ptr_start: felt*;\n let __return_value_ptr = __return_value_ptr_start;\n with range_check_ptr {\n }\n return (\n range_check_ptr=range_check_ptr,\n data_len=__return_value_ptr - __return_value_ptr_start,\n data=__return_value_ptr_start);\n}\n", + "autogen/starknet/storage_var/balance/decl.cairo": "namespace balance {\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (res: felt) {\n let res = 0;\n call hash2;\n call normalize_address;\n }\n\n func read{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (res: felt) {\n let storage_addr = 0;\n call addr;\n call storage_read;\n }\n\n func write{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(value: felt) {\n let storage_addr = 0;\n call addr;\n call storage_write;\n }\n}", + "autogen/starknet/storage_var/balance/impl.cairo": "namespace balance {\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (res: felt) {\n let res = 916907772491729262376534102982219947830828984996257231353398618781993312401;\n return (res=res);\n }\n\n func read{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (res: felt) {\n let (storage_addr) = addr();\n let (__storage_var_temp0) = storage_read(address=storage_addr + 0);\n\n tempvar syscall_ptr = syscall_ptr;\n tempvar pedersen_ptr = pedersen_ptr;\n tempvar range_check_ptr = range_check_ptr;\n tempvar __storage_var_temp0: felt = __storage_var_temp0;\n return ([cast(&__storage_var_temp0, felt*)],);\n }\n\n func write{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(value: felt) {\n let (storage_addr) = addr();\n storage_write(address=storage_addr + 0, value=[cast(&value, felt) + 0]);\n return ();\n }\n}" + }, + "instruction_locations": { + "0": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 354, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 58, + "start_line": 354 + } + }, + "2": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 98, + "end_line": 354, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 354 + } + }, + "3": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 98, + "end_line": 354, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 354 + } + }, + "4": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 87, + "end_line": 355, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 355 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 53, + "end_line": 357, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 352, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 358, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 358 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 352 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 357 + } + }, + "6": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 358, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 19, + "start_line": 358 + } + }, + "7": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 358, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 358 + } + }, + "8": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 372, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 18, + "start_line": 372 + } + }, + "10": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 373, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 371 + } + }, + "11": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 373, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 371 + } + }, + "12": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 373, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 371 + } + }, + "13": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 88, + "end_line": 374, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 374 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 54, + "end_line": 375, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 370, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 376, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 376 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 370 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 375 + } + }, + "15": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 376, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 376 + } + }, + "16": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "17": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 43, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 43, + "start_line": 7 + } + }, + "18": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 21, + "start_line": 9 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 8 + } + }, + "20": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + } + }, + "21": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 35, + "start_line": 12 + } + }, + "22": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 43, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 63, + "start_line": 12 + } + }, + "23": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + } + }, + "25": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 352, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 37, + "start_line": 14 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 352 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 12 + } + }, + "26": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 58, + "start_line": 14 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 13 + } + }, + "27": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 37, + "start_line": 14 + } + }, + "29": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 352, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 31, + "start_line": 16 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 37, + "start_line": 14 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 352 + } + }, + "30": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 32, + "start_line": 17 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 13 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "31": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 35, + "start_line": 18 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 13 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 43, + "start_line": 7 + } + }, + "32": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 45, + "start_line": 19 + }, + "While expanding the reference '__storage_var_temp0' in:" + ], + "start_col": 14, + "start_line": 14 + } + }, + "33": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 20, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 20 + } + }, + "34": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 62, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 23 + } + }, + "35": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 43, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 64, + "start_line": 23 + } + }, + "36": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + } + }, + "38": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 370, + "input_file": { + "filename": "/Users/mario/Projects/work/shardlabs/cairo_venv/lib/python3.9/site-packages/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 25 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 370 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 23 + } + }, + "39": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 31, + "start_line": 25 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 24 + } + }, + "40": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 55, + "start_line": 25 + } + }, + "41": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 25 + } + }, + "43": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 19 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 24 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "44": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 64, + "start_line": 19 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 24 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 43, + "start_line": 7 + } + }, + "45": { + "accessible_scopes": [ + "__main__", + "__main__.balance", + "__main__.balance.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + } + }, + "46": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 14, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 18, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 17, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 14 + } + }, + "47": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 15, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 61, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 18, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 17, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 35, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 15 + } + }, + "48": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 16, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 18, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 17, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 63, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 16 + } + }, + "49": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 18, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 17, + "start_line": 18 + } + }, + "51": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 18, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 19, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 5, + "start_line": 19 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 19 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 18 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "52": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 18, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 19, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 5, + "start_line": 19 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 19 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 17, + "start_line": 18 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 35, + "start_line": 13 + } + }, + "53": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 18, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 19, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 5, + "start_line": 19 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 64, + "start_line": 19 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 17, + "start_line": 18 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 63, + "start_line": 13 + } + }, + "54": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 19, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 19, + "start_line": 19 + } + }, + "55": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 19, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 5, + "start_line": 19 + } + }, + "57": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 5, + "start_line": 20 + } + }, + "58": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/73e68c490b7650388f650e9e1ff9b2b3ced88dabf86213d6a0831077eb1a0800.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 17, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/c31620b02d4d706f0542c989b2aadc01b0981d1f6a5933a8fe4937ace3d70d92.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/01cba52f8515996bb9d7070bde81ff39281d096d7024a558efcba6e1fd2402cf.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 13 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 3, + "start_line": 17 + }, + "While handling calldata argument 'amount'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "60": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/01cba52f8515996bb9d7070bde81ff39281d096d7024a558efcba6e1fd2402cf.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "61": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/b2c52ca2d2a8fc8791a983086d8716c5eacd0c3d62934914d2286f84b98ff4cb.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 14, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 14 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "62": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/9684a85e93c782014ca14293edea4eb2502039a5a7b6538ecd39c56faaf12529.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 15, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 15 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "63": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/741ea357d6336b0bed7bf0472425acd0311d543883b803388880e60a232040c7.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 16, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 16 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "64": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/73e68c490b7650388f650e9e1ff9b2b3ced88dabf86213d6a0831077eb1a0800.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 17, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 145, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 124, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_amount' in:" + ], + "start_col": 3, + "start_line": 17 + }, + "While handling calldata argument 'amount'" + ], + "start_col": 29, + "start_line": 1 + } + }, + "65": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + } + }, + "67": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "69": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "70": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "71": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "72": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "74": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/a41d25a92a3a14a71125d51d48dd7398e2839f055f01551b7b1950eafc1187c0.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "75": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/increase_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 13, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 13 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "76": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 26, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 30, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 17, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 26 + } + }, + "77": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 27, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 61, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 30, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 17, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 35, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 27 + } + }, + "78": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 28, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/balance/decl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 30, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 17, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 63, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 28 + } + }, + "79": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 30, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 17, + "start_line": 30 + } + }, + "81": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 31, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 5, + "start_line": 31 + } + }, + "82": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance_encode_return" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 3 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 18, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 4 + } + }, + "84": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/293368f3a0e12cfcf22314a31e13b9801e95a5b8b2b71822a2fbbdf5a01ea795.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 29, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 9, + "start_line": 29 + }, + "While handling return value 'res'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "85": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/293368f3a0e12cfcf22314a31e13b9801e95a5b8b2b71822a2fbbdf5a01ea795.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 29, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + }, + "While expanding the reference '__return_value_ptr' in:" + ], + "start_col": 9, + "start_line": 29 + }, + "While handling return value 'res'" + ], + "start_col": 26, + "start_line": 2 + } + }, + "87": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 25, + "start_line": 10 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 56, + "start_line": 1 + } + }, + "88": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + } + }, + "89": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 14, + "start_line": 12 + }, + "While expanding the reference '__return_value_ptr_start' in:" + ], + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 11, + "start_line": 5 + } + }, + "90": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/get_balance/9ef0a2b9ad0a2e2b202322d7261fff6dada72892e286df2230a9eb8873880a98.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 9 + } + }, + "91": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/01cba52f8515996bb9d7070bde81ff39281d096d7024a558efcba6e1fd2402cf.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "92": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/b2c52ca2d2a8fc8791a983086d8716c5eacd0c3d62934914d2286f84b98ff4cb.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 26, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 26 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "93": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/9684a85e93c782014ca14293edea4eb2502039a5a7b6538ecd39c56faaf12529.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 27, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 27 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "94": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/741ea357d6336b0bed7bf0472425acd0311d543883b803388880e60a232040c7.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 28, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 28 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "95": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + } + }, + "97": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 100, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 85, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "98": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 101, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 48, + "start_line": 2 + } + }, + "100": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "101": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "102": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "103": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 2 + } + }, + "104": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/get_balance/2c767dabe8478bfafd38f9fb907f9842d03e3c9d2b355e2af5c59b126fcc8f59.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 37, + "start_line": 2 + } + }, + "105": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/get_balance/da17921a4e81c09e730800bbf23bfdbe5e9e6bfaedc59d80fbf62087fa43c27d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 25, + "input_file": { + "filename": "contract.cairo" + }, + "start_col": 6, + "start_line": 25 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + } + } + }, + "hints": { + "4": [ + { + "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": 0, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.storage_read.syscall_ptr": 0 + } + } + } + ], + "13": [ + { + "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": 1, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.storage_write.syscall_ptr": 1 + } + } + } + ], + "67": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.increase_balance" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 6, + "offset": 52 + }, + "reference_ids": {} + } + } + ], + "82": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.get_balance_encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 0 + }, + "reference_ids": {} + } + } + ] + }, + "identifiers": { + "__main__.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "__main__.balance": { + "type": "namespace" + }, + "__main__.balance.Args": { + "full_name": "__main__.balance.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.balance.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "__main__.balance.ImplicitArgs": { + "full_name": "__main__.balance.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.balance.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.balance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.balance.addr": { + "decorators": [], + "pc": 16, + "type": "function" + }, + "__main__.balance.addr.Args": { + "full_name": "__main__.balance.addr.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.balance.addr.ImplicitArgs": { + "full_name": "__main__.balance.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" + }, + "__main__.balance.addr.Return": { + "cairo_type": "(res: felt)", + "type": "type_definition" + }, + "__main__.balance.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.balance.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "__main__.balance.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "__main__.balance.read": { + "decorators": [], + "pc": 21, + "type": "function" + }, + "__main__.balance.read.Args": { + "full_name": "__main__.balance.read.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.balance.read.ImplicitArgs": { + "full_name": "__main__.balance.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" + }, + "__main__.balance.read.Return": { + "cairo_type": "(res: felt)", + "type": "type_definition" + }, + "__main__.balance.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.balance.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "__main__.balance.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "__main__.balance.write": { + "decorators": [], + "pc": 34, + "type": "function" + }, + "__main__.balance.write.Args": { + "full_name": "__main__.balance.write.Args", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.balance.write.ImplicitArgs": { + "full_name": "__main__.balance.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" + }, + "__main__.balance.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.balance.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.get_balance": { + "decorators": [ + "view" + ], + "pc": 76, + "type": "function" + }, + "__main__.get_balance.Args": { + "full_name": "__main__.get_balance.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.get_balance.ImplicitArgs": { + "full_name": "__main__.get_balance.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__.get_balance.Return": { + "cairo_type": "(res: felt)", + "type": "type_definition" + }, + "__main__.get_balance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.increase_balance": { + "decorators": [ + "external" + ], + "pc": 46, + "type": "function" + }, + "__main__.increase_balance.Args": { + "full_name": "__main__.increase_balance.Args", + "members": { + "amount": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.increase_balance.ImplicitArgs": { + "full_name": "__main__.increase_balance.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__.increase_balance.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.increase_balance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.get_balance": { + "decorators": [ + "view" + ], + "pc": 91, + "type": "function" + }, + "__wrappers__.get_balance.Args": { + "full_name": "__wrappers__.get_balance.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.get_balance.ImplicitArgs": { + "full_name": "__wrappers__.get_balance.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.get_balance.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.get_balance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.get_balance.__wrapped_func": { + "destination": "__main__.get_balance", + "type": "alias" + }, + "__wrappers__.get_balance_encode_return": { + "decorators": [], + "pc": 82, + "type": "function" + }, + "__wrappers__.get_balance_encode_return.Args": { + "full_name": "__wrappers__.get_balance_encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "ret_value": { + "cairo_type": "(res: felt)", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__wrappers__.get_balance_encode_return.ImplicitArgs": { + "full_name": "__wrappers__.get_balance_encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.get_balance_encode_return.Return": { + "cairo_type": "(range_check_ptr: felt, data_len: felt, data: felt*)", + "type": "type_definition" + }, + "__wrappers__.get_balance_encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "__wrappers__.get_balance_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.increase_balance": { + "decorators": [ + "external" + ], + "pc": 58, + "type": "function" + }, + "__wrappers__.increase_balance.Args": { + "full_name": "__wrappers__.increase_balance.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.increase_balance.ImplicitArgs": { + "full_name": "__wrappers__.increase_balance.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.increase_balance.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.increase_balance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.increase_balance.__wrapped_func": { + "destination": "__main__.increase_balance", + "type": "alias" + }, + "__wrappers__.increase_balance_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "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.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_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.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.storage_read": { + "decorators": [], + "pc": 0, + "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": 0, + "offset": 0 + }, + "pc": 0, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 0, + "offset": 1 + }, + "pc": 4, + "value": "cast([fp + (-4)] + 3, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.storage_write": { + "decorators": [], + "pc": 8, + "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": 1, + "offset": 0 + }, + "pc": 8, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 1, + "offset": 1 + }, + "pc": 13, + "value": "cast([fp + (-5)] + 3, felt*)" + } + ], + "type": "reference" + } + }, + "main_scope": "__main__", + "prime": "0x800000000000011000000000000000000000000000000000000000000000001", + "reference_manager": { + "references": [ + { + "ap_tracking_data": { + "group": 0, + "offset": 0 + }, + "pc": 0, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 1, + "offset": 0 + }, + "pc": 8, + "value": "[cast(fp + (-5), felt**)]" + } + ] + } + } +} \ No newline at end of file diff --git a/src/core.rs b/src/core.rs index 9dcc9e4b..4ed5d6c7 100644 --- a/src/core.rs +++ b/src/core.rs @@ -7,6 +7,7 @@ use std::fmt::Debug; use derive_more::Display; use once_cell::sync::Lazy; use serde::{Deserialize, Serialize}; +use serde_json::{Value, json, Serializer}; use starknet_crypto::FieldElement; use crate::hash::{pedersen_hash_array, StarkFelt, StarkHash}; @@ -73,6 +74,116 @@ pub fn calculate_contract_address( ContractAddress::try_from(StarkFelt::from(address)) } +fn compute_class_hash_from_json(contract_class: &Value) -> String{ + let mut abi_json = json!({ + "abi": contract_class.get("abi").unwrap_or(&Value::Null), + "program": contract_class.get("program").unwrap_or(&Value::Null) + }); + + let program_json = abi_json.get_mut("program").expect("msg"); + let debug_info_json = program_json.get_mut("debug_info"); + if debug_info_json.is_some(){ + program_json.as_object_mut().unwrap().insert("debug_info".to_owned(), serde_json::Value::Null); + } + + let mut new_object = serde_json::Map::::new(); + let res = crate::utils::traverse_and_exclude_recursively(&abi_json, &mut new_object, &|key, value| { + return + (key == "attributes" || key == "accessible_scopes") + && value.is_array() + && value.as_array().unwrap().is_empty(); + }); + + let mut writer = Vec::with_capacity(128); + let mut serializer = Serializer::with_formatter(&mut writer, crate::serde_utils::StarknetFormatter); + res.serialize(&mut serializer).unwrap(); + let str_json = unsafe{ + String::from_utf8_unchecked(writer) + }; + println!("{}", str_json); + + let keccak_result = crate::hash::sn_keccak(str_json.as_bytes()); + return keccak_result; +} + +fn entry_points_hash_by_type_from_json(contract_class: &Value, entry_point_type: &str) -> StarkFelt{ + let felts = contract_class + .get("entry_points_by_type") + .unwrap_or(&serde_json::Value::Null) + .get(entry_point_type) + .unwrap_or(&serde_json::Value::Null) + .as_array() + .unwrap_or(&Vec::::new()) + .iter() + .flat_map(|entry|{ + let selector = get_starkfelt_from_json_unsafe(&entry, "selector"); + let offset = get_starkfelt_from_json_unsafe(&entry, "offset"); + + return vec![selector, offset]; + }).collect::>(); + + return pedersen_hash_array(&felts); +} + +fn get_starkfelt_from_json_unsafe(json: &Value, key: &str) -> StarkFelt{ + StarkFelt::try_from(json.get(key).unwrap().as_str().unwrap()).unwrap() +} + +pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> ClassHash{ + // api version + let api_version = StarkFelt::try_from(format!("0x{}", hex::encode([0u8])).as_str()).unwrap(); + + // external entry points hash + let external_entry_points_hash = entry_points_hash_by_type_from_json(&contract_class, "EXTERNAL"); + + // l1 handler entry points hash + let l1_entry_points_hash = entry_points_hash_by_type_from_json(&contract_class, "L1_HANDLER"); + + // constructor handler entry points hash + let constructor_entry_points_hash = entry_points_hash_by_type_from_json(&contract_class, "CONSTRUCTOR"); + + // builtins hash + let builtins_encoded = contract_class + .get("program").unwrap_or(&serde_json::Value::Null) + .get("builtins").unwrap_or(&serde_json::Value::Null) + .as_array().unwrap_or(&Vec::::new()).iter().map(|str| { + let hex_str = str.as_str().unwrap().as_bytes().iter().map(|b| format!("{:02x}", b)) + .collect::>().join(""); + return format!("0x{}", hex_str); + }).collect::>(); + + let builtins_encoded_as_felts = builtins_encoded.iter().map(|s| { + return StarkFelt::try_from(s.as_str()).unwrap(); + }).collect::>(); + + let builtins_hash = pedersen_hash_array(&builtins_encoded_as_felts); + + //hinted class hash + let hinted_class_hash = compute_class_hash_from_json(&contract_class); + + //program data hash + let program_data_felts = contract_class + .get("program").unwrap_or(&Value::Null) + .get("data").unwrap_or(&Value::Null) + .as_array().unwrap_or(&Vec::::new()) + .iter() + .map(|str| { + return StarkFelt::try_from(str.as_str().unwrap()).unwrap(); + }).collect::>(); + + let program_data_hash = pedersen_hash_array(&program_data_felts); + + return ClassHash(pedersen_hash_array(&vec![ + api_version, + external_entry_points_hash, + l1_entry_points_hash, + constructor_entry_points_hash, + builtins_hash, + StarkFelt::try_from(hinted_class_hash.as_str()).unwrap(), + program_data_hash + ])); +} + /// The hash of a [ContractClass](`crate::state::ContractClass`). #[derive( Debug, diff --git a/src/core_test.rs b/src/core_test.rs index ca335a64..c6d2e49c 100644 --- a/src/core_test.rs +++ b/src/core_test.rs @@ -65,3 +65,15 @@ fn test_calculate_contract_address() { assert_eq!(actual_address, expected_address); } + + +#[test] +fn test_contract_class_hash_generation(){ + let data_str = std::fs::read_to_string("./resources/contract_compiled.json").unwrap(); + println!("{data_str}"); + let data: serde_json::Value= serde_json::from_str(&data_str).unwrap(); + let expected_class_hash = ClassHash(StarkHash::try_from("0x399998c787e0a063c3ac1d2abac084dcbe09954e3b156d53a8c43a02aa27d35").unwrap()); + + let resulted_class_hash = crate::core::compute_contract_class_hash_v0(&data); + assert_eq!(resulted_class_hash, expected_class_hash); +} \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index 131fca0c..0570ce19 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -8,6 +8,7 @@ pub mod hash; pub mod serde_utils; pub mod state; pub mod transaction; +pub mod utils; use std::num::ParseIntError; From d4281c19b87a8129841c9b3c6c5228aa9ac7c685 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Tue, 4 Apr 2023 11:22:41 +0300 Subject: [PATCH 09/27] format code --- src/core.rs | 108 +++++++++++++++++++++++++--------------- src/core_test.rs | 12 +++-- src/hash.rs | 19 +++---- src/hash_test.rs | 7 ++- src/serde_utils.rs | 31 +++++------- src/serde_utils_test.rs | 23 ++++----- src/utils.rs | 35 ++++++------- 7 files changed, 131 insertions(+), 104 deletions(-) diff --git a/src/core.rs b/src/core.rs index 4ed5d6c7..1fd2dc42 100644 --- a/src/core.rs +++ b/src/core.rs @@ -7,7 +7,7 @@ use std::fmt::Debug; use derive_more::Display; use once_cell::sync::Lazy; use serde::{Deserialize, Serialize}; -use serde_json::{Value, json, Serializer}; +use serde_json::{json, Serializer, Value}; use starknet_crypto::FieldElement; use crate::hash::{pedersen_hash_array, StarkFelt, StarkHash}; @@ -74,7 +74,7 @@ pub fn calculate_contract_address( ContractAddress::try_from(StarkFelt::from(address)) } -fn compute_class_hash_from_json(contract_class: &Value) -> String{ +fn compute_class_hash_from_json(contract_class: &Value) -> String { let mut abi_json = json!({ "abi": contract_class.get("abi").unwrap_or(&Value::Null), "program": contract_class.get("program").unwrap_or(&Value::Null) @@ -82,31 +82,39 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String{ let program_json = abi_json.get_mut("program").expect("msg"); let debug_info_json = program_json.get_mut("debug_info"); - if debug_info_json.is_some(){ - program_json.as_object_mut().unwrap().insert("debug_info".to_owned(), serde_json::Value::Null); + if debug_info_json.is_some() { + program_json + .as_object_mut() + .unwrap() + .insert("debug_info".to_owned(), serde_json::Value::Null); } let mut new_object = serde_json::Map::::new(); - let res = crate::utils::traverse_and_exclude_recursively(&abi_json, &mut new_object, &|key, value| { - return - (key == "attributes" || key == "accessible_scopes") - && value.is_array() - && value.as_array().unwrap().is_empty(); - }); + let res = crate::utils::traverse_and_exclude_recursively( + &abi_json, + &mut new_object, + &|key, value| { + return (key == "attributes" || key == "accessible_scopes") + && value.is_array() + && value.as_array().unwrap().is_empty(); + }, + ); let mut writer = Vec::with_capacity(128); - let mut serializer = Serializer::with_formatter(&mut writer, crate::serde_utils::StarknetFormatter); + let mut serializer = + Serializer::with_formatter(&mut writer, crate::serde_utils::StarknetFormatter); res.serialize(&mut serializer).unwrap(); - let str_json = unsafe{ - String::from_utf8_unchecked(writer) - }; + let str_json = unsafe { String::from_utf8_unchecked(writer) }; println!("{}", str_json); let keccak_result = crate::hash::sn_keccak(str_json.as_bytes()); return keccak_result; } -fn entry_points_hash_by_type_from_json(contract_class: &Value, entry_point_type: &str) -> StarkFelt{ +fn entry_points_hash_by_type_from_json( + contract_class: &Value, + entry_point_type: &str, +) -> StarkFelt { let felts = contract_class .get("entry_points_by_type") .unwrap_or(&serde_json::Value::Null) @@ -115,61 +123,83 @@ fn entry_points_hash_by_type_from_json(contract_class: &Value, entry_point_type: .as_array() .unwrap_or(&Vec::::new()) .iter() - .flat_map(|entry|{ + .flat_map(|entry| { let selector = get_starkfelt_from_json_unsafe(&entry, "selector"); let offset = get_starkfelt_from_json_unsafe(&entry, "offset"); return vec![selector, offset]; - }).collect::>(); + }) + .collect::>(); return pedersen_hash_array(&felts); } -fn get_starkfelt_from_json_unsafe(json: &Value, key: &str) -> StarkFelt{ +fn get_starkfelt_from_json_unsafe(json: &Value, key: &str) -> StarkFelt { StarkFelt::try_from(json.get(key).unwrap().as_str().unwrap()).unwrap() } -pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> ClassHash{ +pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> ClassHash { // api version let api_version = StarkFelt::try_from(format!("0x{}", hex::encode([0u8])).as_str()).unwrap(); // external entry points hash - let external_entry_points_hash = entry_points_hash_by_type_from_json(&contract_class, "EXTERNAL"); + let external_entry_points_hash = + entry_points_hash_by_type_from_json(&contract_class, "EXTERNAL"); // l1 handler entry points hash let l1_entry_points_hash = entry_points_hash_by_type_from_json(&contract_class, "L1_HANDLER"); // constructor handler entry points hash - let constructor_entry_points_hash = entry_points_hash_by_type_from_json(&contract_class, "CONSTRUCTOR"); + let constructor_entry_points_hash = + entry_points_hash_by_type_from_json(&contract_class, "CONSTRUCTOR"); // builtins hash let builtins_encoded = contract_class - .get("program").unwrap_or(&serde_json::Value::Null) - .get("builtins").unwrap_or(&serde_json::Value::Null) - .as_array().unwrap_or(&Vec::::new()).iter().map(|str| { - let hex_str = str.as_str().unwrap().as_bytes().iter().map(|b| format!("{:02x}", b)) - .collect::>().join(""); - return format!("0x{}", hex_str); - }).collect::>(); - - let builtins_encoded_as_felts = builtins_encoded.iter().map(|s| { - return StarkFelt::try_from(s.as_str()).unwrap(); - }).collect::>(); + .get("program") + .unwrap_or(&serde_json::Value::Null) + .get("builtins") + .unwrap_or(&serde_json::Value::Null) + .as_array() + .unwrap_or(&Vec::::new()) + .iter() + .map(|str| { + let hex_str = str + .as_str() + .unwrap() + .as_bytes() + .iter() + .map(|b| format!("{:02x}", b)) + .collect::>() + .join(""); + return format!("0x{}", hex_str); + }) + .collect::>(); + + let builtins_encoded_as_felts = builtins_encoded + .iter() + .map(|s| { + return StarkFelt::try_from(s.as_str()).unwrap(); + }) + .collect::>(); let builtins_hash = pedersen_hash_array(&builtins_encoded_as_felts); - //hinted class hash + // hinted class hash let hinted_class_hash = compute_class_hash_from_json(&contract_class); - //program data hash + // program data hash let program_data_felts = contract_class - .get("program").unwrap_or(&Value::Null) - .get("data").unwrap_or(&Value::Null) - .as_array().unwrap_or(&Vec::::new()) + .get("program") + .unwrap_or(&Value::Null) + .get("data") + .unwrap_or(&Value::Null) + .as_array() + .unwrap_or(&Vec::::new()) .iter() .map(|str| { return StarkFelt::try_from(str.as_str().unwrap()).unwrap(); - }).collect::>(); + }) + .collect::>(); let program_data_hash = pedersen_hash_array(&program_data_felts); @@ -180,7 +210,7 @@ pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> Cla constructor_entry_points_hash, builtins_hash, StarkFelt::try_from(hinted_class_hash.as_str()).unwrap(), - program_data_hash + program_data_hash, ])); } diff --git a/src/core_test.rs b/src/core_test.rs index c6d2e49c..0b7f8f9c 100644 --- a/src/core_test.rs +++ b/src/core_test.rs @@ -66,14 +66,16 @@ fn test_calculate_contract_address() { assert_eq!(actual_address, expected_address); } - #[test] -fn test_contract_class_hash_generation(){ +fn test_contract_class_hash_generation() { let data_str = std::fs::read_to_string("./resources/contract_compiled.json").unwrap(); println!("{data_str}"); - let data: serde_json::Value= serde_json::from_str(&data_str).unwrap(); - let expected_class_hash = ClassHash(StarkHash::try_from("0x399998c787e0a063c3ac1d2abac084dcbe09954e3b156d53a8c43a02aa27d35").unwrap()); + let data: serde_json::Value = serde_json::from_str(&data_str).unwrap(); + let expected_class_hash = ClassHash( + StarkHash::try_from("0x399998c787e0a063c3ac1d2abac084dcbe09954e3b156d53a8c43a02aa27d35") + .unwrap(), + ); let resulted_class_hash = crate::core::compute_contract_class_hash_v0(&data); assert_eq!(resulted_class_hash, expected_class_hash); -} \ No newline at end of file +} diff --git a/src/hash.rs b/src/hash.rs index b4bc501b..76875a1c 100644 --- a/src/hash.rs +++ b/src/hash.rs @@ -9,6 +9,7 @@ use serde::{Deserialize, Serialize}; use sha3::Digest; use starknet_crypto::{pedersen_hash as starknet_crypto_pedersen_hash, FieldElement}; use web3::types::U256; + use crate::serde_utils::{ bytes_from_hex_str, hex_str_from_bytes, BytesAsHex, NonPrefixedBytesAsHex, PrefixedBytesAsHex, }; @@ -45,14 +46,13 @@ pub fn pedersen_hash_array(felts: &[StarkFelt]) -> StarkHash { } /// Starknet Keccak Hash -pub fn sn_keccak(data: &[u8]) -> String{ +pub fn sn_keccak(data: &[u8]) -> String { let keccak256 = sha3::Keccak256::digest(data); let number = U256::from_big_endian(keccak256.as_slice()); let mask = U256::pow(U256::from(2), U256::from(250)) - U256::from(1); let masked_number = number & mask; - let mut res_bytes:[u8;32] = [0;32]; + let mut res_bytes: [u8; 32] = [0; 32]; masked_number.to_big_endian(&mut res_bytes); - return format!("0x{}", hex::encode(res_bytes).trim_start_matches('0')); } @@ -65,15 +65,16 @@ pub struct StarkFelt([u8; 32]); #[derive(Clone, Copy, Eq, PartialEq, Default)] pub struct StarkFeltAsDecimal(U256); -impl Serialize for StarkFeltAsDecimal{ +impl Serialize for StarkFeltAsDecimal { fn serialize(&self, serializer: S) -> Result - where - S: serde::Serializer { + where + S: serde::Serializer, + { serializer.serialize_str(&self.0.to_string()) } } -impl Display for StarkFeltAsDecimal{ +impl Display for StarkFeltAsDecimal { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { return f.write_str(&self.0.to_string()); } @@ -230,13 +231,13 @@ impl TryFrom for usize { } } -impl From for U256{ +impl From for U256 { fn from(felt: StarkFelt) -> Self { return web3::types::U256::from_big_endian(&felt.0); } } -impl From for StarkFeltAsDecimal{ +impl From for StarkFeltAsDecimal { fn from(felt: StarkFelt) -> Self { return StarkFeltAsDecimal(U256::from(felt)); } diff --git a/src/hash_test.rs b/src/hash_test.rs index bcb82433..fa2a6868 100644 --- a/src/hash_test.rs +++ b/src/hash_test.rs @@ -69,8 +69,11 @@ fn hash_serde() { } #[test] -fn stark_felt_from_hex_to_decimal(){ +fn stark_felt_from_hex_to_decimal() { let felt = stark_felt!("0x264d6571d5f186bab2a9d5d8d30aa38bf5502bc4354870edbfe194c6f655c9b"); let felt_decimal = StarkFeltAsDecimal::from(felt); - assert_eq!(felt_decimal.to_string(), "1082789725971120866445625682125121757273101071727151005357998861560691645595"); + assert_eq!( + felt_decimal.to_string(), + "1082789725971120866445625682125121757273101071727151005357998861560691645595" + ); } diff --git a/src/serde_utils.rs b/src/serde_utils.rs index 8cc76907..e99d44b4 100644 --- a/src/serde_utils.rs +++ b/src/serde_utils.rs @@ -131,30 +131,25 @@ use std::io; use serde_json::ser::Formatter; pub struct StarknetFormatter; -impl Formatter for StarknetFormatter{ +impl Formatter for StarknetFormatter { fn begin_object_value(&mut self, writer: &mut W) -> io::Result<()> - where - W: ?Sized + io::Write, { + where + W: ?Sized + io::Write, + { writer.write_all(b": ") } fn begin_object_key(&mut self, writer: &mut W, first: bool) -> io::Result<()> - where - W: ?Sized + io::Write, { - if first { - Ok(()) - } else { - writer.write_all(b", ") - } + where + W: ?Sized + io::Write, + { + if first { Ok(()) } else { writer.write_all(b", ") } } fn begin_array_value(&mut self, writer: &mut W, first: bool) -> io::Result<()> - where - W: ?Sized + io::Write, { - if first { - Ok(()) - } else { - writer.write_all(b", ") - } + where + W: ?Sized + io::Write, + { + if first { Ok(()) } else { writer.write_all(b", ") } } -} \ No newline at end of file +} diff --git a/src/serde_utils_test.rs b/src/serde_utils_test.rs index 49684724..d0e8d99a 100644 --- a/src/serde_utils_test.rs +++ b/src/serde_utils_test.rs @@ -1,9 +1,9 @@ use assert_matches::assert_matches; +use serde_json::Value; use crate::serde_utils::{ bytes_from_hex_str, hex_str_from_bytes, BytesAsHex, InnerDeserializationError, }; -use serde_json::Value; #[test] fn hex_str_from_bytes_scenarios() { @@ -110,18 +110,17 @@ fn hex_as_bytes_serde_not_prefixed() { ); } - #[test] -fn serde_deserialize_big_numbers_without_scientific_notation(){ +fn serde_deserialize_big_numbers_without_scientific_notation() { let input = r#"{ "value": 20853273475220472486191784820 }"#; - let json:serde_json::Value = serde_json::from_str(&input).unwrap(); + let json: serde_json::Value = serde_json::from_str(&input).unwrap(); assert_eq!(json["value"].to_string(), "20853273475220472486191784820"); } #[test] -fn serde_remove_elements_from_json(){ +fn serde_remove_elements_from_json() { let input = r#" { "name": "John Doe", @@ -147,7 +146,6 @@ fn serde_remove_elements_from_json(){ "arr": [90, 85, 95] } "#; - let expected_output = r#" { "name": "John Doe", @@ -171,17 +169,14 @@ fn serde_remove_elements_from_json(){ "arr": [90, 85, 95] } "#; - let value: Value = serde_json::from_str(input).unwrap(); let mut new_object: serde_json::Map = serde_json::Map::new(); - let res = crate::utils::traverse_and_exclude_recursively( - &value, - &mut new_object, - &|key, val| { - return key=="should_be_removed" && - val.is_array() && - val.as_array().unwrap().is_empty() + let res = + crate::utils::traverse_and_exclude_recursively(&value, &mut new_object, &|key, val| { + return key == "should_be_removed" + && val.is_array() + && val.as_array().unwrap().is_empty(); }); assert_eq!(res, serde_json::from_str::(expected_output).unwrap()); diff --git a/src/utils.rs b/src/utils.rs index 7d85d7cb..c16fc98f 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -2,28 +2,29 @@ use serde_json::Value; /// because of the preserve_order feature enabled in the serde_json crate /// removing a key from the object changes the order of the keys -/// When serde_json is not being used with the preserver order feature +/// When serde_json is not being used with the preserver order feature /// deserializing to a serde_json::Value changes the order of the keys /// /// go through the object by visiting every key and value recursively, /// and not including them into a new json obj if the condition is met /// Empty objects are not included pub fn traverse_and_exclude_recursively( - value: &Value, - new_object: &mut serde_json::Map, - condition: &F -) -> serde_json::Value where F: Fn(&String, &Value) -> bool{ + value: &Value, + new_object: &mut serde_json::Map, + condition: &F, +) -> serde_json::Value +where + F: Fn(&String, &Value) -> bool, +{ match value { Value::Object(object) => { for (key, value) in object { let mut inner_obj = serde_json::Map::new(); - if condition(key, &value){ - continue + if condition(key, &value) { + continue; } - let inner_val = traverse_and_exclude_recursively(value, &mut inner_obj, condition); - new_object.insert(key.to_string(), inner_val); } @@ -37,7 +38,7 @@ pub fn traverse_and_exclude_recursively( let mut inner_obj = serde_json::Map::new(); let inner_val = traverse_and_exclude_recursively(value, &mut inner_obj, condition); - if !(inner_val.is_object() && inner_val.as_object().unwrap().is_empty()){ + if !(inner_val.is_object() && inner_val.as_object().unwrap().is_empty()) { inner_arr.push(inner_val) } } @@ -53,20 +54,20 @@ pub fn traverse_and_exclude_recursively( /// because of the preserve_order feature enabled in the serde_json crate /// removing a key from the object changes the order of the keys -/// When serde_json is not being used with the preserver order feature +/// When serde_json is not being used with the preserver order feature /// deserializing to a serde_json::Value changes the order of the keys /// Go through object's top level keys and remove those that pass the condition -pub fn traverse_and_exclude_top_level_keys( - value: &Value, - condition: &F -) -> serde_json::Value where F: Fn(&String, &Value) -> bool{ - if !value.is_object(){ +pub fn traverse_and_exclude_top_level_keys(value: &Value, condition: &F) -> serde_json::Value +where + F: Fn(&String, &Value) -> bool, +{ + if !value.is_object() { return value.clone(); } let mut new_obj = serde_json::Map::new(); - for (key, value) in value.as_object().unwrap(){ + for (key, value) in value.as_object().unwrap() { if condition(key, value) { continue; } From 37a357b72063d1e63b26be68ee97888fdf5399bf Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Tue, 4 Apr 2023 11:48:16 +0300 Subject: [PATCH 10/27] clippy + fmt --- src/core.rs | 45 ++++++++++++++++++++++------------------- src/hash.rs | 8 ++++---- src/serde_utils_test.rs | 2 +- src/state.rs | 8 ++++---- src/utils.rs | 18 ++++++++--------- 5 files changed, 42 insertions(+), 39 deletions(-) diff --git a/src/core.rs b/src/core.rs index 1fd2dc42..a9db2593 100644 --- a/src/core.rs +++ b/src/core.rs @@ -85,7 +85,7 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { if debug_info_json.is_some() { program_json .as_object_mut() - .unwrap() + .expect("Not a json object") .insert("debug_info".to_owned(), serde_json::Value::Null); } @@ -96,19 +96,19 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { &|key, value| { return (key == "attributes" || key == "accessible_scopes") && value.is_array() - && value.as_array().unwrap().is_empty(); + && value.as_array().expect("Not a json array").is_empty(); }, ); let mut writer = Vec::with_capacity(128); let mut serializer = Serializer::with_formatter(&mut writer, crate::serde_utils::StarknetFormatter); - res.serialize(&mut serializer).unwrap(); + res.serialize(&mut serializer).expect("Unable to serialize with custom formatter"); let str_json = unsafe { String::from_utf8_unchecked(writer) }; println!("{}", str_json); let keccak_result = crate::hash::sn_keccak(str_json.as_bytes()); - return keccak_result; + keccak_result } fn entry_points_hash_by_type_from_json( @@ -124,34 +124,36 @@ fn entry_points_hash_by_type_from_json( .unwrap_or(&Vec::::new()) .iter() .flat_map(|entry| { - let selector = get_starkfelt_from_json_unsafe(&entry, "selector"); - let offset = get_starkfelt_from_json_unsafe(&entry, "offset"); + let selector = get_starkfelt_from_json_unsafe(entry, "selector"); + let offset = get_starkfelt_from_json_unsafe(entry, "offset"); - return vec![selector, offset]; + vec![selector, offset] }) .collect::>(); - return pedersen_hash_array(&felts); + pedersen_hash_array(&felts) } fn get_starkfelt_from_json_unsafe(json: &Value, key: &str) -> StarkFelt { - StarkFelt::try_from(json.get(key).unwrap().as_str().unwrap()).unwrap() + StarkFelt::try_from(json.get(key).expect("Key not found").as_str().expect("Not a json string")) + .expect("Not a valid hash") } pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> ClassHash { // api version - let api_version = StarkFelt::try_from(format!("0x{}", hex::encode([0u8])).as_str()).unwrap(); + let api_version = StarkFelt::try_from(format!("0x{}", hex::encode([0u8])).as_str()) + .expect("Not a valid hash"); // external entry points hash let external_entry_points_hash = - entry_points_hash_by_type_from_json(&contract_class, "EXTERNAL"); + entry_points_hash_by_type_from_json(contract_class, "EXTERNAL"); // l1 handler entry points hash - let l1_entry_points_hash = entry_points_hash_by_type_from_json(&contract_class, "L1_HANDLER"); + let l1_entry_points_hash = entry_points_hash_by_type_from_json(contract_class, "L1_HANDLER"); // constructor handler entry points hash let constructor_entry_points_hash = - entry_points_hash_by_type_from_json(&contract_class, "CONSTRUCTOR"); + entry_points_hash_by_type_from_json(contract_class, "CONSTRUCTOR"); // builtins hash let builtins_encoded = contract_class @@ -165,27 +167,27 @@ pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> Cla .map(|str| { let hex_str = str .as_str() - .unwrap() + .expect("Not a json string") .as_bytes() .iter() .map(|b| format!("{:02x}", b)) .collect::>() .join(""); - return format!("0x{}", hex_str); + format!("0x{}", hex_str) }) .collect::>(); let builtins_encoded_as_felts = builtins_encoded .iter() .map(|s| { - return StarkFelt::try_from(s.as_str()).unwrap(); + return StarkFelt::try_from(s.as_str()).expect("Not a valid hash"); }) .collect::>(); let builtins_hash = pedersen_hash_array(&builtins_encoded_as_felts); // hinted class hash - let hinted_class_hash = compute_class_hash_from_json(&contract_class); + let hinted_class_hash = compute_class_hash_from_json(contract_class); // program data hash let program_data_felts = contract_class @@ -197,21 +199,22 @@ pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> Cla .unwrap_or(&Vec::::new()) .iter() .map(|str| { - return StarkFelt::try_from(str.as_str().unwrap()).unwrap(); + return StarkFelt::try_from(str.as_str().expect("Not a json string")) + .expect("Not a valid hash"); }) .collect::>(); let program_data_hash = pedersen_hash_array(&program_data_felts); - return ClassHash(pedersen_hash_array(&vec![ + ClassHash(pedersen_hash_array(&vec![ api_version, external_entry_points_hash, l1_entry_points_hash, constructor_entry_points_hash, builtins_hash, - StarkFelt::try_from(hinted_class_hash.as_str()).unwrap(), + StarkFelt::try_from(hinted_class_hash.as_str()).expect("Not a valid hash"), program_data_hash, - ])); + ])) } /// The hash of a [ContractClass](`crate::state::ContractClass`). diff --git a/src/hash.rs b/src/hash.rs index 76875a1c..8e0af613 100644 --- a/src/hash.rs +++ b/src/hash.rs @@ -53,7 +53,7 @@ pub fn sn_keccak(data: &[u8]) -> String { let masked_number = number & mask; let mut res_bytes: [u8; 32] = [0; 32]; masked_number.to_big_endian(&mut res_bytes); - return format!("0x{}", hex::encode(res_bytes).trim_start_matches('0')); + format!("0x{}", hex::encode(res_bytes).trim_start_matches('0')) } // TODO: Move to a different crate. @@ -76,7 +76,7 @@ impl Serialize for StarkFeltAsDecimal { impl Display for StarkFeltAsDecimal { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - return f.write_str(&self.0.to_string()); + f.write_str(&self.0.to_string()) } } @@ -233,13 +233,13 @@ impl TryFrom for usize { impl From for U256 { fn from(felt: StarkFelt) -> Self { - return web3::types::U256::from_big_endian(&felt.0); + web3::types::U256::from_big_endian(&felt.0) } } impl From for StarkFeltAsDecimal { fn from(felt: StarkFelt) -> Self { - return StarkFeltAsDecimal(U256::from(felt)); + StarkFeltAsDecimal(U256::from(felt)) } } diff --git a/src/serde_utils_test.rs b/src/serde_utils_test.rs index d0e8d99a..3ae1d1ee 100644 --- a/src/serde_utils_test.rs +++ b/src/serde_utils_test.rs @@ -115,7 +115,7 @@ fn serde_deserialize_big_numbers_without_scientific_notation() { let input = r#"{ "value": 20853273475220472486191784820 }"#; - let json: serde_json::Value = serde_json::from_str(&input).unwrap(); + let json: serde_json::Value = serde_json::from_str(input).unwrap(); assert_eq!(json["value"].to_string(), "20853273475220472486191784820"); } diff --git a/src/state.rs b/src/state.rs index 41cb76c5..8e69df6c 100644 --- a/src/state.rs +++ b/src/state.rs @@ -117,10 +117,10 @@ impl TryFrom for EntryPointOffset { pub fn number_or_string<'de, D: Deserializer<'de>>(deserializer: D) -> Result { let usize_value = match Value::deserialize(deserializer)? { - Value::Number(number) => { - number.as_u64().ok_or(DeserializationError::custom("Cannot cast number to usize."))? - as usize - } + Value::Number(number) => number + .as_u64() + .ok_or_else(|| DeserializationError::custom("Cannot cast number to usize."))? + as usize, Value::String(s) => hex_string_try_into_usize(&s).map_err(DeserializationError::custom)?, _ => return Err(DeserializationError::custom("Cannot cast value into usize.")), }; diff --git a/src/utils.rs b/src/utils.rs index c16fc98f..3c7b0ebb 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -21,14 +21,14 @@ where for (key, value) in object { let mut inner_obj = serde_json::Map::new(); - if condition(key, &value) { + if condition(key, value) { continue; } let inner_val = traverse_and_exclude_recursively(value, &mut inner_obj, condition); new_object.insert(key.to_string(), inner_val); } - return Value::Object(new_object.clone()); + Value::Object(new_object.clone()) } // arrays are visited like the objects - recursively Value::Array(array) => { @@ -38,17 +38,17 @@ where let mut inner_obj = serde_json::Map::new(); let inner_val = traverse_and_exclude_recursively(value, &mut inner_obj, condition); - if !(inner_val.is_object() && inner_val.as_object().unwrap().is_empty()) { + if !(inner_val.is_object() + && inner_val.as_object().expect("Not a json object").is_empty()) + { inner_arr.push(inner_val) } } - return Value::Array(inner_arr); + Value::Array(inner_arr) } // handle non-object, non-array values - _ => { - return value.clone(); - } + _ => value.clone(), } } @@ -67,7 +67,7 @@ where let mut new_obj = serde_json::Map::new(); - for (key, value) in value.as_object().unwrap() { + for (key, value) in value.as_object().expect("Not a json object") { if condition(key, value) { continue; } @@ -75,5 +75,5 @@ where new_obj.insert(key.clone(), value.clone()); } - return Value::Object(new_obj); + Value::Object(new_obj) } From 64255121f4630fcfedcbff3f7b0ca11149608ed1 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Tue, 4 Apr 2023 12:59:55 +0300 Subject: [PATCH 11/27] clippy after merge --- src/deprecated_contract_class.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/deprecated_contract_class.rs b/src/deprecated_contract_class.rs index abc217b6..8d799699 100644 --- a/src/deprecated_contract_class.rs +++ b/src/deprecated_contract_class.rs @@ -144,10 +144,10 @@ impl TryFrom for EntryPointOffset { pub fn number_or_string<'de, D: Deserializer<'de>>(deserializer: D) -> Result { let usize_value = match Value::deserialize(deserializer)? { - Value::Number(number) => { - number.as_u64().ok_or(DeserializationError::custom("Cannot cast number to usize."))? - as usize - } + Value::Number(number) => number + .as_u64() + .ok_or_else(|| DeserializationError::custom("Cannot cast number to usize."))? + as usize, Value::String(s) => hex_string_try_into_usize(&s).map_err(DeserializationError::custom)?, _ => return Err(DeserializationError::custom("Cannot cast value into usize.")), }; From 8bec3e11105ddc6b1f9d1364b60d9a554b93d0cf Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 5 Apr 2023 17:04:28 +0300 Subject: [PATCH 12/27] add Deserialize trait to StarkFeltAsDecimal --- src/hash.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hash.rs b/src/hash.rs index 8e0af613..bc01390f 100644 --- a/src/hash.rs +++ b/src/hash.rs @@ -62,7 +62,7 @@ pub fn sn_keccak(data: &[u8]) -> String { #[serde(try_from = "PrefixedBytesAsHex<32_usize>", into = "PrefixedBytesAsHex<32_usize>")] pub struct StarkFelt([u8; 32]); -#[derive(Clone, Copy, Eq, PartialEq, Default)] +#[derive(Clone, Copy, Eq, PartialEq, Default, Deserialize)] pub struct StarkFeltAsDecimal(U256); impl Serialize for StarkFeltAsDecimal { From 211f3566d157c0d7896438ff91a566448e65a4bb Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 5 Apr 2023 17:38:07 +0300 Subject: [PATCH 13/27] Revert "add Deserialize trait to StarkFeltAsDecimal" This reverts commit 8bec3e11105ddc6b1f9d1364b60d9a554b93d0cf. --- src/hash.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hash.rs b/src/hash.rs index bc01390f..8e0af613 100644 --- a/src/hash.rs +++ b/src/hash.rs @@ -62,7 +62,7 @@ pub fn sn_keccak(data: &[u8]) -> String { #[serde(try_from = "PrefixedBytesAsHex<32_usize>", into = "PrefixedBytesAsHex<32_usize>")] pub struct StarkFelt([u8; 32]); -#[derive(Clone, Copy, Eq, PartialEq, Default, Deserialize)] +#[derive(Clone, Copy, Eq, PartialEq, Default)] pub struct StarkFeltAsDecimal(U256); impl Serialize for StarkFeltAsDecimal { From f2d615c9a513a8dbdc3af8cd694c99a2dbed052f Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Tue, 2 May 2023 12:14:34 +0300 Subject: [PATCH 14/27] changed cargo dependency format --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 87c6e802..5e23aff3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,7 +10,7 @@ testing = [] hex = { version = "0.4.3" } indexmap = { version = "1.9.2", features = ["serde"] } once_cell = { version = "1.16.0" } -sha3 = "0.10.6" +sha3 = { version = "0.10.6" } serde = { version = "1.0.130", features = ["derive", "rc"] } serde_json = { version = "1.0.81", features = ["preserve_order", "arbitrary_precision"] } starknet-crypto = { version = "0.2.0" } From 735291771a5f85cbd9de5053ab660b9b6234228d Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 09:46:38 +0300 Subject: [PATCH 15/27] removed needless println! and unsafe block --- src/core.rs | 3 +-- src/core_test.rs | 1 - 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/core.rs b/src/core.rs index 0d0f410f..3b26aac9 100644 --- a/src/core.rs +++ b/src/core.rs @@ -104,8 +104,7 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { let mut serializer = Serializer::with_formatter(&mut writer, crate::serde_utils::StarknetFormatter); res.serialize(&mut serializer).expect("Unable to serialize with custom formatter"); - let str_json = unsafe { String::from_utf8_unchecked(writer) }; - println!("{}", str_json); + let str_json = String::from_utf8(writer).expect("Cant convert to UTF-8 string"); let keccak_result = crate::hash::sn_keccak(str_json.as_bytes()); keccak_result diff --git a/src/core_test.rs b/src/core_test.rs index 0b7f8f9c..78f54409 100644 --- a/src/core_test.rs +++ b/src/core_test.rs @@ -69,7 +69,6 @@ fn test_calculate_contract_address() { #[test] fn test_contract_class_hash_generation() { let data_str = std::fs::read_to_string("./resources/contract_compiled.json").unwrap(); - println!("{data_str}"); let data: serde_json::Value = serde_json::from_str(&data_str).unwrap(); let expected_class_hash = ClassHash( StarkHash::try_from("0x399998c787e0a063c3ac1d2abac084dcbe09954e3b156d53a8c43a02aa27d35") From f8f8cc643aadf271d293c1203b43b91d0c5737bb Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 09:47:53 +0300 Subject: [PATCH 16/27] used informative message --- src/core.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core.rs b/src/core.rs index 3b26aac9..986d46bb 100644 --- a/src/core.rs +++ b/src/core.rs @@ -80,7 +80,7 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { "program": contract_class.get("program").unwrap_or(&Value::Null) }); - let program_json = abi_json.get_mut("program").expect("msg"); + let program_json = abi_json.get_mut("program").expect("Program key should be present in the JSON object"); let debug_info_json = program_json.get_mut("debug_info"); if debug_info_json.is_some() { program_json From 1f10947f5920a6580bbcba9af58f872987f9bf25 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 09:49:30 +0300 Subject: [PATCH 17/27] replaced json with JSON --- src/core.rs | 10 +++++----- src/utils.rs | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/core.rs b/src/core.rs index 986d46bb..338a3bcb 100644 --- a/src/core.rs +++ b/src/core.rs @@ -85,7 +85,7 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { if debug_info_json.is_some() { program_json .as_object_mut() - .expect("Not a json object") + .expect("Not a JSON object") .insert("debug_info".to_owned(), serde_json::Value::Null); } @@ -96,7 +96,7 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { &|key, value| { return (key == "attributes" || key == "accessible_scopes") && value.is_array() - && value.as_array().expect("Not a json array").is_empty(); + && value.as_array().expect("Not a JSON array").is_empty(); }, ); @@ -134,7 +134,7 @@ fn entry_points_hash_by_type_from_json( } fn get_starkfelt_from_json_unsafe(json: &Value, key: &str) -> StarkFelt { - StarkFelt::try_from(json.get(key).expect("Key not found").as_str().expect("Not a json string")) + StarkFelt::try_from(json.get(key).expect("Key not found").as_str().expect("Not a JSON string")) .expect("Not a valid hash") } @@ -166,7 +166,7 @@ pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> Cla .map(|str| { let hex_str = str .as_str() - .expect("Not a json string") + .expect("Not a JSON string") .as_bytes() .iter() .map(|b| format!("{:02x}", b)) @@ -198,7 +198,7 @@ pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> Cla .unwrap_or(&Vec::::new()) .iter() .map(|str| { - return StarkFelt::try_from(str.as_str().expect("Not a json string")) + return StarkFelt::try_from(str.as_str().expect("Not a JSON string")) .expect("Not a valid hash"); }) .collect::>(); diff --git a/src/utils.rs b/src/utils.rs index 3c7b0ebb..78e06db5 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -39,7 +39,7 @@ where let inner_val = traverse_and_exclude_recursively(value, &mut inner_obj, condition); if !(inner_val.is_object() - && inner_val.as_object().expect("Not a json object").is_empty()) + && inner_val.as_object().expect("Not a JSON object").is_empty()) { inner_arr.push(inner_val) } @@ -67,7 +67,7 @@ where let mut new_obj = serde_json::Map::new(); - for (key, value) in value.as_object().expect("Not a json object") { + for (key, value) in value.as_object().expect("Not a JSON object") { if condition(key, value) { continue; } From 46c78f6115bde67b93f97d8cbf94029aaf9e5807 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 09:50:46 +0300 Subject: [PATCH 18/27] remove unused variable when returning from function --- src/core.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/core.rs b/src/core.rs index 338a3bcb..bc73c336 100644 --- a/src/core.rs +++ b/src/core.rs @@ -106,8 +106,7 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { res.serialize(&mut serializer).expect("Unable to serialize with custom formatter"); let str_json = String::from_utf8(writer).expect("Cant convert to UTF-8 string"); - let keccak_result = crate::hash::sn_keccak(str_json.as_bytes()); - keccak_result + crate::hash::sn_keccak(str_json.as_bytes()) } fn entry_points_hash_by_type_from_json( From 8edafa06a5c7c1c06570113dd5605a17ef17e038 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 09:51:04 +0300 Subject: [PATCH 19/27] removed test prefix --- src/core_test.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core_test.rs b/src/core_test.rs index 78f54409..2d7935a4 100644 --- a/src/core_test.rs +++ b/src/core_test.rs @@ -67,7 +67,7 @@ fn test_calculate_contract_address() { } #[test] -fn test_contract_class_hash_generation() { +fn contract_class_hash_generation() { let data_str = std::fs::read_to_string("./resources/contract_compiled.json").unwrap(); let data: serde_json::Value = serde_json::from_str(&data_str).unwrap(); let expected_class_hash = ClassHash( From 439eee8fde974a00d02aa19a81cf5e9b807ef4ff Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 09:56:28 +0300 Subject: [PATCH 20/27] renamed variable in test --- src/core_test.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/core_test.rs b/src/core_test.rs index 2d7935a4..d55468a7 100644 --- a/src/core_test.rs +++ b/src/core_test.rs @@ -69,12 +69,12 @@ fn test_calculate_contract_address() { #[test] fn contract_class_hash_generation() { let data_str = std::fs::read_to_string("./resources/contract_compiled.json").unwrap(); - let data: serde_json::Value = serde_json::from_str(&data_str).unwrap(); + let contract_class_json: serde_json::Value = serde_json::from_str(&data_str).unwrap(); let expected_class_hash = ClassHash( StarkHash::try_from("0x399998c787e0a063c3ac1d2abac084dcbe09954e3b156d53a8c43a02aa27d35") .unwrap(), ); - let resulted_class_hash = crate::core::compute_contract_class_hash_v0(&data); + let resulted_class_hash = crate::core::compute_contract_class_hash_v0(&contract_class_json); assert_eq!(resulted_class_hash, expected_class_hash); } From 417faa9b34f58eaee4e7da8a0ccc1a3c9972ff24 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 12:33:37 +0300 Subject: [PATCH 21/27] added comment for starknet formatter --- src/serde_utils.rs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/serde_utils.rs b/src/serde_utils.rs index e99d44b4..0503da66 100644 --- a/src/serde_utils.rs +++ b/src/serde_utils.rs @@ -5,6 +5,8 @@ mod serde_utils_test; use serde::de::{Deserialize, Visitor}; use serde::ser::{Serialize, SerializeTuple}; +use serde_json::ser::Formatter; +use std::io; /// A [BytesAsHex](`crate::serde_utils::BytesAsHex`) prefixed with '0x'. pub type PrefixedBytesAsHex = BytesAsHex; @@ -126,9 +128,10 @@ pub fn hex_str_from_bytes(bytes: [u8; N]) if PREFIXED { format!("0x{hex_str}") } else { hex_str.to_string() } } -use std::io; - -use serde_json::ser::Formatter; +/// JSON Formatter that serializes an object with the desired spaces +/// So the serialized object can match the object structure when compiling cairo program. +/// When serializing with the default formatter, the JSON string is without any spaces between elements. +/// Example here . pub struct StarknetFormatter; impl Formatter for StarknetFormatter { From d65538f68d175ef701bbc0b08606069cdbfd81fe Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 12:37:05 +0300 Subject: [PATCH 22/27] comment test for scientific notation --- src/serde_utils_test.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/serde_utils_test.rs b/src/serde_utils_test.rs index 3ae1d1ee..076ce594 100644 --- a/src/serde_utils_test.rs +++ b/src/serde_utils_test.rs @@ -110,6 +110,10 @@ fn hex_as_bytes_serde_not_prefixed() { ); } +/// When serializing using serde_json without arbitrary_precision feature enabled, +/// then big numbers gets serialized to scientific notation like 1.23E+10. +/// This test is to ensure that when used serde_json feature arbitrary_precision +/// the resulted string will not use scientific notation #[test] fn serde_deserialize_big_numbers_without_scientific_notation() { let input = r#"{ From 86998919167a5de24cda04e701de7500a6f15be9 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 12:44:14 +0300 Subject: [PATCH 23/27] removed test from serde_utils_test to utils_test --- src/serde_utils_test.rs | 66 +---------------------------------------- src/utils.rs | 4 +++ src/utils_test.rs | 65 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 70 insertions(+), 65 deletions(-) create mode 100644 src/utils_test.rs diff --git a/src/serde_utils_test.rs b/src/serde_utils_test.rs index 076ce594..fb42c040 100644 --- a/src/serde_utils_test.rs +++ b/src/serde_utils_test.rs @@ -1,5 +1,4 @@ use assert_matches::assert_matches; -use serde_json::Value; use crate::serde_utils::{ bytes_from_hex_str, hex_str_from_bytes, BytesAsHex, InnerDeserializationError, @@ -121,67 +120,4 @@ fn serde_deserialize_big_numbers_without_scientific_notation() { }"#; let json: serde_json::Value = serde_json::from_str(input).unwrap(); assert_eq!(json["value"].to_string(), "20853273475220472486191784820"); -} - -#[test] -fn serde_remove_elements_from_json() { - let input = r#" - { - "name": "John Doe", - "isStudent": true, - "age":30, - "address": { - "street": "Vlvo", - "city": "Anytown", - "state": "Any" - }, - "should_be_removed": [], - "scores": - [ - { - "street": "AAA", - "age": 5, - "should_be_removed": [] - }, - { - "age": 5 - } - ], - "arr": [90, 85, 95] - } - "#; - let expected_output = r#" - { - "name": "John Doe", - "isStudent": true, - "age":30, - "address": { - "street": "Vlvo", - "city": "Anytown", - "state": "Any" - }, - "scores": - [ - { - "street": "AAA", - "age": 5 - }, - { - "age": 5 - } - ], - "arr": [90, 85, 95] - } - "#; - let value: Value = serde_json::from_str(input).unwrap(); - let mut new_object: serde_json::Map = serde_json::Map::new(); - - let res = - crate::utils::traverse_and_exclude_recursively(&value, &mut new_object, &|key, val| { - return key == "should_be_removed" - && val.is_array() - && val.as_array().unwrap().is_empty(); - }); - - assert_eq!(res, serde_json::from_str::(expected_output).unwrap()); -} +} \ No newline at end of file diff --git a/src/utils.rs b/src/utils.rs index 78e06db5..0016faf8 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,3 +1,7 @@ +#[cfg(test)] +#[path = "utils_test.rs"] +mod utils_test; + use serde_json::Value; /// because of the preserve_order feature enabled in the serde_json crate diff --git a/src/utils_test.rs b/src/utils_test.rs new file mode 100644 index 00000000..11aba2c5 --- /dev/null +++ b/src/utils_test.rs @@ -0,0 +1,65 @@ +use serde_json::Value; + + +#[test] +fn serde_remove_elements_from_json() { + let input = r#" + { + "name": "John Doe", + "isStudent": true, + "age":30, + "address": { + "street": "Vlvo", + "city": "Anytown", + "state": "Any" + }, + "should_be_removed": [], + "scores": + [ + { + "street": "AAA", + "age": 5, + "should_be_removed": [] + }, + { + "age": 5 + } + ], + "arr": [90, 85, 95] + } + "#; + let expected_output = r#" + { + "name": "John Doe", + "isStudent": true, + "age":30, + "address": { + "street": "Vlvo", + "city": "Anytown", + "state": "Any" + }, + "scores": + [ + { + "street": "AAA", + "age": 5 + }, + { + "age": 5 + } + ], + "arr": [90, 85, 95] + } + "#; + let value: Value = serde_json::from_str(input).unwrap(); + let mut new_object: serde_json::Map = serde_json::Map::new(); + + let res = + crate::utils::traverse_and_exclude_recursively(&value, &mut new_object, &|key, val| { + return key == "should_be_removed" + && val.is_array() + && val.as_array().unwrap().is_empty(); + }); + + assert_eq!(res, serde_json::from_str::(expected_output).unwrap()); +} From df98097242ad50cad2415e9f14e3ace1fc92612b Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 12:45:29 +0300 Subject: [PATCH 24/27] removed unused method --- src/utils.rs | 28 +--------------------------- 1 file changed, 1 insertion(+), 27 deletions(-) diff --git a/src/utils.rs b/src/utils.rs index 0016faf8..21f6a318 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -54,30 +54,4 @@ where // handle non-object, non-array values _ => value.clone(), } -} - -/// because of the preserve_order feature enabled in the serde_json crate -/// removing a key from the object changes the order of the keys -/// When serde_json is not being used with the preserver order feature -/// deserializing to a serde_json::Value changes the order of the keys -/// Go through object's top level keys and remove those that pass the condition -pub fn traverse_and_exclude_top_level_keys(value: &Value, condition: &F) -> serde_json::Value -where - F: Fn(&String, &Value) -> bool, -{ - if !value.is_object() { - return value.clone(); - } - - let mut new_obj = serde_json::Map::new(); - - for (key, value) in value.as_object().expect("Not a JSON object") { - if condition(key, value) { - continue; - } - - new_obj.insert(key.clone(), value.clone()); - } - - Value::Object(new_obj) -} +} \ No newline at end of file From 8fea9b6950dc07e57fd097b37e6f8ddbbae1dce4 Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Wed, 3 May 2023 12:47:06 +0300 Subject: [PATCH 25/27] cargo fmt --- src/core.rs | 3 ++- src/serde_utils.rs | 18 +++++++++++++++--- src/serde_utils_test.rs | 2 +- src/utils.rs | 2 +- src/utils_test.rs | 1 - 5 files changed, 19 insertions(+), 7 deletions(-) diff --git a/src/core.rs b/src/core.rs index bc73c336..17c92a8f 100644 --- a/src/core.rs +++ b/src/core.rs @@ -80,7 +80,8 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { "program": contract_class.get("program").unwrap_or(&Value::Null) }); - let program_json = abi_json.get_mut("program").expect("Program key should be present in the JSON object"); + let program_json = + abi_json.get_mut("program").expect("Program key should be present in the JSON object"); let debug_info_json = program_json.get_mut("debug_info"); if debug_info_json.is_some() { program_json diff --git a/src/serde_utils.rs b/src/serde_utils.rs index 0503da66..3a56b111 100644 --- a/src/serde_utils.rs +++ b/src/serde_utils.rs @@ -125,7 +125,11 @@ pub fn hex_str_from_bytes(bytes: [u8; N]) let hex_str = hex::encode(bytes); let mut hex_str = hex_str.trim_start_matches('0'); hex_str = if hex_str.is_empty() { "0" } else { hex_str }; - if PREFIXED { format!("0x{hex_str}") } else { hex_str.to_string() } + if PREFIXED { + format!("0x{hex_str}") + } else { + hex_str.to_string() + } } /// JSON Formatter that serializes an object with the desired spaces @@ -146,13 +150,21 @@ impl Formatter for StarknetFormatter { where W: ?Sized + io::Write, { - if first { Ok(()) } else { writer.write_all(b", ") } + if first { + Ok(()) + } else { + writer.write_all(b", ") + } } fn begin_array_value(&mut self, writer: &mut W, first: bool) -> io::Result<()> where W: ?Sized + io::Write, { - if first { Ok(()) } else { writer.write_all(b", ") } + if first { + Ok(()) + } else { + writer.write_all(b", ") + } } } diff --git a/src/serde_utils_test.rs b/src/serde_utils_test.rs index fb42c040..51a54ac4 100644 --- a/src/serde_utils_test.rs +++ b/src/serde_utils_test.rs @@ -120,4 +120,4 @@ fn serde_deserialize_big_numbers_without_scientific_notation() { }"#; let json: serde_json::Value = serde_json::from_str(input).unwrap(); assert_eq!(json["value"].to_string(), "20853273475220472486191784820"); -} \ No newline at end of file +} diff --git a/src/utils.rs b/src/utils.rs index 21f6a318..98bfff95 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -54,4 +54,4 @@ where // handle non-object, non-array values _ => value.clone(), } -} \ No newline at end of file +} diff --git a/src/utils_test.rs b/src/utils_test.rs index 11aba2c5..dd77637a 100644 --- a/src/utils_test.rs +++ b/src/utils_test.rs @@ -1,6 +1,5 @@ use serde_json::Value; - #[test] fn serde_remove_elements_from_json() { let input = r#" From 2901303c0172dd45a45a248423da110b7e5052bd Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Mon, 8 May 2023 17:10:35 +0300 Subject: [PATCH 26/27] replace expect with Error --- src/core.rs | 111 +++++++++++++++++++++++++-------------------- src/core_test.rs | 3 +- src/lib.rs | 5 +- src/serde_utils.rs | 15 ++++++ src/utils.rs | 4 +- 5 files changed, 85 insertions(+), 53 deletions(-) diff --git a/src/core.rs b/src/core.rs index 17c92a8f..e454ffbb 100644 --- a/src/core.rs +++ b/src/core.rs @@ -11,6 +11,7 @@ use serde_json::{json, Serializer, Value}; use starknet_crypto::FieldElement; use crate::hash::{pedersen_hash_array, StarkFelt, StarkHash}; +use crate::serde_utils::{InnerDeserializationError, InnerSerializationError}; use crate::transaction::{Calldata, ContractAddressSalt}; use crate::StarknetApiError; @@ -74,19 +75,21 @@ pub fn calculate_contract_address( ContractAddress::try_from(StarkFelt::from(address)) } -fn compute_class_hash_from_json(contract_class: &Value) -> String { +fn compute_class_hash_from_json(contract_class: &Value) -> Result { let mut abi_json = json!({ "abi": contract_class.get("abi").unwrap_or(&Value::Null), "program": contract_class.get("program").unwrap_or(&Value::Null) }); - let program_json = - abi_json.get_mut("program").expect("Program key should be present in the JSON object"); + let program_json = abi_json + .get_mut("program") + .ok_or(InnerDeserializationError::MissingKey { key: "program".to_string() })?; + let debug_info_json = program_json.get_mut("debug_info"); if debug_info_json.is_some() { program_json .as_object_mut() - .expect("Not a JSON object") + .ok_or(InnerDeserializationError::UnexpectedType { expected: "object".to_string() })? .insert("debug_info".to_owned(), serde_json::Value::Null); } @@ -97,123 +100,135 @@ fn compute_class_hash_from_json(contract_class: &Value) -> String { &|key, value| { return (key == "attributes" || key == "accessible_scopes") && value.is_array() - && value.as_array().expect("Not a JSON array").is_empty(); + && value.as_array().unwrap().is_empty(); }, ); let mut writer = Vec::with_capacity(128); let mut serializer = Serializer::with_formatter(&mut writer, crate::serde_utils::StarknetFormatter); - res.serialize(&mut serializer).expect("Unable to serialize with custom formatter"); - let str_json = String::from_utf8(writer).expect("Cant convert to UTF-8 string"); + res.serialize(&mut serializer).map_err(|_| InnerSerializationError::FormatterError { + formatter: "StarknetFormatter".to_string(), + })?; + + let str_json = String::from_utf8(writer).map_err(|_| InnerSerializationError::Custom { + msg: "Cant convert from bytes to UTF-8 JSON string".to_string(), + })?; - crate::hash::sn_keccak(str_json.as_bytes()) + Ok(crate::hash::sn_keccak(str_json.as_bytes())) } fn entry_points_hash_by_type_from_json( contract_class: &Value, entry_point_type: &str, -) -> StarkFelt { - let felts = contract_class +) -> Result { + let felts: Result, _> = contract_class .get("entry_points_by_type") .unwrap_or(&serde_json::Value::Null) .get(entry_point_type) .unwrap_or(&serde_json::Value::Null) .as_array() .unwrap_or(&Vec::::new()) - .iter() + .clone() + .into_iter() .flat_map(|entry| { - let selector = get_starkfelt_from_json_unsafe(entry, "selector"); - let offset = get_starkfelt_from_json_unsafe(entry, "offset"); + let selector = get_starkfelt_from_json(&entry, "selector"); + let offset = get_starkfelt_from_json(&entry, "offset"); vec![selector, offset] }) - .collect::>(); + .collect(); - pedersen_hash_array(&felts) + Ok(pedersen_hash_array(&felts?)) } -fn get_starkfelt_from_json_unsafe(json: &Value, key: &str) -> StarkFelt { - StarkFelt::try_from(json.get(key).expect("Key not found").as_str().expect("Not a JSON string")) - .expect("Not a valid hash") +fn get_starkfelt_from_json(json: &Value, key: &str) -> Result { + StarkFelt::try_from( + json.get(key) + .ok_or(InnerDeserializationError::MissingKey { key: key.to_string() })? + .as_str() + .ok_or(InnerDeserializationError::UnexpectedType { expected: "string".to_string() })?, + ) } -pub fn compute_contract_class_hash_v0(contract_class: &serde_json::Value) -> ClassHash { +pub fn compute_contract_class_hash_v0( + contract_class: &serde_json::Value, +) -> Result { // api version - let api_version = StarkFelt::try_from(format!("0x{}", hex::encode([0u8])).as_str()) - .expect("Not a valid hash"); + let api_version = StarkFelt::try_from(format!("0x{}", hex::encode([0u8])).as_str())?; // external entry points hash let external_entry_points_hash = - entry_points_hash_by_type_from_json(contract_class, "EXTERNAL"); + entry_points_hash_by_type_from_json(contract_class, "EXTERNAL")?; // l1 handler entry points hash - let l1_entry_points_hash = entry_points_hash_by_type_from_json(contract_class, "L1_HANDLER"); + let l1_entry_points_hash = entry_points_hash_by_type_from_json(contract_class, "L1_HANDLER")?; // constructor handler entry points hash let constructor_entry_points_hash = - entry_points_hash_by_type_from_json(contract_class, "CONSTRUCTOR"); + entry_points_hash_by_type_from_json(contract_class, "CONSTRUCTOR")?; // builtins hash - let builtins_encoded = contract_class + let builtins_encoded: Result, _> = contract_class .get("program") .unwrap_or(&serde_json::Value::Null) .get("builtins") .unwrap_or(&serde_json::Value::Null) .as_array() .unwrap_or(&Vec::::new()) - .iter() + .clone() + .into_iter() .map(|str| { - let hex_str = str - .as_str() - .expect("Not a JSON string") + let json_str = str.as_str().ok_or(InnerDeserializationError::UnexpectedType { + expected: "string".to_string(), + })?; + let hex_str = json_str .as_bytes() .iter() .map(|b| format!("{:02x}", b)) .collect::>() .join(""); - format!("0x{}", hex_str) - }) - .collect::>(); - let builtins_encoded_as_felts = builtins_encoded - .iter() - .map(|s| { - return StarkFelt::try_from(s.as_str()).expect("Not a valid hash"); + Ok::(format!("0x{}", hex_str)) }) - .collect::>(); + .collect(); + + let builtins_encoded_as_felts: Result, _> = + builtins_encoded?.into_iter().map(|s| StarkFelt::try_from(s.as_str())).collect(); - let builtins_hash = pedersen_hash_array(&builtins_encoded_as_felts); + let builtins_hash = pedersen_hash_array(&builtins_encoded_as_felts?); // hinted class hash - let hinted_class_hash = compute_class_hash_from_json(contract_class); + let hinted_class_hash = compute_class_hash_from_json(contract_class)?; // program data hash - let program_data_felts = contract_class + let program_data_felts: Result, _> = contract_class .get("program") .unwrap_or(&Value::Null) .get("data") .unwrap_or(&Value::Null) .as_array() .unwrap_or(&Vec::::new()) - .iter() + .clone() + .into_iter() .map(|str| { - return StarkFelt::try_from(str.as_str().expect("Not a JSON string")) - .expect("Not a valid hash"); + StarkFelt::try_from(str.as_str().ok_or(InnerDeserializationError::UnexpectedType { + expected: "string".to_string(), + })?) }) - .collect::>(); + .collect(); - let program_data_hash = pedersen_hash_array(&program_data_felts); + let program_data_hash = pedersen_hash_array(&program_data_felts?); - ClassHash(pedersen_hash_array(&vec![ + Ok(ClassHash(pedersen_hash_array(&vec![ api_version, external_entry_points_hash, l1_entry_points_hash, constructor_entry_points_hash, builtins_hash, - StarkFelt::try_from(hinted_class_hash.as_str()).expect("Not a valid hash"), + StarkFelt::try_from(hinted_class_hash.as_str())?, program_data_hash, - ])) + ]))) } /// The hash of a ContractClass. diff --git a/src/core_test.rs b/src/core_test.rs index d55468a7..b6937ba3 100644 --- a/src/core_test.rs +++ b/src/core_test.rs @@ -75,6 +75,7 @@ fn contract_class_hash_generation() { .unwrap(), ); - let resulted_class_hash = crate::core::compute_contract_class_hash_v0(&contract_class_json); + let resulted_class_hash = + crate::core::compute_contract_class_hash_v0(&contract_class_json).unwrap(); assert_eq!(resulted_class_hash, expected_class_hash); } diff --git a/src/lib.rs b/src/lib.rs index 7f8c5568..b4fe35c1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -13,7 +13,7 @@ pub mod utils; use std::num::ParseIntError; -use serde_utils::InnerDeserializationError; +use serde_utils::{InnerDeserializationError, InnerSerializationError}; /// The error type returned by StarknetApi. #[derive(thiserror::Error, Clone, Debug)] @@ -27,4 +27,7 @@ pub enum StarknetApiError { /// Error when serializing into number. #[error(transparent)] ParseIntError(#[from] ParseIntError), + /// Error when serializing + #[error(transparent)] + InnerSerialization(#[from] InnerSerializationError), } diff --git a/src/serde_utils.rs b/src/serde_utils.rs index 3a56b111..33212872 100644 --- a/src/serde_utils.rs +++ b/src/serde_utils.rs @@ -89,6 +89,21 @@ pub enum InnerDeserializationError { /// Unexpected input byte count. #[error("Bad input - expected #bytes: {expected_byte_count}, string found: {string_found}.")] BadInput { expected_byte_count: usize, string_found: String }, + #[error("Not found key {key}")] + MissingKey { key: String }, + #[error("Received unexpected type, expected type is {expected}")] + UnexpectedType { expected: String }, + #[error("{msg}")] + Custom { msg: String }, +} + +/// The error type returned by the inner deserialization. +#[derive(thiserror::Error, Clone, Debug)] +pub enum InnerSerializationError { + #[error("Cant serialize using formatter: {formatter}")] + FormatterError { formatter: String }, + #[error("{msg}")] + Custom { msg: String }, } /// Deserializes a Hex decoded as string to a byte array. diff --git a/src/utils.rs b/src/utils.rs index 98bfff95..f37922bb 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -42,9 +42,7 @@ where let mut inner_obj = serde_json::Map::new(); let inner_val = traverse_and_exclude_recursively(value, &mut inner_obj, condition); - if !(inner_val.is_object() - && inner_val.as_object().expect("Not a JSON object").is_empty()) - { + if !(inner_val.is_object() && inner_val.as_object().unwrap().is_empty()) { inner_arr.push(inner_val) } } From ecf4907da95df887e0926d99bd5a4b6d462635fe Mon Sep 17 00:00:00 2001 From: marioiordanov Date: Mon, 8 May 2023 17:21:15 +0300 Subject: [PATCH 27/27] cargo clippy --- src/core.rs | 2 +- src/utils.rs | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/core.rs b/src/core.rs index e454ffbb..563026a8 100644 --- a/src/core.rs +++ b/src/core.rs @@ -100,7 +100,7 @@ fn compute_class_hash_from_json(contract_class: &Value) -> Result