diff --git a/Cargo.lock b/Cargo.lock index 48474cc79b1..c781e60c1eb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10,10 +10,15 @@ dependencies = [ "base64 0.21.7", "bincode", "brillig", + "color-eyre", "criterion", "flate2", "fxhash", + "noir_protobuf", "pprof", + "prost", + "prost-build", + "protoc-prebuilt", "serde", "serde-big-array", "serde-generate", @@ -3000,6 +3005,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "multimap" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03" + [[package]] name = "nargo" version = "1.0.0-beta.3" @@ -3302,6 +3313,14 @@ dependencies = [ "tracing-subscriber", ] +[[package]] +name = "noir_protobuf" +version = "1.0.0-beta.3" +dependencies = [ + "color-eyre", + "prost", +] + [[package]] name = "noir_wasm" version = "1.0.0-beta.3" @@ -3963,6 +3982,16 @@ dependencies = [ "termtree", ] +[[package]] +name = "prettyplease" +version = "0.2.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6924ced06e1f7dfe3fa48d57b9f74f55d8915f5036121bef647ef4b204895fac" +dependencies = [ + "proc-macro2", + "syn 2.0.98", +] + [[package]] name = "prettytable-rs" version = "0.10.0" @@ -4032,6 +4061,68 @@ dependencies = [ "syn 2.0.98", ] +[[package]] +name = "prost" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5" +dependencies = [ + "bytes", + "prost-derive", +] + +[[package]] +name = "prost-build" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf" +dependencies = [ + "heck 0.5.0", + "itertools 0.13.0", + "log", + "multimap", + "once_cell", + "petgraph", + "prettyplease", + "prost", + "prost-types", + "regex", + "syn 2.0.98", + "tempfile", +] + +[[package]] +name = "prost-derive" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d" +dependencies = [ + "anyhow", + "itertools 0.13.0", + "proc-macro2", + "quote", + "syn 2.0.98", +] + +[[package]] +name = "prost-types" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16" +dependencies = [ + "prost", +] + +[[package]] +name = "protoc-prebuilt" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d85d4641fe3b8c6e853dfd09fe35379bc6b6e66bd692ac29ed4f7087de69ed5" +dependencies = [ + "ureq", + "zip", +] + [[package]] name = "quick-error" version = "1.2.3" @@ -5550,6 +5641,21 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" +[[package]] +name = "ureq" +version = "2.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d" +dependencies = [ + "base64 0.22.1", + "log", + "once_cell", + "rustls", + "rustls-pki-types", + "url", + "webpki-roots", +] + [[package]] name = "url" version = "2.5.4" @@ -6132,6 +6238,18 @@ dependencies = [ "syn 2.0.98", ] +[[package]] +name = "zip" +version = "0.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261" +dependencies = [ + "byteorder", + "crc32fast", + "crossbeam-utils", + "flate2", +] + [[package]] name = "zkhash" version = "0.2.0" diff --git a/Cargo.toml b/Cargo.toml index ca954e5846f..0b28d9959c1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -37,6 +37,7 @@ members = [ "acvm-repo/bn254_blackbox_solver", # Utility crates "utils/iter-extended", + "utils/protobuf", ] default-members = [ "tooling/nargo_cli", @@ -94,6 +95,7 @@ noirc_abi = { path = "tooling/noirc_abi" } noirc_artifacts = { path = "tooling/noirc_artifacts" } noirc_artifacts_info = { path = "tooling/noirc_artifacts_info" } noir_artifact_cli = { path = "tooling/artifact_cli" } +noir_protobuf = { path = "utils/protobuf" } # Arkworks ark-bn254 = { version = "^0.5.0", default-features = false, features = [ @@ -137,6 +139,11 @@ criterion = "0.5.0" # https://github.com/tikv/pprof-rs/pull/172 pprof = { version = "0.14", features = ["flamegraph", "criterion"] } +# Protobuf +prost = "0.13" +prost-build = "0.13" +protoc-prebuilt = "0.3" + cfg-if = "1.0.0" dirs = "4" serde = { version = "1.0.136", features = ["derive"] } diff --git a/acvm-repo/acir/Cargo.toml b/acvm-repo/acir/Cargo.toml index 2b15c2abf09..5dae59e953e 100644 --- a/acvm-repo/acir/Cargo.toml +++ b/acvm-repo/acir/Cargo.toml @@ -18,15 +18,23 @@ workspace = true [dependencies] acir_field.workspace = true brillig.workspace = true +noir_protobuf.workspace = true + +color-eyre.workspace = true serde.workspace = true thiserror.workspace = true flate2.workspace = true bincode.workspace = true base64.workspace = true +prost.workspace = true serde-big-array = "0.5.1" strum = { workspace = true } strum_macros = { workspace = true } +[build-dependencies] +prost-build.workspace = true +protoc-prebuilt.workspace = true + [dev-dependencies] serde_json = "1.0" serde-reflection = "0.3.6" diff --git a/acvm-repo/acir/build.rs b/acvm-repo/acir/build.rs new file mode 100644 index 00000000000..31eecd5bf51 --- /dev/null +++ b/acvm-repo/acir/build.rs @@ -0,0 +1,22 @@ +use std::path::Path; + +fn main() { + let (protoc_bin, include_dir) = + protoc_prebuilt::init("29.3").expect("failed to initialize protoc"); + + std::env::set_var("PROTOC", protoc_bin); + + prost_build::compile_protos( + &[ + // DTOs for a `Program`, which work with the types in `acir.cpp` + "./src/proto/program.proto", + // DTOs for the `WitnessStack`, which work with the types in `witness.cpp` + "./src/proto/acir/witness.proto", + // A pared down DTO for `Program`, so Barretenberg can ignore the Brillig part. + // This is only included to make sure it compiles. + "./src/proto/acir/program.proto", + ], + &[Path::new("./src/proto"), include_dir.as_path()], + ) + .expect("failed to compile .proto schemas"); +} diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs index d0f12b1168e..d15255e9da5 100644 --- a/acvm-repo/acir/src/circuit/mod.rs +++ b/acvm-repo/acir/src/circuit/mod.rs @@ -237,9 +237,27 @@ impl Circuit { } } -impl Program { +impl Program { fn write(&self, writer: W) -> std::io::Result<()> { - let buf = bincode::serialize(self).unwrap(); + let buf = { + // # Bincode + // bincode::serialize(self).unwrap() + + // # CBOR + // let mut buf = Vec::new(); + // ciborium::into_writer(self, &mut buf).map_err(std::io::Error::other)?; + // buf + + // # FlexBuffers + // let mut s = flexbuffers::FlexbufferSerializer::new(); + // self.serialize(&mut s).map_err(std::io::Error::other)?; + // s.take_buffer() + + // # Protobuf + use crate::proto::convert::ProtoSchema; + use noir_protobuf::ProtoCodec; + ProtoSchema::::serialize_to_vec(self) + }; let mut encoder = flate2::write::GzEncoder::new(writer, Compression::default()); encoder.write_all(&buf)?; encoder.finish()?; @@ -263,13 +281,28 @@ impl Program { } } -impl Deserialize<'a>> Program { +impl Deserialize<'a>> Program { fn read(reader: R) -> std::io::Result { let mut gz_decoder = flate2::read::GzDecoder::new(reader); - let mut buf_d = Vec::new(); - gz_decoder.read_to_end(&mut buf_d)?; - bincode::deserialize(&buf_d) - .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err)) + let mut buf = Vec::new(); + gz_decoder.read_to_end(&mut buf)?; + let result = { + // # Bincode + // bincode::deserialize(&buf) + + // # CBOR + // ciborium::from_reader(buf.as_slice()) + + // # FlexBuffers + // let r = flexbuffers::Reader::get_root(buf.as_slice()).map_err(std::io::Error::other)?; + // Self::deserialize(r) + + // # Protobuf + use crate::proto::convert::ProtoSchema; + use noir_protobuf::ProtoCodec; + ProtoSchema::::deserialize_from_vec(&buf) + }; + result.map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err)) } /// Deserialize bytecode. diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs index bb5b50c0daf..963853e900a 100644 --- a/acvm-repo/acir/src/lib.rs +++ b/acvm-repo/acir/src/lib.rs @@ -7,6 +7,7 @@ pub mod circuit; pub mod native_types; +mod proto; pub use acir_field; pub use acir_field::{AcirField, FieldElement}; diff --git a/acvm-repo/acir/src/proto/acir/circuit.proto b/acvm-repo/acir/src/proto/acir/circuit.proto new file mode 100644 index 00000000000..c0981d6e30c --- /dev/null +++ b/acvm-repo/acir/src/proto/acir/circuit.proto @@ -0,0 +1,255 @@ +syntax = "proto3"; + +package acvm.acir.circuit; + +import "acir/native.proto"; + +message Circuit { + uint32 current_witness_index = 1; + repeated Opcode opcodes = 2; + ExpressionWidth expression_width = 3; + repeated native.Witness private_parameters = 4; + repeated native.Witness public_parameters = 5; + repeated native.Witness return_values = 6; + repeated AssertMessage assert_messages = 7; +} + +message ExpressionWidth { + oneof value { + Unbounded unbounded = 1; + Bounded bounded = 2; + } + message Unbounded {} + message Bounded { uint64 width = 1; } +} + +message AssertMessage { + OpcodeLocation location = 1; + AssertionPayload payload = 2; +} + +message OpcodeLocation { + oneof value { + uint64 acir = 1; + BrilligLocation brillig = 2; + } + message BrilligLocation { + uint64 acir_index = 1; + uint64 brillig_index = 2; + } +} + +message AssertionPayload { + uint64 error_selector = 1; + repeated ExpressionOrMemory payload = 2; +} + +message ExpressionOrMemory { + oneof value { + native.Expression expression = 1; + uint32 memory = 2; + } +} + +message Opcode { + oneof value { + native.Expression assert_zero = 1; + BlackBoxFuncCall blackbox_func_call = 2; + MemoryOp memory_op = 3; + MemoryInit memory_init = 4; + BrilligCall brillig_call = 5; + Call call = 6; + } + message MemoryOp { + uint32 block_id = 1; + MemOp op = 2; + optional native.Expression predicate = 3; + } + message MemoryInit { + uint32 block_id = 1; + repeated native.Witness init = 2; + BlockType block_type = 3; + } + message BrilligCall { + uint32 id = 1; + repeated BrilligInputs inputs = 2; + repeated BrilligOutputs outputs = 3; + optional native.Expression predicate = 4; + } + message Call { + uint32 id = 1; + repeated native.Witness inputs = 2; + repeated native.Witness outputs = 3; + optional native.Expression predicate = 4; + } +} + +message BlackBoxFuncCall { + oneof value { + AES128Encrypt aes128_encrypt = 1; + AND and = 2; + XOR xor = 3; + RANGE range = 4; + Blake2s blake2s = 5; + Blake3 blake3 = 6; + EcdsaSecp256k1 ecdsa_secp256k1 = 7; + EcdsaSecp256r1 ecdsa_secp256r1 = 8; + MultiScalarMul multi_scalar_mul = 9; + EmbeddedCurveAdd embedded_curve_add = 10; + Keccakf1600 keccak_f1600 = 11; + RecursiveAggregation recursive_aggregation = 12; + BigIntAdd big_int_add = 13; + BigIntSub big_int_sub = 14; + BigIntMul big_int_mul = 15; + BigIntDiv big_int_div = 16; + BigIntFromLeBytes big_int_from_le_bytes = 17; + BigIntToLeBytes big_int_to_le_bytes = 18; + Poseidon2Permutation poseidon2_permutation = 19; + Sha256Compression sha256_compression = 20; + } + message AES128Encrypt { + repeated FunctionInput inputs = 1; + repeated FunctionInput iv = 2; + repeated FunctionInput key = 3; + repeated native.Witness outputs = 4; + } + message AND { + FunctionInput lhs = 1; + FunctionInput rhs = 2; + native.Witness output = 3; + } + message XOR { + FunctionInput lhs = 1; + FunctionInput rhs = 2; + native.Witness output = 3; + } + message RANGE { FunctionInput input = 1; } + message Blake2s { + repeated FunctionInput inputs = 1; + repeated native.Witness outputs = 2; + } + message Blake3 { + repeated FunctionInput inputs = 1; + repeated native.Witness outputs = 2; + } + message EcdsaSecp256k1 { + repeated FunctionInput public_key_x = 1; + repeated FunctionInput public_key_y = 2; + repeated FunctionInput signature = 3; + repeated FunctionInput hashed_message = 4; + native.Witness output = 5; + } + message EcdsaSecp256r1 { + repeated FunctionInput public_key_x = 1; + repeated FunctionInput public_key_y = 2; + repeated FunctionInput signature = 3; + repeated FunctionInput hashed_message = 4; + native.Witness output = 5; + } + message MultiScalarMul { + repeated FunctionInput points = 1; + repeated FunctionInput scalars = 2; + repeated native.Witness outputs = 3; + } + message EmbeddedCurveAdd { + repeated FunctionInput input1 = 1; + repeated FunctionInput input2 = 2; + repeated native.Witness outputs = 3; + } + message Keccakf1600 { + repeated FunctionInput inputs = 1; + repeated native.Witness outputs = 2; + } + message RecursiveAggregation { + repeated FunctionInput verification_key = 1; + repeated FunctionInput proof = 2; + repeated FunctionInput public_inputs = 3; + FunctionInput key_hash = 4; + uint32 proof_type = 5; + } + message BigIntAdd { + uint32 lhs = 1; + uint32 rhs = 2; + uint32 output = 3; + } + message BigIntSub { + uint32 lhs = 1; + uint32 rhs = 2; + uint32 output = 3; + } + message BigIntMul { + uint32 lhs = 1; + uint32 rhs = 2; + uint32 output = 3; + } + message BigIntDiv { + uint32 lhs = 1; + uint32 rhs = 2; + uint32 output = 3; + } + message BigIntFromLeBytes { + repeated FunctionInput inputs = 1; + bytes modulus = 2; + uint32 output = 3; + } + message BigIntToLeBytes { + uint32 input = 1; + repeated native.Witness outputs = 2; + } + message Poseidon2Permutation { + repeated FunctionInput inputs = 1; + repeated native.Witness outputs = 2; + uint32 len = 3; + } + message Sha256Compression { + repeated FunctionInput inputs = 1; + repeated FunctionInput hash_values = 2; + repeated native.Witness outputs = 3; + } +} + +message FunctionInput { + ConstantOrWitnessEnum input = 1; + uint32 num_bits = 2; +} + +message ConstantOrWitnessEnum { + oneof value { + native.Field constant = 1; + native.Witness witness = 2; + } +} + +message MemOp { + native.Expression operation = 1; + native.Expression index = 2; + native.Expression value = 3; +} + +message BlockType { + oneof value { + Memory memory = 1; + CallData call_data = 2; + ReturnData return_data = 3; + } + message Memory {} + message CallData { uint32 value = 1; } + message ReturnData {} +} + +message BrilligInputs { + oneof value { + native.Expression single = 1; + Array array = 2; + uint32 memory_array = 3; + } + message Array { repeated native.Expression values = 2; } +} + +message BrilligOutputs { + oneof value { + native.Witness simple = 1; + Array array = 2; + } + message Array { repeated native.Witness values = 1; } +} diff --git a/acvm-repo/acir/src/proto/acir/native.proto b/acvm-repo/acir/src/proto/acir/native.proto new file mode 100644 index 00000000000..561a79c5701 --- /dev/null +++ b/acvm-repo/acir/src/proto/acir/native.proto @@ -0,0 +1,24 @@ +syntax = "proto3"; + +package acvm.acir.native; + +message Field { bytes value = 1; } + +message Witness { uint32 index = 1; } + +message Expression { + repeated MulTerm mul_terms = 1; + repeated LinearCombination linear_combinations = 2; + Field q_c = 3; + + message MulTerm { + Field q_m = 1; + Witness witness_left = 2; + Witness witness_right = 3; + } + + message LinearCombination { + Field q_l = 1; + Witness witness = 2; + } +} \ No newline at end of file diff --git a/acvm-repo/acir/src/proto/acir/program.proto b/acvm-repo/acir/src/proto/acir/program.proto new file mode 100644 index 00000000000..0032966d0cb --- /dev/null +++ b/acvm-repo/acir/src/proto/acir/program.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; + +package acvm.acir.program; + +// Only including the ACIR types for Berratenberg, not Brillig. +import "acir/circuit.proto"; + +// Same as the top level `program.proto` but ignores the +// `unconstrained_functions` field, so that Berratenberg doesn't need to +// deserialize it. +message Program { + // ACIR circuits + repeated acvm.acir.circuit.Circuit functions = 1; + + reserved 2; + reserved "unconstrained_functions"; +} \ No newline at end of file diff --git a/acvm-repo/acir/src/proto/acir/witness.proto b/acvm-repo/acir/src/proto/acir/witness.proto new file mode 100644 index 00000000000..0ac922f7e20 --- /dev/null +++ b/acvm-repo/acir/src/proto/acir/witness.proto @@ -0,0 +1,9 @@ +syntax = "proto3"; + +package acvm.acir.witness; + +import "acir/native.proto"; + +message WitnessStack { + // TODO +} \ No newline at end of file diff --git a/acvm-repo/acir/src/proto/brillig.proto b/acvm-repo/acir/src/proto/brillig.proto new file mode 100644 index 00000000000..cba8c797889 --- /dev/null +++ b/acvm-repo/acir/src/proto/brillig.proto @@ -0,0 +1,308 @@ +syntax = "proto3"; + +package acvm.brillig; + +import "acir/native.proto"; + +message BrilligBytecode { repeated BrilligOpcode bytecode = 1; } + +message BrilligOpcode { + oneof value { + BinaryFieldOp binary_field_op = 1; + BinaryIntOp binary_int_op = 2; + Not not = 3; + Cast cast = 4; + JumpIfNot jump_if_not = 5; + JumpIf jump_if = 6; + Jump jump = 7; + CalldataCopy calldata_copy = 8; + Call call = 9; + Const const = 10; + IndirectConst indirect_const = 11; + Return return = 12; + ForeignCall foreign_call = 13; + Mov mov = 14; + ConditionalMov conditional_mov = 15; + Load load = 16; + Store store = 17; + BlackBox black_box = 18; + Trap trap = 19; + Stop stop = 20; + } + message BinaryFieldOp { + MemoryAddress destination = 1; + BinaryFieldOpKind op = 2; + MemoryAddress lhs = 3; + MemoryAddress rhs = 4; + } + message BinaryIntOp { + MemoryAddress destination = 1; + BinaryIntOpKind op = 2; + IntegerBitSize bit_size = 3; + MemoryAddress lhs = 4; + MemoryAddress rhs = 5; + } + message Not { + MemoryAddress destination = 1; + MemoryAddress source = 2; + IntegerBitSize bit_size = 3; + } + message Cast { + MemoryAddress destination = 1; + MemoryAddress source = 2; + BitSize bit_size = 3; + } + message JumpIfNot { + MemoryAddress condition = 1; + uint64 location = 2; + } + message JumpIf { + MemoryAddress condition = 1; + uint64 location = 2; + } + message Jump { uint64 location = 1; } + message CalldataCopy { + MemoryAddress destination_address = 1; + MemoryAddress size_address = 2; + MemoryAddress offset_address = 3; + } + message Call { uint64 location = 1; } + message Const { + MemoryAddress destination = 1; + BitSize bit_size = 2; + acir.native.Field value = 3; + } + message IndirectConst { + MemoryAddress destination_pointer = 1; + BitSize bit_size = 2; + acir.native.Field value = 3; + } + message Return {} + message ForeignCall { + string function = 1; + repeated ValueOrArray destinations = 2; + repeated HeapValueType destination_value_types = 3; + repeated ValueOrArray inputs = 4; + repeated HeapValueType input_value_types = 5; + } + message Mov { + MemoryAddress destination = 1; + MemoryAddress source = 2; + } + message ConditionalMov { + MemoryAddress destination = 1; + MemoryAddress source_a = 2; + MemoryAddress source_b = 3; + MemoryAddress condition = 4; + } + message Load { + MemoryAddress destination = 1; + MemoryAddress source_pointer = 2; + } + message Store { + MemoryAddress destination_pointer = 1; + MemoryAddress source = 2; + } + message BlackBox { BlackBoxOp op = 1; } + message Trap { HeapVector revert_data = 1; } + message Stop { HeapVector return_data = 1; } +} + +message MemoryAddress { + oneof value { + uint64 direct = 1; + uint64 relative = 2; + } +} + +message ValueOrArray { + oneof value { + MemoryAddress memory_address = 1; + HeapArray heap_array = 2; + HeapVector heap_vector = 3; + } +} + +message HeapArray { + MemoryAddress pointer = 1; + uint64 size = 2; +} + +message HeapVector { + MemoryAddress pointer = 1; + MemoryAddress size = 2; +} + +message HeapValueType { + oneof value { + BitSize simple = 1; + Array array = 2; + Vector vector = 3; + } + message Array { + repeated HeapValueType value_types = 1; + uint64 size = 2; + } + message Vector { repeated HeapValueType value_types = 1; } +} + +enum BinaryFieldOpKind { + BFO_UNSPECIFIED = 0; + BFO_ADD = 1; + BFO_SUB = 2; + BFO_MUL = 3; + BFO_DIV = 4; + BFO_INTEGER_DIV = 5; + BFO_EQUALS = 6; + BFO_LESS_THAN = 7; + BFO_LESS_THAN_EQUALS = 8; +} + +enum BinaryIntOpKind { + BIO_UNSPECIFIED = 0; + BIO_ADD = 1; + BIO_SUB = 2; + BIO_MUL = 3; + BIO_DIV = 4; + BIO_EQUALS = 5; + BIO_LESS_THAN = 6; + BIO_LESS_THAN_EQUALS = 7; + BIO_AND = 8; + BIO_OR = 9; + BIO_XOR = 10; + BIO_SHL = 11; + BIO_SHR = 12; +} + +enum IntegerBitSize { + IBS_UNSPECIFIED = 0; + IBS_U1 = 1; + IBS_U8 = 8; + IBS_U16 = 16; + IBS_U32 = 32; + IBS_U64 = 64; + IBS_U128 = 128; +} + +message BitSize { + oneof value { + Field field = 1; + IntegerBitSize integer = 2; + } + message Field {} +} + +message BlackBoxOp { + oneof value { + AES128Encrypt aes128_encrypt = 1; + Blake2s blake2s = 2; + Blake3 blake3 = 3; + Keccakf1600 keccak_f1600 = 4; + EcdsaSecp256k1 ecdsa_secp256k1 = 5; + EcdsaSecp256r1 ecdsa_secp256r1 = 6; + MultiScalarMul multi_scalar_mul = 7; + EmbeddedCurveAdd embedded_curve_add = 8; + BigIntAdd big_int_add = 9; + BigIntSub big_int_sub = 10; + BigIntMul big_int_mul = 11; + BigIntDiv big_int_div = 12; + BigIntFromLeBytes big_int_from_le_bytes = 13; + BigIntToLeBytes big_int_to_le_bytes = 14; + Poseidon2Permutation poseidon2_permutation = 15; + Sha256Compression sha256_compression = 16; + ToRadix to_radix = 17; + } + message AES128Encrypt { + HeapVector inputs = 1; + HeapArray iv = 2; + HeapArray key = 3; + HeapVector outputs = 4; + } + message Blake2s { + HeapVector message = 1; + HeapArray output = 2; + } + message Blake3 { + HeapVector message = 1; + HeapArray output = 2; + } + message Keccakf1600 { + HeapArray input = 1; + HeapArray output = 2; + } + message EcdsaSecp256k1 { + HeapVector hashed_msg = 1; + HeapArray public_key_x = 2; + HeapArray public_key_y = 3; + HeapArray signature = 4; + MemoryAddress result = 5; + } + message EcdsaSecp256r1 { + HeapVector hashed_msg = 1; + HeapArray public_key_x = 2; + HeapArray public_key_y = 3; + HeapArray signature = 4; + MemoryAddress result = 5; + } + + message MultiScalarMul { + HeapVector points = 1; + HeapVector scalars = 2; + HeapArray outputs = 3; + } + message EmbeddedCurveAdd { + MemoryAddress input1_x = 1; + MemoryAddress input1_y = 2; + MemoryAddress input1_infinite = 3; + MemoryAddress input2_x = 4; + MemoryAddress input2_y = 5; + MemoryAddress input2_infinite = 6; + HeapArray result = 7; + } + message BigIntAdd { + MemoryAddress lhs = 1; + MemoryAddress rhs = 2; + MemoryAddress output = 3; + } + message BigIntSub { + MemoryAddress lhs = 1; + MemoryAddress rhs = 2; + MemoryAddress output = 3; + } + message BigIntMul { + MemoryAddress lhs = 1; + MemoryAddress rhs = 2; + MemoryAddress output = 3; + } + message BigIntDiv { + MemoryAddress lhs = 1; + MemoryAddress rhs = 2; + MemoryAddress output = 3; + } + message BigIntFromLeBytes { + HeapVector inputs = 1; + HeapVector modulus = 2; + MemoryAddress output = 3; + } + message BigIntToLeBytes { + MemoryAddress input = 1; + HeapVector output = 2; + } + message Poseidon2Permutation { + HeapVector message = 1; + HeapArray output = 2; + MemoryAddress len = 3; + } + message Sha256Compression { + HeapArray input = 1; + HeapArray hash_values = 2; + HeapArray output = 3; + } + message ToRadix { + MemoryAddress input = 1; + MemoryAddress radix = 2; + MemoryAddress output_pointer = 3; + MemoryAddress num_limbs = 4; + MemoryAddress output_bits = 5; + } +} \ No newline at end of file diff --git a/acvm-repo/acir/src/proto/convert/acir.rs b/acvm-repo/acir/src/proto/convert/acir.rs new file mode 100644 index 00000000000..9f40d3f50c8 --- /dev/null +++ b/acvm-repo/acir/src/proto/convert/acir.rs @@ -0,0 +1,507 @@ +use crate::{ + circuit::{ + self, + opcodes::{self, BlockId}, + }, + proto::acir::circuit::{ + AssertMessage, AssertionPayload, BlackBoxFuncCall, BlockType, BrilligInputs, + BrilligOutputs, Circuit, ConstantOrWitnessEnum, ExpressionOrMemory, ExpressionWidth, + FunctionInput, MemOp, Opcode, OpcodeLocation, + }, +}; +use acir_field::AcirField; +use color_eyre::eyre::{self, Context}; +use noir_protobuf::{decode_oneof_map, ProtoCodec}; + +use super::ProtoSchema; + +impl ProtoCodec, Circuit> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &circuit::Circuit) -> Circuit { + Circuit { + current_witness_index: value.current_witness_index, + opcodes: Self::encode_vec(&value.opcodes), + expression_width: Self::encode_some(&value.expression_width), + private_parameters: Self::encode_vec(value.private_parameters.iter()), + public_parameters: Self::encode_vec(value.public_parameters.0.iter()), + return_values: Self::encode_vec(value.return_values.0.iter()), + assert_messages: Self::encode_vec(&value.assert_messages), + } + } + + fn decode(value: &Circuit) -> eyre::Result> { + Ok(circuit::Circuit { + current_witness_index: value.current_witness_index, + opcodes: Self::decode_vec_msg(&value.opcodes, "opcodes")?, + expression_width: Self::decode_some_msg(&value.expression_width, "expression_width")?, + private_parameters: Self::decode_vec_msg( + &value.private_parameters, + "private_parameters", + )? + .into_iter() + .collect(), + public_parameters: circuit::PublicInputs( + Self::decode_vec_msg(&value.public_parameters, "public_parameters")? + .into_iter() + .collect(), + ), + return_values: circuit::PublicInputs( + Self::decode_vec_msg(&value.return_values, "return_values")?.into_iter().collect(), + ), + assert_messages: Self::decode_vec_msg(&value.assert_messages, "assert_messages")?, + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &circuit::ExpressionWidth) -> ExpressionWidth { + use crate::proto::acir::circuit::expression_width::*; + let value = match value { + circuit::ExpressionWidth::Unbounded => Value::Unbounded(Unbounded {}), + circuit::ExpressionWidth::Bounded { width } => { + Value::Bounded(Bounded { width: Self::encode(width) }) + } + }; + ExpressionWidth { value: Some(value) } + } + + fn decode(value: &ExpressionWidth) -> eyre::Result { + use crate::proto::acir::circuit::expression_width::*; + decode_oneof_map(&value.value, |value| match value { + Value::Unbounded(_) => Ok(circuit::ExpressionWidth::Unbounded), + Value::Bounded(bounded) => Ok(circuit::ExpressionWidth::Bounded { + width: Self::decode_msg(&bounded.width, "width")?, + }), + }) + } +} + +impl ProtoCodec<(circuit::OpcodeLocation, circuit::AssertionPayload), AssertMessage> + for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &(circuit::OpcodeLocation, circuit::AssertionPayload)) -> AssertMessage { + AssertMessage { + location: Self::encode_some(&value.0), + payload: Self::encode_some(&value.1), + } + } + + fn decode( + value: &AssertMessage, + ) -> eyre::Result<(circuit::OpcodeLocation, circuit::AssertionPayload)> { + let location = Self::decode_some_msg(&value.location, "location")?; + let payload = Self::decode_some_msg(&value.payload, "payload")?; + Ok((location, payload)) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &circuit::OpcodeLocation) -> OpcodeLocation { + use crate::proto::acir::circuit::opcode_location::*; + let value = match value { + circuit::OpcodeLocation::Acir(size) => Value::Acir(Self::encode(size)), + circuit::OpcodeLocation::Brillig { acir_index, brillig_index } => { + Value::Brillig(BrilligLocation { + acir_index: Self::encode(acir_index), + brillig_index: Self::encode(brillig_index), + }) + } + }; + OpcodeLocation { value: Some(value) } + } + + fn decode(value: &OpcodeLocation) -> eyre::Result { + use crate::proto::acir::circuit::opcode_location::*; + decode_oneof_map(&value.value, |value| match value { + Value::Acir(location) => { + Ok(circuit::OpcodeLocation::Acir(Self::decode_msg(location, "location")?)) + } + Value::Brillig(brillig_location) => Ok(circuit::OpcodeLocation::Brillig { + acir_index: Self::decode_msg(&brillig_location.acir_index, "acir_index")?, + brillig_index: Self::decode_msg(&brillig_location.brillig_index, "brillig_index")?, + }), + }) + } +} + +impl ProtoCodec, AssertionPayload> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &circuit::AssertionPayload) -> AssertionPayload { + AssertionPayload { + error_selector: value.error_selector, + payload: Self::encode_vec(&value.payload), + } + } + + fn decode(value: &AssertionPayload) -> eyre::Result> { + Ok(circuit::AssertionPayload { + error_selector: value.error_selector, + payload: Self::decode_vec_msg(&value.payload, "payload")?, + }) + } +} + +impl ProtoCodec, ExpressionOrMemory> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &circuit::ExpressionOrMemory) -> ExpressionOrMemory { + use crate::proto::acir::circuit::expression_or_memory::*; + let value = match value { + circuit::ExpressionOrMemory::Expression(expression) => { + Value::Expression(Self::encode(expression)) + } + circuit::ExpressionOrMemory::Memory(block_id) => Value::Memory(block_id.0), + }; + ExpressionOrMemory { value: Some(value) } + } + + fn decode(value: &ExpressionOrMemory) -> eyre::Result> { + use crate::proto::acir::circuit::expression_or_memory::*; + decode_oneof_map(&value.value, |value| match value { + Value::Expression(expression) => Ok(circuit::ExpressionOrMemory::Expression( + Self::decode_msg(expression, "expression")?, + )), + Value::Memory(id) => Ok(circuit::ExpressionOrMemory::Memory(BlockId(*id))), + }) + } +} + +impl ProtoCodec, Opcode> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &circuit::Opcode) -> Opcode { + use crate::proto::acir::circuit::opcode::*; + let value = match value { + circuit::Opcode::AssertZero(expression) => Value::AssertZero(Self::encode(expression)), + circuit::Opcode::BlackBoxFuncCall(black_box_func_call) => { + Value::BlackboxFuncCall(Self::encode(black_box_func_call)) + } + circuit::Opcode::MemoryOp { block_id, op, predicate } => Value::MemoryOp(MemoryOp { + block_id: block_id.0, + op: Self::encode_some(op), + predicate: predicate.as_ref().map(Self::encode), + }), + circuit::Opcode::MemoryInit { block_id, init, block_type } => { + Value::MemoryInit(MemoryInit { + block_id: block_id.0, + init: Self::encode_vec(init), + block_type: Self::encode_some(block_type), + }) + } + circuit::Opcode::BrilligCall { id, inputs, outputs, predicate } => { + Value::BrilligCall(BrilligCall { + id: id.0, + inputs: Self::encode_vec(inputs), + outputs: Self::encode_vec(outputs), + predicate: predicate.as_ref().map(Self::encode), + }) + } + circuit::Opcode::Call { id, inputs, outputs, predicate } => Value::Call(Call { + id: id.0, + inputs: Self::encode_vec(inputs), + outputs: Self::encode_vec(outputs), + predicate: predicate.as_ref().map(Self::encode), + }), + }; + Opcode { value: Some(value) } + } + + fn decode(_value: &Opcode) -> eyre::Result> { + todo!("decode") + } +} + +impl ProtoCodec, MemOp> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &opcodes::MemOp) -> MemOp { + MemOp { + operation: Self::encode_some(&value.operation), + index: Self::encode_some(&value.index), + value: Self::encode_some(&value.value), + } + } + + fn decode(value: &MemOp) -> eyre::Result> { + Ok(opcodes::MemOp { + operation: Self::decode_some_msg(&value.operation, "operation")?, + index: Self::decode_some_msg(&value.index, "index")?, + value: Self::decode_some_msg(&value.value, "value")?, + }) + } +} + +impl ProtoCodec, BlackBoxFuncCall> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &opcodes::BlackBoxFuncCall) -> BlackBoxFuncCall { + use crate::proto::acir::circuit::black_box_func_call::*; + let value = match value { + opcodes::BlackBoxFuncCall::AES128Encrypt { inputs, iv, key, outputs } => { + Value::Aes128Encrypt(Aes128Encrypt { + inputs: Self::encode_vec(inputs), + iv: Self::encode_vec(iv.as_ref()), + key: Self::encode_vec(key.as_ref()), + outputs: Self::encode_vec(outputs), + }) + } + opcodes::BlackBoxFuncCall::AND { lhs, rhs, output } => Value::And(And { + lhs: Self::encode_some(lhs), + rhs: Self::encode_some(rhs), + output: Self::encode_some(output), + }), + opcodes::BlackBoxFuncCall::XOR { lhs, rhs, output } => Value::Xor(Xor { + lhs: Self::encode_some(lhs), + rhs: Self::encode_some(rhs), + output: Self::encode_some(output), + }), + opcodes::BlackBoxFuncCall::RANGE { input } => { + Value::Range(Range { input: Self::encode_some(input) }) + } + opcodes::BlackBoxFuncCall::Blake2s { inputs, outputs } => Value::Blake2s(Blake2s { + inputs: Self::encode_vec(inputs), + outputs: Self::encode_vec(outputs.as_ref()), + }), + opcodes::BlackBoxFuncCall::Blake3 { inputs, outputs } => Value::Blake3(Blake3 { + inputs: Self::encode_vec(inputs), + outputs: Self::encode_vec(outputs.as_ref()), + }), + opcodes::BlackBoxFuncCall::EcdsaSecp256k1 { + public_key_x, + public_key_y, + signature, + hashed_message, + output, + } => Value::EcdsaSecp256k1(EcdsaSecp256k1 { + public_key_x: Self::encode_vec(public_key_x.as_ref()), + public_key_y: Self::encode_vec(public_key_y.as_ref()), + signature: Self::encode_vec(signature.as_ref()), + hashed_message: Self::encode_vec(hashed_message.as_ref()), + output: Self::encode_some(output), + }), + opcodes::BlackBoxFuncCall::EcdsaSecp256r1 { + public_key_x, + public_key_y, + signature, + hashed_message, + output, + } => Value::EcdsaSecp256r1(EcdsaSecp256r1 { + public_key_x: Self::encode_vec(public_key_x.as_ref()), + public_key_y: Self::encode_vec(public_key_y.as_ref()), + signature: Self::encode_vec(signature.as_ref()), + hashed_message: Self::encode_vec(hashed_message.as_ref()), + output: Self::encode_some(output), + }), + opcodes::BlackBoxFuncCall::MultiScalarMul { points, scalars, outputs } => { + let (o0, o1, o2) = outputs; + Value::MultiScalarMul(MultiScalarMul { + points: Self::encode_vec(points), + scalars: Self::encode_vec(scalars), + outputs: Self::encode_vec([o0, o1, o2]), + }) + } + opcodes::BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, outputs } => { + let (o0, o1, o2) = outputs; + Value::EmbeddedCurveAdd(EmbeddedCurveAdd { + input1: Self::encode_vec(input1.as_ref()), + input2: Self::encode_vec(input2.as_ref()), + outputs: Self::encode_vec([o0, o1, o2]), + }) + } + opcodes::BlackBoxFuncCall::Keccakf1600 { inputs, outputs } => { + Value::KeccakF1600(Keccakf1600 { + inputs: Self::encode_vec(inputs.as_ref()), + outputs: Self::encode_vec(outputs.as_ref()), + }) + } + opcodes::BlackBoxFuncCall::RecursiveAggregation { + verification_key, + proof, + public_inputs, + key_hash, + proof_type, + } => Value::RecursiveAggregation(RecursiveAggregation { + verification_key: Self::encode_vec(verification_key), + proof: Self::encode_vec(proof), + public_inputs: Self::encode_vec(public_inputs), + key_hash: Self::encode_some(key_hash), + proof_type: *proof_type, + }), + opcodes::BlackBoxFuncCall::BigIntAdd { lhs, rhs, output } => { + Value::BigIntAdd(BigIntAdd { lhs: *lhs, rhs: *rhs, output: *output }) + } + opcodes::BlackBoxFuncCall::BigIntSub { lhs, rhs, output } => { + Value::BigIntSub(BigIntSub { lhs: *lhs, rhs: *rhs, output: *output }) + } + opcodes::BlackBoxFuncCall::BigIntMul { lhs, rhs, output } => { + Value::BigIntMul(BigIntMul { lhs: *lhs, rhs: *rhs, output: *output }) + } + opcodes::BlackBoxFuncCall::BigIntDiv { lhs, rhs, output } => { + Value::BigIntDiv(BigIntDiv { lhs: *lhs, rhs: *rhs, output: *output }) + } + opcodes::BlackBoxFuncCall::BigIntFromLeBytes { inputs, modulus, output } => { + Value::BigIntFromLeBytes(BigIntFromLeBytes { + inputs: Self::encode_vec(inputs), + modulus: modulus.clone(), + output: *output, + }) + } + opcodes::BlackBoxFuncCall::BigIntToLeBytes { input, outputs } => { + Value::BigIntToLeBytes(BigIntToLeBytes { + input: *input, + outputs: Self::encode_vec(outputs), + }) + } + opcodes::BlackBoxFuncCall::Poseidon2Permutation { inputs, outputs, len } => { + Value::Poseidon2Permutation(Poseidon2Permutation { + inputs: Self::encode_vec(inputs), + outputs: Self::encode_vec(outputs), + len: *len, + }) + } + opcodes::BlackBoxFuncCall::Sha256Compression { inputs, hash_values, outputs } => { + Value::Sha256Compression(Sha256Compression { + inputs: Self::encode_vec(inputs.as_ref()), + hash_values: Self::encode_vec(hash_values.as_ref()), + outputs: Self::encode_vec(outputs.as_ref()), + }) + } + }; + BlackBoxFuncCall { value: Some(value) } + } + + fn decode(_value: &BlackBoxFuncCall) -> eyre::Result> { + todo!("decode") + } +} + +impl ProtoCodec, FunctionInput> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &opcodes::FunctionInput) -> FunctionInput { + FunctionInput { input: Self::encode_some(value.input_ref()), num_bits: value.num_bits() } + } + + fn decode(value: &FunctionInput) -> eyre::Result> { + let input = Self::decode_some_msg(&value.input, "input")?; + + match input { + opcodes::ConstantOrWitnessEnum::Constant(c) => { + opcodes::FunctionInput::constant(c, value.num_bits).wrap_err("constant") + } + opcodes::ConstantOrWitnessEnum::Witness(w) => { + Ok(opcodes::FunctionInput::witness(w, value.num_bits)) + } + } + } +} + +impl ProtoCodec, ConstantOrWitnessEnum> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &opcodes::ConstantOrWitnessEnum) -> ConstantOrWitnessEnum { + use crate::proto::acir::circuit::constant_or_witness_enum::*; + let value = match value { + opcodes::ConstantOrWitnessEnum::Constant(field) => Value::Constant(Self::encode(field)), + opcodes::ConstantOrWitnessEnum::Witness(witness) => { + Value::Witness(Self::encode(witness)) + } + }; + ConstantOrWitnessEnum { value: Some(value) } + } + + fn decode(value: &ConstantOrWitnessEnum) -> eyre::Result> { + use crate::proto::acir::circuit::constant_or_witness_enum::*; + decode_oneof_map(&value.value, |value| match value { + Value::Constant(field) => { + Ok(opcodes::ConstantOrWitnessEnum::Constant(Self::decode_msg(field, "constant")?)) + } + Value::Witness(witness) => { + Ok(opcodes::ConstantOrWitnessEnum::Witness(Self::decode_msg(witness, "witness")?)) + } + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &opcodes::BlockType) -> BlockType { + use crate::proto::acir::circuit::block_type::*; + let value = match value { + opcodes::BlockType::Memory => Value::Memory(Memory {}), + opcodes::BlockType::CallData(value) => Value::CallData(CallData { value: *value }), + opcodes::BlockType::ReturnData => Value::ReturnData(ReturnData {}), + }; + BlockType { value: Some(value) } + } + + fn decode(_value: &BlockType) -> eyre::Result { + todo!("decode") + } +} + +impl ProtoCodec, BrilligInputs> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &circuit::brillig::BrilligInputs) -> BrilligInputs { + use crate::proto::acir::circuit::brillig_inputs::*; + let value = match value { + circuit::brillig::BrilligInputs::Single(expression) => { + Value::Single(Self::encode(expression)) + } + circuit::brillig::BrilligInputs::Array(expressions) => { + Value::Array(Array { values: Self::encode_vec(expressions) }) + } + circuit::brillig::BrilligInputs::MemoryArray(block_id) => { + Value::MemoryArray(block_id.0) + } + }; + BrilligInputs { value: Some(value) } + } + + fn decode(value: &BrilligInputs) -> eyre::Result> { + use crate::proto::acir::circuit::brillig_inputs::*; + decode_oneof_map(&value.value, |value| match value { + Value::Single(expression) => { + Ok(circuit::brillig::BrilligInputs::Single(Self::decode_msg(expression, "single")?)) + } + Value::Array(array) => Ok(circuit::brillig::BrilligInputs::Array( + Self::decode_vec_msg(&array.values, "array")?, + )), + Value::MemoryArray(id) => { + Ok(circuit::brillig::BrilligInputs::MemoryArray(BlockId(*id))) + } + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &circuit::brillig::BrilligOutputs) -> BrilligOutputs { + use crate::proto::acir::circuit::brillig_outputs::*; + let value = match value { + circuit::brillig::BrilligOutputs::Simple(witness) => { + Value::Simple(Self::encode(witness)) + } + circuit::brillig::BrilligOutputs::Array(witnesses) => { + Value::Array(Array { values: Self::encode_vec(witnesses) }) + } + }; + BrilligOutputs { value: Some(value) } + } + + fn decode(_value: &BrilligOutputs) -> eyre::Result { + todo!("decode") + } +} diff --git a/acvm-repo/acir/src/proto/convert/brillig.rs b/acvm-repo/acir/src/proto/convert/brillig.rs new file mode 100644 index 00000000000..cc036360777 --- /dev/null +++ b/acvm-repo/acir/src/proto/convert/brillig.rs @@ -0,0 +1,743 @@ +use crate::{ + circuit, + proto::brillig::{BitSize, BlackBoxOp, HeapArray, HeapValueType, HeapVector, ValueOrArray}, +}; +use acir_field::AcirField; +use color_eyre::eyre::{self, bail}; +use noir_protobuf::{decode_oneof_map, ProtoCodec}; + +use crate::proto::brillig::{ + brillig_opcode, BinaryFieldOpKind, BinaryIntOpKind, BrilligBytecode, BrilligOpcode, + IntegerBitSize, MemoryAddress, +}; + +use super::ProtoSchema; + +impl ProtoCodec, BrilligBytecode> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &circuit::brillig::BrilligBytecode) -> BrilligBytecode { + BrilligBytecode { bytecode: Self::encode_vec(&value.bytecode) } + } + + fn decode(value: &BrilligBytecode) -> eyre::Result> { + Ok(circuit::brillig::BrilligBytecode { + bytecode: Self::decode_vec_msg(&value.bytecode, "bytecode")?, + }) + } +} + +impl ProtoCodec, BrilligOpcode> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &brillig::Opcode) -> BrilligOpcode { + use brillig_opcode::*; + + let value = match value { + brillig::Opcode::BinaryFieldOp { destination, op, lhs, rhs } => { + Value::BinaryFieldOp(BinaryFieldOp { + destination: Self::encode_some(destination), + op: Self::encode_enum(op), + lhs: Self::encode_some(lhs), + rhs: Self::encode_some(rhs), + }) + } + brillig::Opcode::BinaryIntOp { destination, op, bit_size, lhs, rhs } => { + Value::BinaryIntOp(BinaryIntOp { + destination: Self::encode_some(destination), + op: Self::encode_enum(op), + bit_size: Self::encode_enum(bit_size), + lhs: Self::encode_some(lhs), + rhs: Self::encode_some(rhs), + }) + } + brillig::Opcode::Not { destination, source, bit_size } => Value::Not(Not { + destination: Self::encode_some(destination), + source: Self::encode_some(source), + bit_size: Self::encode_enum(bit_size), + }), + brillig::Opcode::Cast { destination, source, bit_size } => Value::Cast(Cast { + destination: Self::encode_some(destination), + source: Self::encode_some(source), + bit_size: Self::encode_some(bit_size), + }), + brillig::Opcode::JumpIfNot { condition, location } => Value::JumpIfNot(JumpIfNot { + condition: Self::encode_some(condition), + location: Self::encode(location), + }), + brillig::Opcode::JumpIf { condition, location } => Value::JumpIf(JumpIf { + condition: Self::encode_some(condition), + location: Self::encode(location), + }), + brillig::Opcode::Jump { location } => { + Value::Jump(Jump { location: Self::encode(location) }) + } + brillig::Opcode::CalldataCopy { destination_address, size_address, offset_address } => { + Value::CalldataCopy(CalldataCopy { + destination_address: Self::encode_some(destination_address), + size_address: Self::encode_some(size_address), + offset_address: Self::encode_some(offset_address), + }) + } + brillig::Opcode::Call { location } => { + Value::Call(Call { location: Self::encode(location) }) + } + brillig::Opcode::Const { destination, bit_size, value } => Value::Const(Const { + destination: Self::encode_some(destination), + bit_size: Self::encode_some(bit_size), + value: Self::encode_some(value), + }), + brillig::Opcode::IndirectConst { destination_pointer, bit_size, value } => { + Value::IndirectConst(IndirectConst { + destination_pointer: Self::encode_some(destination_pointer), + bit_size: Self::encode_some(bit_size), + value: Self::encode_some(value), + }) + } + brillig::Opcode::Return => Value::Return(Return {}), + brillig::Opcode::ForeignCall { + function, + destinations, + destination_value_types, + inputs, + input_value_types, + } => Value::ForeignCall(ForeignCall { + function: function.to_string(), + destinations: Self::encode_vec(destinations), + destination_value_types: Self::encode_vec(destination_value_types), + inputs: Self::encode_vec(inputs), + input_value_types: Self::encode_vec(input_value_types), + }), + brillig::Opcode::Mov { destination, source } => Value::Mov(Mov { + destination: Self::encode_some(destination), + source: Self::encode_some(source), + }), + brillig::Opcode::ConditionalMov { destination, source_a, source_b, condition } => { + Value::ConditionalMov(ConditionalMov { + destination: Self::encode_some(destination), + source_a: Self::encode_some(source_a), + source_b: Self::encode_some(source_b), + condition: Self::encode_some(condition), + }) + } + brillig::Opcode::Load { destination, source_pointer } => Value::Load(Load { + destination: Self::encode_some(destination), + source_pointer: Self::encode_some(source_pointer), + }), + brillig::Opcode::Store { destination_pointer, source } => Value::Store(Store { + destination_pointer: Self::encode_some(destination_pointer), + source: Self::encode_some(source), + }), + brillig::Opcode::BlackBox(black_box_op) => { + Value::BlackBox(BlackBox { op: Self::encode_some(black_box_op) }) + } + brillig::Opcode::Trap { revert_data } => { + Value::Trap(Trap { revert_data: Self::encode_some(revert_data) }) + } + brillig::Opcode::Stop { return_data } => { + Value::Stop(Stop { return_data: Self::encode_some(return_data) }) + } + }; + BrilligOpcode { value: Some(value) } + } + + fn decode(value: &BrilligOpcode) -> eyre::Result> { + use brillig_opcode::*; + + decode_oneof_map(&value.value, |value| match value { + Value::BinaryFieldOp(binary_field_op) => Ok(brillig::Opcode::BinaryFieldOp { + destination: Self::decode_some_msg(&binary_field_op.destination, "destination")?, + op: Self::decode_enum_msg(binary_field_op.op, "op")?, + lhs: Self::decode_some_msg(&binary_field_op.lhs, "lhs")?, + rhs: Self::decode_some_msg(&binary_field_op.rhs, "rhs")?, + }), + Value::BinaryIntOp(binary_int_op) => Ok(brillig::Opcode::BinaryIntOp { + destination: Self::decode_some_msg(&binary_int_op.destination, "destination")?, + op: Self::decode_enum_msg(binary_int_op.op, "op")?, + bit_size: Self::decode_enum_msg(binary_int_op.bit_size, "bit_size")?, + lhs: Self::decode_some_msg(&binary_int_op.lhs, "lhs")?, + rhs: Self::decode_some_msg(&binary_int_op.rhs, "rhs")?, + }), + Value::Not(not) => Ok(brillig::Opcode::Not { + destination: Self::decode_some_msg(¬.destination, "destination")?, + source: Self::decode_some_msg(¬.source, "source")?, + bit_size: Self::decode_enum_msg(not.bit_size, "bit_size")?, + }), + Value::Cast(cast) => Ok(brillig::Opcode::Cast { + destination: Self::decode_some_msg(&cast.destination, "destination")?, + source: Self::decode_some_msg(&cast.source, "source")?, + bit_size: Self::decode_some_msg(&cast.bit_size, "bit_size")?, + }), + Value::JumpIfNot(jump_if_not) => Ok(brillig::Opcode::JumpIfNot { + condition: Self::decode_some_msg(&jump_if_not.condition, "condition")?, + location: Self::decode_msg(&jump_if_not.location, "location")?, + }), + Value::JumpIf(jump_if) => Ok(brillig::Opcode::JumpIf { + condition: Self::decode_some_msg(&jump_if.condition, "condition")?, + location: Self::decode_msg(&jump_if.location, "location")?, + }), + Value::Jump(jump) => Ok(brillig::Opcode::Jump { + location: Self::decode_msg(&jump.location, "location")?, + }), + Value::CalldataCopy(calldata_copy) => Ok(brillig::Opcode::CalldataCopy { + destination_address: Self::decode_some_msg( + &calldata_copy.destination_address, + "destination_address", + )?, + size_address: Self::decode_some_msg(&calldata_copy.size_address, "size_address")?, + offset_address: Self::decode_some_msg( + &calldata_copy.offset_address, + "offset_address", + )?, + }), + Value::Call(call) => Ok(brillig::Opcode::Call { + location: Self::decode_msg(&call.location, "location")?, + }), + Value::Const(constant) => Ok(brillig::Opcode::Const { + destination: Self::decode_some_msg(&constant.destination, "destination")?, + bit_size: Self::decode_some_msg(&constant.bit_size, "bit_size")?, + value: Self::decode_some_msg(&constant.value, "value")?, + }), + Value::IndirectConst(indirect_const) => Ok(brillig::Opcode::IndirectConst { + destination_pointer: Self::decode_some_msg( + &indirect_const.destination_pointer, + "destination_pointer", + )?, + bit_size: Self::decode_some_msg(&indirect_const.bit_size, "bit_size")?, + value: Self::decode_some_msg(&indirect_const.value, "value")?, + }), + Value::Return(_) => Ok(brillig::Opcode::Return), + Value::ForeignCall(foreign_call) => Ok(brillig::Opcode::ForeignCall { + function: foreign_call.function.clone(), + destinations: Self::decode_vec_msg(&foreign_call.destinations, "destinations")?, + destination_value_types: Self::decode_vec_msg( + &foreign_call.destination_value_types, + "destination_value_types", + )?, + inputs: Self::decode_vec_msg(&foreign_call.inputs, "inputs")?, + input_value_types: Self::decode_vec_msg( + &foreign_call.input_value_types, + "input_value_types", + )?, + }), + Value::Mov(mov) => Ok(brillig::Opcode::Mov { + destination: Self::decode_some_msg(&mov.destination, "destination")?, + source: Self::decode_some_msg(&mov.source, "source")?, + }), + Value::ConditionalMov(conditional_mov) => Ok(brillig::Opcode::ConditionalMov { + destination: Self::decode_some_msg(&conditional_mov.destination, "destination")?, + source_a: Self::decode_some_msg(&conditional_mov.source_a, "source_a")?, + source_b: Self::decode_some_msg(&conditional_mov.source_b, "source_b")?, + condition: Self::decode_some_msg(&conditional_mov.condition, "condition")?, + }), + Value::Load(load) => Ok(brillig::Opcode::Load { + destination: Self::decode_some_msg(&load.destination, "destination")?, + source_pointer: Self::decode_some_msg(&load.source_pointer, "source_pointer")?, + }), + Value::Store(store) => Ok(brillig::Opcode::Store { + destination_pointer: Self::decode_some_msg( + &store.destination_pointer, + "destination_pointer", + )?, + source: Self::decode_some_msg(&store.source, "source")?, + }), + Value::BlackBox(black_box) => { + Ok(brillig::Opcode::BlackBox(Self::decode_some_msg(&black_box.op, "black_box")?)) + } + Value::Trap(trap) => Ok(brillig::Opcode::Trap { + revert_data: Self::decode_some_msg(&trap.revert_data, "revert_data")?, + }), + Value::Stop(stop) => Ok(brillig::Opcode::Stop { + return_data: Self::decode_some_msg(&stop.return_data, "return_data")?, + }), + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::MemoryAddress) -> MemoryAddress { + use crate::proto::brillig::memory_address::*; + let value = match value { + brillig::MemoryAddress::Direct(addr) => Value::Direct(Self::encode(addr)), + brillig::MemoryAddress::Relative(addr) => Value::Relative(Self::encode(addr)), + }; + MemoryAddress { value: Some(value) } + } + + fn decode(value: &MemoryAddress) -> eyre::Result { + use crate::proto::brillig::memory_address::*; + decode_oneof_map(&value.value, |value| match value { + Value::Direct(v) => Self::decode_msg(v, "direct").map(brillig::MemoryAddress::Direct), + Value::Relative(v) => { + Self::decode_msg(v, "relative").map(brillig::MemoryAddress::Relative) + } + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::BinaryFieldOp) -> BinaryFieldOpKind { + match value { + brillig::BinaryFieldOp::Add => BinaryFieldOpKind::BfoAdd, + brillig::BinaryFieldOp::Sub => BinaryFieldOpKind::BfoSub, + brillig::BinaryFieldOp::Mul => BinaryFieldOpKind::BfoMul, + brillig::BinaryFieldOp::Div => BinaryFieldOpKind::BfoDiv, + brillig::BinaryFieldOp::IntegerDiv => BinaryFieldOpKind::BfoIntegerDiv, + brillig::BinaryFieldOp::Equals => BinaryFieldOpKind::BfoEquals, + brillig::BinaryFieldOp::LessThan => BinaryFieldOpKind::BfoLessThan, + brillig::BinaryFieldOp::LessThanEquals => BinaryFieldOpKind::BfoLessThanEquals, + } + } + + fn decode(value: &BinaryFieldOpKind) -> eyre::Result { + match value { + BinaryFieldOpKind::BfoUnspecified => bail!("unspecified BinaryFieldOp"), + BinaryFieldOpKind::BfoAdd => Ok(brillig::BinaryFieldOp::Add), + BinaryFieldOpKind::BfoSub => Ok(brillig::BinaryFieldOp::Sub), + BinaryFieldOpKind::BfoMul => Ok(brillig::BinaryFieldOp::Mul), + BinaryFieldOpKind::BfoDiv => Ok(brillig::BinaryFieldOp::Div), + BinaryFieldOpKind::BfoIntegerDiv => Ok(brillig::BinaryFieldOp::IntegerDiv), + BinaryFieldOpKind::BfoEquals => Ok(brillig::BinaryFieldOp::Equals), + BinaryFieldOpKind::BfoLessThan => Ok(brillig::BinaryFieldOp::LessThan), + BinaryFieldOpKind::BfoLessThanEquals => Ok(brillig::BinaryFieldOp::LessThanEquals), + } + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::BinaryIntOp) -> BinaryIntOpKind { + match value { + brillig::BinaryIntOp::Add => BinaryIntOpKind::BioAdd, + brillig::BinaryIntOp::Sub => BinaryIntOpKind::BioSub, + brillig::BinaryIntOp::Mul => BinaryIntOpKind::BioMul, + brillig::BinaryIntOp::Div => BinaryIntOpKind::BioDiv, + brillig::BinaryIntOp::Equals => BinaryIntOpKind::BioEquals, + brillig::BinaryIntOp::LessThan => BinaryIntOpKind::BioLessThan, + brillig::BinaryIntOp::LessThanEquals => BinaryIntOpKind::BioLessThanEquals, + brillig::BinaryIntOp::And => BinaryIntOpKind::BioAnd, + brillig::BinaryIntOp::Or => BinaryIntOpKind::BioOr, + brillig::BinaryIntOp::Xor => BinaryIntOpKind::BioXor, + brillig::BinaryIntOp::Shl => BinaryIntOpKind::BioShl, + brillig::BinaryIntOp::Shr => BinaryIntOpKind::BioShr, + } + } + + fn decode(value: &BinaryIntOpKind) -> eyre::Result { + match value { + BinaryIntOpKind::BioUnspecified => bail!("unspecified BinaryIntOp"), + BinaryIntOpKind::BioAdd => Ok(brillig::BinaryIntOp::Add), + BinaryIntOpKind::BioSub => Ok(brillig::BinaryIntOp::Sub), + BinaryIntOpKind::BioMul => Ok(brillig::BinaryIntOp::Mul), + BinaryIntOpKind::BioDiv => Ok(brillig::BinaryIntOp::Div), + BinaryIntOpKind::BioEquals => Ok(brillig::BinaryIntOp::Equals), + BinaryIntOpKind::BioLessThan => Ok(brillig::BinaryIntOp::LessThan), + BinaryIntOpKind::BioLessThanEquals => Ok(brillig::BinaryIntOp::LessThanEquals), + BinaryIntOpKind::BioAnd => Ok(brillig::BinaryIntOp::And), + BinaryIntOpKind::BioOr => Ok(brillig::BinaryIntOp::Or), + BinaryIntOpKind::BioXor => Ok(brillig::BinaryIntOp::Xor), + BinaryIntOpKind::BioShl => Ok(brillig::BinaryIntOp::Shl), + BinaryIntOpKind::BioShr => Ok(brillig::BinaryIntOp::Shr), + } + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::IntegerBitSize) -> IntegerBitSize { + match value { + brillig::IntegerBitSize::U1 => IntegerBitSize::IbsU1, + brillig::IntegerBitSize::U8 => IntegerBitSize::IbsU8, + brillig::IntegerBitSize::U16 => IntegerBitSize::IbsU16, + brillig::IntegerBitSize::U32 => IntegerBitSize::IbsU32, + brillig::IntegerBitSize::U64 => IntegerBitSize::IbsU64, + brillig::IntegerBitSize::U128 => IntegerBitSize::IbsU128, + } + } + + fn decode(value: &IntegerBitSize) -> eyre::Result { + match value { + IntegerBitSize::IbsUnspecified => bail!("unspecified IntegerBitSize"), + IntegerBitSize::IbsU1 => Ok(brillig::IntegerBitSize::U1), + IntegerBitSize::IbsU8 => Ok(brillig::IntegerBitSize::U8), + IntegerBitSize::IbsU16 => Ok(brillig::IntegerBitSize::U16), + IntegerBitSize::IbsU32 => Ok(brillig::IntegerBitSize::U32), + IntegerBitSize::IbsU64 => Ok(brillig::IntegerBitSize::U64), + IntegerBitSize::IbsU128 => Ok(brillig::IntegerBitSize::U128), + } + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::BitSize) -> BitSize { + use crate::proto::brillig::bit_size::*; + let value = match value { + brillig::BitSize::Field => Value::Field(Field {}), + brillig::BitSize::Integer(integer_bit_size) => { + Value::Integer(Self::encode_enum(integer_bit_size)) + } + }; + BitSize { value: Some(value) } + } + + fn decode(value: &BitSize) -> eyre::Result { + use crate::proto::brillig::bit_size::*; + decode_oneof_map(&value.value, |value| match value { + Value::Field(_) => Ok(brillig::BitSize::Field), + Value::Integer(size) => { + Ok(brillig::BitSize::Integer(Self::decode_enum_msg(*size, "size")?)) + } + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::ValueOrArray) -> ValueOrArray { + use crate::proto::brillig::value_or_array::*; + let value = match value { + brillig::ValueOrArray::MemoryAddress(memory_address) => { + Value::MemoryAddress(Self::encode(memory_address)) + } + brillig::ValueOrArray::HeapArray(heap_array) => { + Value::HeapArray(Self::encode(heap_array)) + } + brillig::ValueOrArray::HeapVector(heap_vector) => { + Value::HeapVector(Self::encode(heap_vector)) + } + }; + ValueOrArray { value: Some(value) } + } + + fn decode(value: &ValueOrArray) -> eyre::Result { + use crate::proto::brillig::value_or_array::*; + decode_oneof_map(&value.value, |value| match value { + Value::MemoryAddress(memory_address) => Ok(brillig::ValueOrArray::MemoryAddress( + Self::decode_msg(memory_address, "memory_address")?, + )), + Value::HeapArray(heap_array) => { + Ok(brillig::ValueOrArray::HeapArray(Self::decode_msg(heap_array, "heap_array")?)) + } + Value::HeapVector(heap_vector) => { + Ok(brillig::ValueOrArray::HeapVector(Self::decode_msg(heap_vector, "heap_vector")?)) + } + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::HeapValueType) -> HeapValueType { + use crate::proto::brillig::heap_value_type::*; + let value = match value { + brillig::HeapValueType::Simple(bit_size) => Value::Simple(Self::encode(bit_size)), + brillig::HeapValueType::Array { value_types, size } => Value::Array(Array { + value_types: Self::encode_vec(value_types), + size: *size as u64, + }), + brillig::HeapValueType::Vector { value_types } => { + Value::Vector(Vector { value_types: Self::encode_vec(value_types) }) + } + }; + HeapValueType { value: Some(value) } + } + + fn decode(value: &HeapValueType) -> eyre::Result { + use crate::proto::brillig::heap_value_type::*; + decode_oneof_map(&value.value, |value| match value { + Value::Simple(bit_size) => { + Ok(brillig::HeapValueType::Simple(Self::decode_msg(bit_size, "simple")?)) + } + Value::Array(array) => Ok(brillig::HeapValueType::Array { + value_types: Self::decode_vec_msg(&array.value_types, "value_types")?, + size: Self::decode_msg(&array.size, "size")?, + }), + Value::Vector(vector) => Ok(brillig::HeapValueType::Vector { + value_types: Self::decode_vec_msg(&vector.value_types, "value_types")?, + }), + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::HeapArray) -> HeapArray { + HeapArray { pointer: Self::encode_some(&value.pointer), size: Self::encode(&value.size) } + } + + fn decode(value: &HeapArray) -> eyre::Result { + Ok(brillig::HeapArray { + pointer: Self::decode_some_msg(&value.pointer, "pointer")?, + size: Self::decode_msg(&value.size, "size")?, + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::HeapVector) -> HeapVector { + HeapVector { + pointer: Self::encode_some(&value.pointer), + size: Self::encode_some(&value.size), + } + } + + fn decode(value: &HeapVector) -> eyre::Result { + Ok(brillig::HeapVector { + pointer: Self::decode_some_msg(&value.pointer, "pointer")?, + size: Self::decode_some_msg(&value.size, "size")?, + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &brillig::BlackBoxOp) -> BlackBoxOp { + use crate::proto::brillig::black_box_op::*; + let value = match value { + brillig::BlackBoxOp::AES128Encrypt { inputs, iv, key, outputs } => { + Value::Aes128Encrypt(Aes128Encrypt { + inputs: Self::encode_some(inputs), + iv: Self::encode_some(iv), + key: Self::encode_some(key), + outputs: Self::encode_some(outputs), + }) + } + brillig::BlackBoxOp::Blake2s { message, output } => Value::Blake2s(Blake2s { + message: Self::encode_some(message), + output: Self::encode_some(output), + }), + brillig::BlackBoxOp::Blake3 { message, output } => Value::Blake3(Blake3 { + message: Self::encode_some(message), + output: Self::encode_some(output), + }), + brillig::BlackBoxOp::Keccakf1600 { input, output } => Value::KeccakF1600(Keccakf1600 { + input: Self::encode_some(input), + output: Self::encode_some(output), + }), + brillig::BlackBoxOp::EcdsaSecp256k1 { + hashed_msg, + public_key_x, + public_key_y, + signature, + result, + } => Value::EcdsaSecp256k1(EcdsaSecp256k1 { + hashed_msg: Self::encode_some(hashed_msg), + public_key_x: Self::encode_some(public_key_x), + public_key_y: Self::encode_some(public_key_y), + signature: Self::encode_some(signature), + result: Self::encode_some(result), + }), + brillig::BlackBoxOp::EcdsaSecp256r1 { + hashed_msg, + public_key_x, + public_key_y, + signature, + result, + } => Value::EcdsaSecp256r1(EcdsaSecp256r1 { + hashed_msg: Self::encode_some(hashed_msg), + public_key_x: Self::encode_some(public_key_x), + public_key_y: Self::encode_some(public_key_y), + signature: Self::encode_some(signature), + result: Self::encode_some(result), + }), + brillig::BlackBoxOp::MultiScalarMul { points, scalars, outputs } => { + Value::MultiScalarMul(MultiScalarMul { + points: Self::encode_some(points), + scalars: Self::encode_some(scalars), + outputs: Self::encode_some(outputs), + }) + } + brillig::BlackBoxOp::EmbeddedCurveAdd { + input1_x, + input1_y, + input1_infinite, + input2_x, + input2_y, + input2_infinite, + result, + } => Value::EmbeddedCurveAdd(EmbeddedCurveAdd { + input1_x: Self::encode_some(input1_x), + input1_y: Self::encode_some(input1_y), + input1_infinite: Self::encode_some(input1_infinite), + input2_x: Self::encode_some(input2_x), + input2_y: Self::encode_some(input2_y), + input2_infinite: Self::encode_some(input2_infinite), + result: Self::encode_some(result), + }), + brillig::BlackBoxOp::BigIntAdd { lhs, rhs, output } => Value::BigIntAdd(BigIntAdd { + lhs: Self::encode_some(lhs), + rhs: Self::encode_some(rhs), + output: Self::encode_some(output), + }), + brillig::BlackBoxOp::BigIntSub { lhs, rhs, output } => Value::BigIntSub(BigIntSub { + lhs: Self::encode_some(lhs), + rhs: Self::encode_some(rhs), + output: Self::encode_some(output), + }), + brillig::BlackBoxOp::BigIntMul { lhs, rhs, output } => Value::BigIntMul(BigIntMul { + lhs: Self::encode_some(lhs), + rhs: Self::encode_some(rhs), + output: Self::encode_some(output), + }), + brillig::BlackBoxOp::BigIntDiv { lhs, rhs, output } => Value::BigIntDiv(BigIntDiv { + lhs: Self::encode_some(lhs), + rhs: Self::encode_some(rhs), + output: Self::encode_some(output), + }), + brillig::BlackBoxOp::BigIntFromLeBytes { inputs, modulus, output } => { + Value::BigIntFromLeBytes(BigIntFromLeBytes { + inputs: Self::encode_some(inputs), + modulus: Self::encode_some(modulus), + output: Self::encode_some(output), + }) + } + brillig::BlackBoxOp::BigIntToLeBytes { input, output } => { + Value::BigIntToLeBytes(BigIntToLeBytes { + input: Self::encode_some(input), + output: Self::encode_some(output), + }) + } + brillig::BlackBoxOp::Poseidon2Permutation { message, output, len } => { + Value::Poseidon2Permutation(Poseidon2Permutation { + message: Self::encode_some(message), + output: Self::encode_some(output), + len: Self::encode_some(len), + }) + } + brillig::BlackBoxOp::Sha256Compression { input, hash_values, output } => { + Value::Sha256Compression(Sha256Compression { + input: Self::encode_some(input), + hash_values: Self::encode_some(hash_values), + output: Self::encode_some(output), + }) + } + brillig::BlackBoxOp::ToRadix { + input, + radix, + output_pointer, + num_limbs, + output_bits, + } => Value::ToRadix(ToRadix { + input: Self::encode_some(input), + radix: Self::encode_some(radix), + output_pointer: Self::encode_some(output_pointer), + num_limbs: Self::encode_some(num_limbs), + output_bits: Self::encode_some(output_bits), + }), + }; + BlackBoxOp { value: Some(value) } + } + + fn decode(value: &BlackBoxOp) -> eyre::Result { + use crate::proto::brillig::black_box_op::*; + decode_oneof_map(&value.value, |value| match value { + Value::Aes128Encrypt(aes128_encrypt) => Ok(brillig::BlackBoxOp::AES128Encrypt { + inputs: Self::decode_some_msg(&aes128_encrypt.inputs, "inputs")?, + iv: Self::decode_some_msg(&aes128_encrypt.iv, "iv")?, + key: Self::decode_some_msg(&aes128_encrypt.key, "key")?, + outputs: Self::decode_some_msg(&aes128_encrypt.outputs, "outputs")?, + }), + Value::Blake2s(blake2s) => Ok(brillig::BlackBoxOp::Blake2s { + message: Self::decode_some_msg(&blake2s.message, "message")?, + output: Self::decode_some_msg(&blake2s.output, "output")?, + }), + Value::Blake3(blake3) => Ok(brillig::BlackBoxOp::Blake3 { + message: Self::decode_some_msg(&blake3.message, "message")?, + output: Self::decode_some_msg(&blake3.output, "output")?, + }), + Value::KeccakF1600(keccakf1600) => Ok(brillig::BlackBoxOp::Keccakf1600 { + input: Self::decode_some_msg(&keccakf1600.input, "input")?, + output: Self::decode_some_msg(&keccakf1600.output, "output")?, + }), + Value::EcdsaSecp256k1(ecdsa_secp256k1) => Ok(brillig::BlackBoxOp::EcdsaSecp256k1 { + hashed_msg: Self::decode_some_msg(&ecdsa_secp256k1.hashed_msg, "hashed_msg")?, + public_key_x: Self::decode_some_msg(&ecdsa_secp256k1.public_key_x, "public_key_x")?, + public_key_y: Self::decode_some_msg(&ecdsa_secp256k1.public_key_y, "public_key_y")?, + signature: Self::decode_some_msg(&ecdsa_secp256k1.signature, "signature")?, + result: Self::decode_some_msg(&ecdsa_secp256k1.result, "result")?, + }), + Value::EcdsaSecp256r1(ecdsa_secp256r1) => Ok(brillig::BlackBoxOp::EcdsaSecp256r1 { + hashed_msg: Self::decode_some_msg(&ecdsa_secp256r1.hashed_msg, "hashed_msg")?, + public_key_x: Self::decode_some_msg(&ecdsa_secp256r1.public_key_x, "public_key_x")?, + public_key_y: Self::decode_some_msg(&ecdsa_secp256r1.public_key_y, "public_key_y")?, + signature: Self::decode_some_msg(&ecdsa_secp256r1.signature, "signature")?, + result: Self::decode_some_msg(&ecdsa_secp256r1.result, "result")?, + }), + Value::MultiScalarMul(multi_scalar_mul) => Ok(brillig::BlackBoxOp::MultiScalarMul { + points: Self::decode_some_msg(&multi_scalar_mul.points, "points")?, + scalars: Self::decode_some_msg(&multi_scalar_mul.scalars, "scalars")?, + outputs: Self::decode_some_msg(&multi_scalar_mul.outputs, "outputs")?, + }), + Value::EmbeddedCurveAdd(embedded_curve_add) => { + Ok(brillig::BlackBoxOp::EmbeddedCurveAdd { + input1_x: Self::decode_some_msg(&embedded_curve_add.input1_x, "input1_x")?, + input1_y: Self::decode_some_msg(&embedded_curve_add.input1_y, "input1_y")?, + input1_infinite: Self::decode_some_msg( + &embedded_curve_add.input1_infinite, + "input1_infinite", + )?, + input2_x: Self::decode_some_msg(&embedded_curve_add.input2_x, "input2_x")?, + input2_y: Self::decode_some_msg(&embedded_curve_add.input2_y, "input2_y")?, + input2_infinite: Self::decode_some_msg( + &embedded_curve_add.input2_infinite, + "input2_infinite", + )?, + result: Self::decode_some_msg(&embedded_curve_add.result, "result")?, + }) + } + Value::BigIntAdd(big_int_add) => Ok(brillig::BlackBoxOp::BigIntAdd { + lhs: Self::decode_some_msg(&big_int_add.lhs, "lhs")?, + rhs: Self::decode_some_msg(&big_int_add.rhs, "rhs")?, + output: Self::decode_some_msg(&big_int_add.output, "output")?, + }), + Value::BigIntSub(big_int_sub) => Ok(brillig::BlackBoxOp::BigIntSub { + lhs: Self::decode_some_msg(&big_int_sub.lhs, "lhs")?, + rhs: Self::decode_some_msg(&big_int_sub.rhs, "rhs")?, + output: Self::decode_some_msg(&big_int_sub.output, "output")?, + }), + Value::BigIntMul(big_int_mul) => Ok(brillig::BlackBoxOp::BigIntMul { + lhs: Self::decode_some_msg(&big_int_mul.lhs, "lhs")?, + rhs: Self::decode_some_msg(&big_int_mul.rhs, "rhs")?, + output: Self::decode_some_msg(&big_int_mul.output, "output")?, + }), + Value::BigIntDiv(big_int_div) => Ok(brillig::BlackBoxOp::BigIntDiv { + lhs: Self::decode_some_msg(&big_int_div.lhs, "lhs")?, + rhs: Self::decode_some_msg(&big_int_div.rhs, "rhs")?, + output: Self::decode_some_msg(&big_int_div.output, "output")?, + }), + Value::BigIntFromLeBytes(big_int_from_le_bytes) => { + Ok(brillig::BlackBoxOp::BigIntFromLeBytes { + inputs: Self::decode_some_msg(&big_int_from_le_bytes.inputs, "inputs")?, + modulus: Self::decode_some_msg(&big_int_from_le_bytes.modulus, "modulus")?, + output: Self::decode_some_msg(&big_int_from_le_bytes.output, "output")?, + }) + } + Value::BigIntToLeBytes(big_int_to_le_bytes) => { + Ok(brillig::BlackBoxOp::BigIntToLeBytes { + input: Self::decode_some_msg(&big_int_to_le_bytes.input, "input")?, + output: Self::decode_some_msg(&big_int_to_le_bytes.output, "output")?, + }) + } + Value::Poseidon2Permutation(poseidon2_permutation) => { + Ok(brillig::BlackBoxOp::Poseidon2Permutation { + message: Self::decode_some_msg(&poseidon2_permutation.message, "message")?, + output: Self::decode_some_msg(&poseidon2_permutation.output, "output")?, + len: Self::decode_some_msg(&poseidon2_permutation.len, "len")?, + }) + } + Value::Sha256Compression(sha256_compression) => { + Ok(brillig::BlackBoxOp::Sha256Compression { + input: Self::decode_some_msg(&sha256_compression.input, "input")?, + hash_values: Self::decode_some_msg( + &sha256_compression.hash_values, + "hash_values", + )?, + output: Self::decode_some_msg(&sha256_compression.output, "output")?, + }) + } + Value::ToRadix(to_radix) => Ok(brillig::BlackBoxOp::ToRadix { + input: Self::decode_some_msg(&to_radix.input, "input")?, + radix: Self::decode_some_msg(&to_radix.radix, "radix")?, + output_pointer: Self::decode_some_msg(&to_radix.output_pointer, "output_pointer")?, + num_limbs: Self::decode_some_msg(&to_radix.num_limbs, "num_limbs")?, + output_bits: Self::decode_some_msg(&to_radix.output_bits, "output_bits")?, + }), + }) + } +} diff --git a/acvm-repo/acir/src/proto/convert/mod.rs b/acvm-repo/acir/src/proto/convert/mod.rs new file mode 100644 index 00000000000..2cae6cce18b --- /dev/null +++ b/acvm-repo/acir/src/proto/convert/mod.rs @@ -0,0 +1,48 @@ +use std::marker::PhantomData; + +use acir_field::AcirField; +use color_eyre::eyre::{self, Context}; +use noir_protobuf::ProtoCodec; + +use crate::circuit; +use crate::proto::program::Program; + +mod acir; +mod brillig; +mod native; + +pub(crate) struct ProtoSchema { + field: PhantomData, +} + +impl ProtoCodec, Program> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &circuit::Program) -> Program { + Program { + functions: Self::encode_vec(&value.functions), + unconstrained_functions: Self::encode_vec(&value.unconstrained_functions), + } + } + + fn decode(value: &Program) -> eyre::Result> { + Ok(circuit::Program { + functions: Self::decode_vec_msg(&value.functions, "functions")?, + unconstrained_functions: Self::decode_vec_msg( + &value.unconstrained_functions, + "unconstrained_functions", + )?, + }) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &usize) -> u64 { + *value as u64 + } + + fn decode(value: &u64) -> eyre::Result { + (*value).try_into().wrap_err("failed to convert u64 to usize") + } +} diff --git a/acvm-repo/acir/src/proto/convert/native.rs b/acvm-repo/acir/src/proto/convert/native.rs new file mode 100644 index 00000000000..d5439d3f98d --- /dev/null +++ b/acvm-repo/acir/src/proto/convert/native.rs @@ -0,0 +1,80 @@ +use acir_field::AcirField; +use color_eyre::eyre; +use noir_protobuf::{decode_vec_msg_map, ProtoCodec}; + +use crate::{ + native_types, + proto::acir::native::{Expression, Field, Witness}, +}; + +use super::ProtoSchema; + +impl ProtoCodec for ProtoSchema { + fn encode(value: &F) -> Field { + Field { value: value.to_le_bytes() } + } + + fn decode(value: &Field) -> eyre::Result { + Ok(F::from_le_bytes_reduce(&value.value)) + } +} + +impl ProtoCodec for ProtoSchema { + fn encode(value: &native_types::Witness) -> Witness { + Witness { index: value.0 } + } + + fn decode(value: &Witness) -> eyre::Result { + Ok(native_types::Witness(value.index)) + } +} + +impl ProtoCodec, Expression> for ProtoSchema +where + F: AcirField, +{ + fn encode(value: &native_types::Expression) -> Expression { + use crate::proto::acir::native::expression::*; + Expression { + mul_terms: value + .mul_terms + .iter() + .map(|(q_m, wl, wr)| MulTerm { + q_m: Self::encode_some(q_m), + witness_left: Self::encode_some(wl), + witness_right: Self::encode_some(wr), + }) + .collect(), + linear_combinations: value + .linear_combinations + .iter() + .map(|(q_l, w)| LinearCombination { + q_l: Self::encode_some(q_l), + witness: Self::encode_some(w), + }) + .collect(), + q_c: Self::encode_some(&value.q_c), + } + } + + fn decode(value: &Expression) -> eyre::Result> { + Ok(native_types::Expression { + mul_terms: decode_vec_msg_map(&value.mul_terms, "mul_terms", |mt| { + let q_m = Self::decode_some_msg(&mt.q_m, "q_m")?; + let wl = Self::decode_some_msg(&mt.witness_left, "witness_left")?; + let wr = Self::decode_some_msg(&mt.witness_right, "witness_right")?; + Ok((q_m, wl, wr)) + })?, + linear_combinations: decode_vec_msg_map( + &value.linear_combinations, + "linear_combinations", + |lc| { + let q_l = Self::decode_some_msg(&lc.q_l, "q_l")?; + let w = Self::decode_some_msg(&lc.witness, "witness")?; + Ok((q_l, w)) + }, + )?, + q_c: Self::decode_some_msg(&value.q_c, "q_c")?, + }) + } +} diff --git a/acvm-repo/acir/src/proto/mod.rs b/acvm-repo/acir/src/proto/mod.rs new file mode 100644 index 00000000000..ba5bbc5108c --- /dev/null +++ b/acvm-repo/acir/src/proto/mod.rs @@ -0,0 +1,29 @@ +pub(crate) mod convert; + +pub(crate) mod acir { + + #[allow(unreachable_pub)] + pub(crate) mod native { + include!(concat!(env!("OUT_DIR"), "/acvm.acir.native.rs")); + } + + #[allow(unreachable_pub)] + pub(crate) mod witness { + include!(concat!(env!("OUT_DIR"), "/acvm.acir.witness.rs")); + } + + #[allow(unreachable_pub)] + pub(crate) mod circuit { + include!(concat!(env!("OUT_DIR"), "/acvm.acir.circuit.rs")); + } +} + +#[allow(unreachable_pub, clippy::enum_variant_names)] +pub(crate) mod brillig { + include!(concat!(env!("OUT_DIR"), "/acvm.brillig.rs")); +} + +#[allow(unreachable_pub)] +pub(crate) mod program { + include!(concat!(env!("OUT_DIR"), "/acvm.program.rs")); +} diff --git a/acvm-repo/acir/src/proto/program.proto b/acvm-repo/acir/src/proto/program.proto new file mode 100644 index 00000000000..d54d0aff5a9 --- /dev/null +++ b/acvm-repo/acir/src/proto/program.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package acvm.program; + +import public "acir/circuit.proto"; +import public "brillig.proto"; + +// A program represents an entire circuit with ACIR and Brillig functions and +// potentially multiple endpoints. +message Program { + // ACIR circuits + repeated acvm.acir.circuit.Circuit functions = 1; + // Brillig functions + repeated acvm.brillig.BrilligBytecode unconstrained_functions = 2; +} diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs index 157ed9638ca..7d1fb3f67d3 100644 --- a/acvm-repo/brillig_vm/src/lib.rs +++ b/acvm-repo/brillig_vm/src/lib.rs @@ -1737,7 +1737,7 @@ mod tests { ) -> VM<'a, F, StubbedBlackBoxSolver> { let mut vm = VM::new(calldata, opcodes, solver, false); brillig_execute(&mut vm); - assert_eq!(vm.call_stack, vec![]); + assert!(vm.call_stack.is_empty()); vm } diff --git a/cspell.json b/cspell.json index 3bbbede78cc..31c81657144 100644 --- a/cspell.json +++ b/cspell.json @@ -173,6 +173,7 @@ "noncanonical", "nouner", "oneshot", + "oneof", "overflowing", "pedersen", "peekable", @@ -188,6 +189,11 @@ "printstd", "proptest", "proptests", + "prost", + "proto", + "protobuf", + "protoc", + "protos", "pseudocode", "pubkey", "quantile", diff --git a/scripts/bytecode-sizes/bincode-vs-cbor.jsonl b/scripts/bytecode-sizes/bincode-vs-cbor.jsonl new file mode 100644 index 00000000000..b11e1ae4679 --- /dev/null +++ b/scripts/bytecode-sizes/bincode-vs-cbor.jsonl @@ -0,0 +1,727 @@ +{"name":"parity_base","base_size":38512,"alt_size":39479,"ratio":1.0251090569173245} +{"name":"parity_root","base_size":56652,"alt_size":62457,"ratio":1.1024676975217116} +{"name":"private_kernel_init","base_size":220963,"alt_size":239509,"ratio":1.083932604101139} +{"name":"private_kernel_init_simulated","base_size":58910,"alt_size":62602,"ratio":1.062671872347649} +{"name":"private_kernel_inner","base_size":360037,"alt_size":386852,"ratio":1.074478456380872} +{"name":"private_kernel_inner_simulated","base_size":86003,"alt_size":92241,"ratio":1.0725323535225515} +{"name":"private_kernel_reset","base_size":900341,"alt_size":968420,"ratio":1.0756146837698162} +{"name":"private_kernel_reset_0_0_0_0_0_64_0_0_0","base_size":240204,"alt_size":258991,"ratio":1.0782126858836656} +{"name":"private_kernel_reset_0_0_0_0_64_0_0_0_0","base_size":196989,"alt_size":210412,"ratio":1.068140860657194} +{"name":"private_kernel_reset_0_0_0_64_0_0_0_0_0","base_size":381535,"alt_size":414154,"ratio":1.085494122426514} +{"name":"private_kernel_reset_0_0_64_0_0_0_0_0_0","base_size":168641,"alt_size":185042,"ratio":1.0972539299458612} +{"name":"private_kernel_reset_0_64_0_0_0_0_0_0_0","base_size":382112,"alt_size":415357,"ratio":1.087003286994389} +{"name":"private_kernel_reset_16_16_16_16_16_16_16_16_16","base_size":422691,"alt_size":461786,"ratio":1.0924907320004447} +{"name":"private_kernel_reset_32_16_32_16_4_4_4_4_32","base_size":419518,"alt_size":462320,"ratio":1.1020266114922364} +{"name":"private_kernel_reset_32_16_32_16_4_4_4_4_4","base_size":399588,"alt_size":438602,"ratio":1.0976355646315705} +{"name":"private_kernel_reset_32_16_32_16_4_4_4_64_32","base_size":436743,"alt_size":480119,"ratio":1.0993169896254777} +{"name":"private_kernel_reset_32_16_32_16_4_4_4_64_4","base_size":412103,"alt_size":456265,"ratio":1.1071625297559105} +{"name":"private_kernel_reset_32_16_32_16_4_4_64_4_32","base_size":443428,"alt_size":485632,"ratio":1.0951766690420992} +{"name":"private_kernel_reset_32_16_32_16_4_4_64_4_4","base_size":419832,"alt_size":460924,"ratio":1.0978772461365498} +{"name":"private_kernel_reset_32_16_32_16_4_4_64_64_32","base_size":462153,"alt_size":502304,"ratio":1.0868781550698579} +{"name":"private_kernel_reset_32_16_32_16_4_4_64_64_4","base_size":435584,"alt_size":479096,"ratio":1.099893476344402} +{"name":"private_kernel_reset_32_16_32_4_4_4_4_4_32","base_size":377138,"alt_size":416649,"ratio":1.1047653644024202} +{"name":"private_kernel_reset_32_16_32_4_4_4_4_4_4","base_size":356647,"alt_size":391838,"ratio":1.0986717959214574} +{"name":"private_kernel_reset_32_16_32_4_4_4_4_64_32","base_size":394400,"alt_size":433778,"ratio":1.099842799188641} +{"name":"private_kernel_reset_32_16_32_4_4_4_4_64_4","base_size":370694,"alt_size":408600,"ratio":1.1022568479662471} +{"name":"private_kernel_reset_32_16_32_4_4_4_64_4_32","base_size":401514,"alt_size":439832,"ratio":1.0954337831308498} +{"name":"private_kernel_reset_32_16_32_4_4_4_64_4_4","base_size":377562,"alt_size":414951,"ratio":1.0990274444991817} +{"name":"private_kernel_reset_32_16_32_4_4_4_64_64_32","base_size":419246,"alt_size":456344,"ratio":1.088487427429242} +{"name":"private_kernel_reset_32_16_32_4_4_4_64_64_4","base_size":394170,"alt_size":433137,"ratio":1.09885836060583} +{"name":"private_kernel_reset_32_32_32_32_32_32_32_32_32","base_size":591387,"alt_size":641384,"ratio":1.0845419327783667} +{"name":"private_kernel_reset_32_4_32_16_4_4_4_4_32","base_size":376447,"alt_size":415549,"ratio":1.1038711956796043} +{"name":"private_kernel_reset_32_4_32_16_4_4_4_4_4","base_size":355489,"alt_size":390665,"ratio":1.0989510223945045} +{"name":"private_kernel_reset_32_4_32_16_4_4_4_64_32","base_size":393764,"alt_size":432862,"ratio":1.0992929775195295} +{"name":"private_kernel_reset_32_4_32_16_4_4_4_64_4","base_size":368166,"alt_size":407637,"ratio":1.1072097912354752} +{"name":"private_kernel_reset_32_4_32_16_4_4_64_4_32","base_size":399898,"alt_size":438609,"ratio":1.0968021845570621} +{"name":"private_kernel_reset_32_4_32_16_4_4_64_4_4","base_size":376506,"alt_size":413777,"ratio":1.098991782335474} +{"name":"private_kernel_reset_32_4_32_16_4_4_64_64_32","base_size":417917,"alt_size":455588,"ratio":1.0901399081635827} +{"name":"private_kernel_reset_32_4_32_16_4_4_64_64_4","base_size":391965,"alt_size":431430,"ratio":1.1006850101412116} +{"name":"private_kernel_reset_32_4_32_4_4_4_4_4_32","base_size":334123,"alt_size":368930,"ratio":1.1041742112934458} +{"name":"private_kernel_reset_32_4_32_4_4_4_4_4_4","base_size":312145,"alt_size":344321,"ratio":1.1030802992199138} +{"name":"private_kernel_reset_32_4_32_4_4_4_4_64_32","base_size":350172,"alt_size":385798,"ratio":1.1017385741863999} +{"name":"private_kernel_reset_32_4_32_4_4_4_4_64_4","base_size":327715,"alt_size":360381,"ratio":1.0996780739361947} +{"name":"private_kernel_reset_32_4_32_4_4_4_64_4_32","base_size":357578,"alt_size":390717,"ratio":1.0926762832165289} +{"name":"private_kernel_reset_32_4_32_4_4_4_64_4_4","base_size":334218,"alt_size":366683,"ratio":1.097137197876835} +{"name":"private_kernel_reset_32_4_32_4_4_4_64_64_32","base_size":374014,"alt_size":407262,"ratio":1.088895068099055} +{"name":"private_kernel_reset_32_4_32_4_4_4_64_64_4","base_size":350157,"alt_size":383955,"ratio":1.0965224170871923} +{"name":"private_kernel_reset_4_4_4_4_4_4_4_4_4","base_size":294895,"alt_size":326075,"ratio":1.1057325488733278} +{"name":"private_kernel_reset_64_0_0_0_0_0_0_0_0","base_size":168449,"alt_size":184492,"ratio":1.095239508694026} +{"name":"private_kernel_reset_simulated","base_size":109155,"alt_size":121248,"ratio":1.1107874123952177} +{"name":"private_kernel_reset_simulated_0_0_0_0_0_64_0_0_0","base_size":46863,"alt_size":51433,"ratio":1.097518298017626} +{"name":"private_kernel_reset_simulated_0_0_0_0_64_0_0_0_0","base_size":46859,"alt_size":51624,"ratio":1.1016880428519602} +{"name":"private_kernel_reset_simulated_0_0_0_64_0_0_0_0_0","base_size":60920,"alt_size":68755,"ratio":1.1286112934996717} +{"name":"private_kernel_reset_simulated_0_0_64_0_0_0_0_0_0","base_size":45100,"alt_size":49624,"ratio":1.100310421286031} +{"name":"private_kernel_reset_simulated_0_64_0_0_0_0_0_0_0","base_size":57694,"alt_size":65082,"ratio":1.1280549103892952} +{"name":"private_kernel_reset_simulated_16_16_16_16_16_16_16_16_16","base_size":79966,"alt_size":85309,"ratio":1.0668158967561214} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_4_4_32","base_size":79780,"alt_size":85340,"ratio":1.0696916520431186} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_4_4_4","base_size":80015,"alt_size":85713,"ratio":1.0712116478160345} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_4_64_32","base_size":79643,"alt_size":85652,"ratio":1.0754491920193865} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_4_64_4","base_size":79770,"alt_size":85732,"ratio":1.074739877146797} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_64_4_32","base_size":79902,"alt_size":85689,"ratio":1.0724262221220995} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_64_4_4","base_size":79769,"alt_size":85832,"ratio":1.0760069701262396} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_64_64_32","base_size":79782,"alt_size":85887,"ratio":1.0765210197788975} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_64_64_4","base_size":79888,"alt_size":85543,"ratio":1.0707866012417384} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_4_4_32","base_size":77401,"alt_size":82571,"ratio":1.0667950026485447} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_4_4_4","base_size":77763,"alt_size":82773,"ratio":1.064426526754369} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_4_64_32","base_size":77385,"alt_size":82873,"ratio":1.0709181365897784} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_4_64_4","base_size":77396,"alt_size":82926,"ratio":1.071450720967492} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_64_4_32","base_size":77285,"alt_size":82598,"ratio":1.0687455521770073} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_64_4_4","base_size":77360,"alt_size":82998,"ratio":1.0728800413650466} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_64_64_32","base_size":77311,"alt_size":82666,"ratio":1.069265693109648} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_64_64_4","base_size":77343,"alt_size":82950,"ratio":1.0724952484387726} +{"name":"private_kernel_reset_simulated_32_32_32_32_32_32_32_32_32","base_size":87519,"alt_size":95105,"ratio":1.086678321278808} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_4_4_32","base_size":77673,"alt_size":83144,"ratio":1.0704363163518855} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_4_4_4","base_size":77871,"alt_size":83296,"ratio":1.0696664997239023} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_4_64_32","base_size":77677,"alt_size":83077,"ratio":1.0695186477335634} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_4_64_4","base_size":77784,"alt_size":83093,"ratio":1.0682531111796771} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_64_4_32","base_size":77650,"alt_size":83164,"ratio":1.0710109465550548} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_64_4_4","base_size":77781,"alt_size":83138,"ratio":1.0688728609814737} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_64_64_32","base_size":77727,"alt_size":83139,"ratio":1.069628314485314} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_64_64_4","base_size":77718,"alt_size":83171,"ratio":1.0701639259888314} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_4_4_32","base_size":74627,"alt_size":79191,"ratio":1.0611574899165181} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_4_4_4","base_size":74974,"alt_size":79576,"ratio":1.0613812788433323} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_4_64_32","base_size":74627,"alt_size":79332,"ratio":1.0630468865156042} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_4_64_4","base_size":74630,"alt_size":79488,"ratio":1.0650944660324266} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_64_4_32","base_size":74720,"alt_size":79342,"ratio":1.061857601713062} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_64_4_4","base_size":74671,"alt_size":79653,"ratio":1.0667193421810341} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_64_64_32","base_size":74628,"alt_size":79430,"ratio":1.0643458219435065} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_64_64_4","base_size":74857,"alt_size":79617,"ratio":1.0635879076105108} +{"name":"private_kernel_reset_simulated_4_4_4_4_4_4_4_4_4","base_size":74093,"alt_size":78231,"ratio":1.0558487306493192} +{"name":"private_kernel_reset_simulated_64_0_0_0_0_0_0_0_0","base_size":45171,"alt_size":49839,"ratio":1.1033406389054925} +{"name":"private_kernel_tail","base_size":119739,"alt_size":129136,"ratio":1.078479025213172} +{"name":"private_kernel_tail_simulated","base_size":47129,"alt_size":49102,"ratio":1.0418638205775637} +{"name":"private_kernel_tail_to_public","base_size":213723,"alt_size":225427,"ratio":1.054762472920556} +{"name":"private_kernel_tail_to_public_simulated","base_size":69150,"alt_size":71890,"ratio":1.0396240057845263} +{"name":"rollup_base_private","base_size":1395946,"alt_size":1478760,"ratio":1.0593246443630342} +{"name":"rollup_base_private_simulated","base_size":81316,"alt_size":84989,"ratio":1.045169462344434} +{"name":"rollup_base_public","base_size":679704,"alt_size":713364,"ratio":1.049521556442216} +{"name":"rollup_base_public_simulated","base_size":77006,"alt_size":83361,"ratio":1.0825260369321872} +{"name":"rollup_block_merge","base_size":106886,"alt_size":118996,"ratio":1.113298280410905} +{"name":"rollup_block_root","base_size":14975740,"alt_size":15306791,"ratio":1.0221058191448302} +{"name":"rollup_block_root_empty","base_size":20689,"alt_size":22707,"ratio":1.0975397554255886} +{"name":"rollup_block_root_simulated","base_size":82459,"alt_size":98188,"ratio":1.1907493420972848} +{"name":"rollup_block_root_single_tx","base_size":14959959,"alt_size":15285913,"ratio":1.0217884286982337} +{"name":"rollup_block_root_single_tx_simulated","base_size":76009,"alt_size":89185,"ratio":1.1733478930126695} +{"name":"rollup_merge","base_size":29269,"alt_size":32257,"ratio":1.102087532884622} +{"name":"rollup_root","base_size":106709,"alt_size":119467,"ratio":1.1195588001012098} +{"name":"amm_contract-AMM::_add_liquidity","base_size":7622,"alt_size":8803,"ratio":1.1549462083442665} +{"name":"amm_contract-AMM::_remove_liquidity","base_size":4902,"alt_size":5754,"ratio":1.1738066095471236} +{"name":"amm_contract-AMM::_swap_exact_tokens_for_tokens","base_size":3837,"alt_size":4578,"ratio":1.193119624706802} +{"name":"amm_contract-AMM::_swap_tokens_for_exact_tokens","base_size":4339,"alt_size":5023,"ratio":1.157640009218714} +{"name":"amm_contract-AMM::add_liquidity","base_size":32091,"alt_size":34383,"ratio":1.0714218939889688} +{"name":"amm_contract-AMM::constructor","base_size":3729,"alt_size":4273,"ratio":1.1458836149101637} +{"name":"amm_contract-AMM::get_amount_in_for_exact_out","base_size":18345,"alt_size":20354,"ratio":1.1095121286454075} +{"name":"amm_contract-AMM::get_amount_out_for_exact_in","base_size":18221,"alt_size":20433,"ratio":1.1213983864771417} +{"name":"amm_contract-AMM::process_log","base_size":15154,"alt_size":16635,"ratio":1.0977299722845453} +{"name":"amm_contract-AMM::public_dispatch","base_size":21009,"alt_size":22866,"ratio":1.0883906897044124} +{"name":"amm_contract-AMM::remove_liquidity","base_size":29866,"alt_size":32295,"ratio":1.0813299404004553} +{"name":"amm_contract-AMM::swap_exact_tokens_for_tokens","base_size":29805,"alt_size":32337,"ratio":1.084952189229995} +{"name":"amm_contract-AMM::swap_tokens_for_exact_tokens","base_size":29991,"alt_size":32459,"ratio":1.0822913540728885} +{"name":"amm_contract-AMM::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"app_subscription_contract-AppSubscription::constructor","base_size":4363,"alt_size":4993,"ratio":1.1443960577584231} +{"name":"app_subscription_contract-AppSubscription::entrypoint","base_size":99041,"alt_size":104762,"ratio":1.0577639563413133} +{"name":"app_subscription_contract-AppSubscription::is_initialized","base_size":24104,"alt_size":26472,"ratio":1.098240955857949} +{"name":"app_subscription_contract-AppSubscription::process_log","base_size":21895,"alt_size":23834,"ratio":1.088559031742407} +{"name":"app_subscription_contract-AppSubscription::public_dispatch","base_size":4869,"alt_size":5617,"ratio":1.1536249743273772} +{"name":"app_subscription_contract-AppSubscription::subscribe","base_size":95196,"alt_size":100422,"ratio":1.0548972645909491} +{"name":"app_subscription_contract-AppSubscription::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"auth_contract-Auth::constructor","base_size":2997,"alt_size":3560,"ratio":1.1878545211878546} +{"name":"auth_contract-Auth::do_private_authorized_thing","base_size":12949,"alt_size":13875,"ratio":1.071511313614951} +{"name":"auth_contract-Auth::get_authorized","base_size":836,"alt_size":1309,"ratio":1.5657894736842106} +{"name":"auth_contract-Auth::get_authorized_delay","base_size":663,"alt_size":1094,"ratio":1.650075414781297} +{"name":"auth_contract-Auth::get_authorized_in_private","base_size":13295,"alt_size":14181,"ratio":1.0666415945844303} +{"name":"auth_contract-Auth::get_scheduled_authorized","base_size":748,"alt_size":1210,"ratio":1.6176470588235294} +{"name":"auth_contract-Auth::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"auth_contract-Auth::public_dispatch","base_size":9866,"alt_size":11053,"ratio":1.1203121832556253} +{"name":"auth_contract-Auth::set_authorized","base_size":3466,"alt_size":4373,"ratio":1.2616849394114253} +{"name":"auth_contract-Auth::set_authorized_delay","base_size":3492,"alt_size":4322,"ratio":1.2376861397479955} +{"name":"auth_contract-Auth::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"auth_registry_contract-AuthRegistry::_set_authorized","base_size":1740,"alt_size":2296,"ratio":1.3195402298850574} +{"name":"auth_registry_contract-AuthRegistry::consume","base_size":3874,"alt_size":4515,"ratio":1.1654620547237997} +{"name":"auth_registry_contract-AuthRegistry::is_consumable","base_size":1730,"alt_size":2320,"ratio":1.3410404624277457} +{"name":"auth_registry_contract-AuthRegistry::is_reject_all","base_size":1143,"alt_size":1728,"ratio":1.5118110236220472} +{"name":"auth_registry_contract-AuthRegistry::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"auth_registry_contract-AuthRegistry::public_dispatch","base_size":7767,"alt_size":8674,"ratio":1.11677610402987} +{"name":"auth_registry_contract-AuthRegistry::set_authorized","base_size":1693,"alt_size":2252,"ratio":1.3301831069108092} +{"name":"auth_registry_contract-AuthRegistry::set_authorized_private","base_size":5800,"alt_size":6515,"ratio":1.1232758620689656} +{"name":"auth_registry_contract-AuthRegistry::set_reject_all","base_size":1113,"alt_size":1689,"ratio":1.517520215633423} +{"name":"auth_registry_contract-AuthRegistry::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"auth_registry_contract-AuthRegistry::unconstrained_is_consumable","base_size":1756,"alt_size":2337,"ratio":1.330865603644647} +{"name":"auth_wit_test_contract-AuthWitTest::consume","base_size":5464,"alt_size":6118,"ratio":1.119692532942899} +{"name":"auth_wit_test_contract-AuthWitTest::consume_public","base_size":749,"alt_size":1271,"ratio":1.6969292389853137} +{"name":"auth_wit_test_contract-AuthWitTest::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"auth_wit_test_contract-AuthWitTest::public_dispatch","base_size":1308,"alt_size":1853,"ratio":1.4166666666666667} +{"name":"auth_wit_test_contract-AuthWitTest::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_f1600","base_size":712,"alt_size":1137,"ratio":1.5969101123595506} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_hash","base_size":2062,"alt_size":2587,"ratio":1.254607177497575} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash","base_size":2820,"alt_size":3349,"ratio":1.1875886524822694} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash_with_index","base_size":2797,"alt_size":3323,"ratio":1.1880586342509831} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::poseidon2_hash","base_size":1636,"alt_size":2135,"ratio":1.3050122249388754} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::public_dispatch","base_size":39194,"alt_size":39823,"ratio":1.0160483747512374} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_10","base_size":2487,"alt_size":2993,"ratio":1.2034579815038198} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_100","base_size":3910,"alt_size":4308,"ratio":1.1017902813299232} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_20","base_size":2503,"alt_size":3020,"ratio":1.2065521374350778} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_2048","base_size":22473,"alt_size":27410,"ratio":1.219685845236506} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_255","base_size":5869,"alt_size":6264,"ratio":1.0673027773044812} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_256","base_size":5530,"alt_size":5951,"ratio":1.076130198915009} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_30","base_size":2708,"alt_size":3223,"ratio":1.1901772525849335} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_40","base_size":2761,"alt_size":3262,"ratio":1.1814559942049982} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_50","base_size":2905,"alt_size":3452,"ratio":1.1882960413080894} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_511","base_size":8590,"alt_size":9470,"ratio":1.1024447031431897} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_512","base_size":8154,"alt_size":9018,"ratio":1.1059602649006623} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_60","base_size":2998,"alt_size":3476,"ratio":1.1594396264176117} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_70","base_size":3715,"alt_size":4135,"ratio":1.1130551816958276} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_80","base_size":3610,"alt_size":4120,"ratio":1.1412742382271468} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_90","base_size":3825,"alt_size":4290,"ratio":1.1215686274509804} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"avm_initializer_test_contract-AvmInitializerTest::constructor","base_size":2520,"alt_size":3078,"ratio":1.2214285714285715} +{"name":"avm_initializer_test_contract-AvmInitializerTest::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"avm_initializer_test_contract-AvmInitializerTest::public_dispatch","base_size":3106,"alt_size":3725,"ratio":1.1992916934964584} +{"name":"avm_initializer_test_contract-AvmInitializerTest::read_storage_immutable","base_size":321,"alt_size":671,"ratio":2.0903426791277258} +{"name":"avm_initializer_test_contract-AvmInitializerTest::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"avm_test_contract-AvmTest::add_args_return","base_size":228,"alt_size":583,"ratio":2.557017543859649} +{"name":"avm_test_contract-AvmTest::add_storage_map","base_size":2300,"alt_size":2826,"ratio":1.228695652173913} +{"name":"avm_test_contract-AvmTest::add_u128","base_size":345,"alt_size":762,"ratio":2.208695652173913} +{"name":"avm_test_contract-AvmTest::assert_calldata_copy","base_size":615,"alt_size":1124,"ratio":1.8276422764227642} +{"name":"avm_test_contract-AvmTest::assert_nullifier_exists","base_size":286,"alt_size":667,"ratio":2.332167832167832} +{"name":"avm_test_contract-AvmTest::assert_same","base_size":254,"alt_size":617,"ratio":2.4291338582677167} +{"name":"avm_test_contract-AvmTest::assertion_failure","base_size":213,"alt_size":537,"ratio":2.5211267605633805} +{"name":"avm_test_contract-AvmTest::bulk_testing","base_size":18366,"alt_size":19541,"ratio":1.063976913862572} +{"name":"avm_test_contract-AvmTest::create_different_nullifier_in_nested_call","base_size":737,"alt_size":1239,"ratio":1.6811397557666214} +{"name":"avm_test_contract-AvmTest::create_same_nullifier_in_nested_call","base_size":706,"alt_size":1221,"ratio":1.7294617563739376} +{"name":"avm_test_contract-AvmTest::debug_logging","base_size":1075,"alt_size":1585,"ratio":1.4744186046511627} +{"name":"avm_test_contract-AvmTest::divide_by_zero","base_size":209,"alt_size":524,"ratio":2.507177033492823} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add","base_size":665,"alt_size":1214,"ratio":1.825563909774436} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add_and_double","base_size":323,"alt_size":644,"ratio":1.9938080495356036} +{"name":"avm_test_contract-AvmTest::emit_nullifier_and_check","base_size":310,"alt_size":683,"ratio":2.203225806451613} +{"name":"avm_test_contract-AvmTest::emit_public_log","base_size":2015,"alt_size":2538,"ratio":1.2595533498759306} +{"name":"avm_test_contract-AvmTest::enqueue_public_from_private","base_size":5008,"alt_size":5595,"ratio":1.1172124600638977} +{"name":"avm_test_contract-AvmTest::external_call_to_assertion_failure","base_size":663,"alt_size":1141,"ratio":1.7209653092006034} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero","base_size":673,"alt_size":1127,"ratio":1.674591381872214} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero_recovers","base_size":2193,"alt_size":2801,"ratio":1.2772457820337437} +{"name":"avm_test_contract-AvmTest::get_address","base_size":212,"alt_size":543,"ratio":2.561320754716981} +{"name":"avm_test_contract-AvmTest::get_args_hash","base_size":1810,"alt_size":2369,"ratio":1.3088397790055248} +{"name":"avm_test_contract-AvmTest::get_block_number","base_size":216,"alt_size":554,"ratio":2.564814814814815} +{"name":"avm_test_contract-AvmTest::get_chain_id","base_size":210,"alt_size":554,"ratio":2.638095238095238} +{"name":"avm_test_contract-AvmTest::get_da_gas_left","base_size":216,"alt_size":541,"ratio":2.5046296296296298} +{"name":"avm_test_contract-AvmTest::get_fee_per_da_gas","base_size":218,"alt_size":555,"ratio":2.5458715596330275} +{"name":"avm_test_contract-AvmTest::get_fee_per_l2_gas","base_size":216,"alt_size":554,"ratio":2.564814814814815} +{"name":"avm_test_contract-AvmTest::get_l2_gas_left","base_size":215,"alt_size":543,"ratio":2.525581395348837} +{"name":"avm_test_contract-AvmTest::get_sender","base_size":214,"alt_size":543,"ratio":2.5373831775700935} +{"name":"avm_test_contract-AvmTest::get_timestamp","base_size":220,"alt_size":556,"ratio":2.5272727272727273} +{"name":"avm_test_contract-AvmTest::get_transaction_fee","base_size":219,"alt_size":565,"ratio":2.5799086757990866} +{"name":"avm_test_contract-AvmTest::get_version","base_size":216,"alt_size":553,"ratio":2.560185185185185} +{"name":"avm_test_contract-AvmTest::helper_with_failed_assertion","base_size":111,"alt_size":263,"ratio":2.369369369369369} +{"name":"avm_test_contract-AvmTest::inner_helper_with_failed_assertion","base_size":111,"alt_size":263,"ratio":2.369369369369369} +{"name":"avm_test_contract-AvmTest::l1_to_l2_msg_exists","base_size":266,"alt_size":637,"ratio":2.3947368421052633} +{"name":"avm_test_contract-AvmTest::modulo2","base_size":216,"alt_size":574,"ratio":2.6574074074074074} +{"name":"avm_test_contract-AvmTest::n_new_l2_to_l1_msgs","base_size":279,"alt_size":671,"ratio":2.4050179211469533} +{"name":"avm_test_contract-AvmTest::n_new_note_hashes","base_size":280,"alt_size":679,"ratio":2.425} +{"name":"avm_test_contract-AvmTest::n_new_nullifiers","base_size":279,"alt_size":667,"ratio":2.390681003584229} +{"name":"avm_test_contract-AvmTest::n_new_public_logs","base_size":386,"alt_size":826,"ratio":2.139896373056995} +{"name":"avm_test_contract-AvmTest::n_storage_writes","base_size":1174,"alt_size":1756,"ratio":1.495741056218058} +{"name":"avm_test_contract-AvmTest::nested_call_to_add","base_size":761,"alt_size":1244,"ratio":1.6346911957950065} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_n_times_different_addresses","base_size":1092,"alt_size":1606,"ratio":1.4706959706959708} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_with_gas","base_size":713,"alt_size":1213,"ratio":1.7012622720897617} +{"name":"avm_test_contract-AvmTest::nested_call_to_assert_same","base_size":765,"alt_size":1255,"ratio":1.6405228758169934} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing","base_size":667,"alt_size":1129,"ratio":1.6926536731634183} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing_recovers","base_size":414,"alt_size":857,"ratio":2.070048309178744} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_add","base_size":753,"alt_size":1256,"ratio":1.6679946879150067} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_set_storage","base_size":698,"alt_size":1167,"ratio":1.671919770773639} +{"name":"avm_test_contract-AvmTest::new_note_hash","base_size":224,"alt_size":580,"ratio":2.5892857142857144} +{"name":"avm_test_contract-AvmTest::new_nullifier","base_size":216,"alt_size":590,"ratio":2.7314814814814814} +{"name":"avm_test_contract-AvmTest::note_hash_exists","base_size":266,"alt_size":637,"ratio":2.3947368421052633} +{"name":"avm_test_contract-AvmTest::nullifier_collision","base_size":230,"alt_size":590,"ratio":2.5652173913043477} +{"name":"avm_test_contract-AvmTest::nullifier_exists","base_size":265,"alt_size":635,"ratio":2.3962264150943398} +{"name":"avm_test_contract-AvmTest::pedersen_commit","base_size":1168,"alt_size":1722,"ratio":1.4743150684931507} +{"name":"avm_test_contract-AvmTest::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"avm_test_contract-AvmTest::public_dispatch","base_size":39990,"alt_size":42155,"ratio":1.0541385346336585} +{"name":"avm_test_contract-AvmTest::read_assert_storage_single","base_size":266,"alt_size":658,"ratio":2.473684210526316} +{"name":"avm_test_contract-AvmTest::read_storage_list","base_size":392,"alt_size":791,"ratio":2.017857142857143} +{"name":"avm_test_contract-AvmTest::read_storage_map","base_size":1110,"alt_size":1675,"ratio":1.509009009009009} +{"name":"avm_test_contract-AvmTest::read_storage_single","base_size":231,"alt_size":587,"ratio":2.5411255411255413} +{"name":"avm_test_contract-AvmTest::return_oracle","base_size":510,"alt_size":941,"ratio":1.8450980392156864} +{"name":"avm_test_contract-AvmTest::returndata_copy_oracle","base_size":1359,"alt_size":1851,"ratio":1.3620309050772628} +{"name":"avm_test_contract-AvmTest::revert_oracle","base_size":496,"alt_size":940,"ratio":1.8951612903225807} +{"name":"avm_test_contract-AvmTest::send_l2_to_l1_msg","base_size":244,"alt_size":608,"ratio":2.4918032786885247} +{"name":"avm_test_contract-AvmTest::set_opcode_big_field","base_size":214,"alt_size":539,"ratio":2.5186915887850465} +{"name":"avm_test_contract-AvmTest::set_opcode_really_big_field","base_size":211,"alt_size":532,"ratio":2.5213270142180093} +{"name":"avm_test_contract-AvmTest::set_opcode_small_field","base_size":211,"alt_size":539,"ratio":2.5545023696682465} +{"name":"avm_test_contract-AvmTest::set_opcode_u32","base_size":196,"alt_size":508,"ratio":2.5918367346938775} +{"name":"avm_test_contract-AvmTest::set_opcode_u64","base_size":195,"alt_size":502,"ratio":2.5743589743589745} +{"name":"avm_test_contract-AvmTest::set_opcode_u8","base_size":187,"alt_size":506,"ratio":2.7058823529411766} +{"name":"avm_test_contract-AvmTest::set_read_storage_single","base_size":262,"alt_size":640,"ratio":2.4427480916030535} +{"name":"avm_test_contract-AvmTest::set_storage_list","base_size":264,"alt_size":630,"ratio":2.3863636363636362} +{"name":"avm_test_contract-AvmTest::set_storage_map","base_size":1677,"alt_size":2204,"ratio":1.3142516398330353} +{"name":"avm_test_contract-AvmTest::set_storage_single","base_size":230,"alt_size":607,"ratio":2.639130434782609} +{"name":"avm_test_contract-AvmTest::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance","base_size":540,"alt_size":960,"ratio":1.7777777777777777} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance_matches","base_size":564,"alt_size":988,"ratio":1.75177304964539} +{"name":"avm_test_contract-AvmTest::to_radix_le","base_size":472,"alt_size":909,"ratio":1.9258474576271187} +{"name":"avm_test_contract-AvmTest::u128_addition_overflow","base_size":1031,"alt_size":1567,"ratio":1.5198836081474296} +{"name":"avm_test_contract-AvmTest::u128_from_integer_overflow","base_size":606,"alt_size":1080,"ratio":1.7821782178217822} +{"name":"avm_test_contract-AvmTest::variable_base_msm","base_size":571,"alt_size":1017,"ratio":1.7810858143607706} +{"name":"benchmarking_contract-Benchmarking::broadcast","base_size":1192,"alt_size":1785,"ratio":1.4974832214765101} +{"name":"benchmarking_contract-Benchmarking::create_note","base_size":70451,"alt_size":74329,"ratio":1.0550453506692594} +{"name":"benchmarking_contract-Benchmarking::increment_balance","base_size":2177,"alt_size":2790,"ratio":1.281580156178227} +{"name":"benchmarking_contract-Benchmarking::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"benchmarking_contract-Benchmarking::public_dispatch","base_size":6092,"alt_size":6847,"ratio":1.1239330269205516} +{"name":"benchmarking_contract-Benchmarking::recreate_note","base_size":89161,"alt_size":93443,"ratio":1.0480254819932482} +{"name":"benchmarking_contract-Benchmarking::sha256_hash_2048","base_size":22473,"alt_size":27410,"ratio":1.219685845236506} +{"name":"benchmarking_contract-Benchmarking::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"card_game_contract-CardGame::buy_pack","base_size":120555,"alt_size":126226,"ratio":1.0470407697731325} +{"name":"card_game_contract-CardGame::claim_cards","base_size":149790,"alt_size":155529,"ratio":1.0383136390947327} +{"name":"card_game_contract-CardGame::join_game","base_size":329284,"alt_size":349588,"ratio":1.0616610585391333} +{"name":"card_game_contract-CardGame::on_card_played","base_size":3651,"alt_size":4485,"ratio":1.228430566967954} +{"name":"card_game_contract-CardGame::on_cards_claimed","base_size":4786,"alt_size":5671,"ratio":1.1849143334726284} +{"name":"card_game_contract-CardGame::on_game_joined","base_size":2716,"alt_size":3468,"ratio":1.2768777614138438} +{"name":"card_game_contract-CardGame::play_card","base_size":240993,"alt_size":259154,"ratio":1.0753590353246776} +{"name":"card_game_contract-CardGame::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"card_game_contract-CardGame::public_dispatch","base_size":13560,"alt_size":15608,"ratio":1.1510324483775811} +{"name":"card_game_contract-CardGame::start_game","base_size":3907,"alt_size":4620,"ratio":1.1824929613514206} +{"name":"card_game_contract-CardGame::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"card_game_contract-CardGame::view_collection_cards","base_size":19406,"alt_size":21284,"ratio":1.096774193548387} +{"name":"card_game_contract-CardGame::view_game","base_size":18112,"alt_size":19837,"ratio":1.0952407243816253} +{"name":"card_game_contract-CardGame::view_game_cards","base_size":19932,"alt_size":21882,"ratio":1.0978326309452138} +{"name":"child_contract-Child::private_get_value","base_size":44885,"alt_size":47626,"ratio":1.0610671716609112} +{"name":"child_contract-Child::private_set_value","base_size":70713,"alt_size":74751,"ratio":1.0571040685588222} +{"name":"child_contract-Child::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"child_contract-Child::pub_get_value","base_size":304,"alt_size":696,"ratio":2.289473684210526} +{"name":"child_contract-Child::pub_inc_value","base_size":398,"alt_size":840,"ratio":2.1105527638190953} +{"name":"child_contract-Child::pub_inc_value_internal","base_size":457,"alt_size":909,"ratio":1.9890590809628008} +{"name":"child_contract-Child::pub_set_value","base_size":381,"alt_size":809,"ratio":2.1233595800524934} +{"name":"child_contract-Child::public_dispatch","base_size":2811,"alt_size":3352,"ratio":1.192458199928851} +{"name":"child_contract-Child::set_value_twice_with_nested_first","base_size":838,"alt_size":1283,"ratio":1.5310262529832936} +{"name":"child_contract-Child::set_value_twice_with_nested_last","base_size":847,"alt_size":1284,"ratio":1.5159386068476977} +{"name":"child_contract-Child::set_value_with_two_nested_calls","base_size":1091,"alt_size":1561,"ratio":1.4307974335472045} +{"name":"child_contract-Child::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"child_contract-Child::value","base_size":21817,"alt_size":23425,"ratio":1.0737039922995828} +{"name":"child_contract-Child::value_internal","base_size":21771,"alt_size":23524,"ratio":1.0805199577419502} +{"name":"claim_contract-Claim::claim","base_size":40666,"alt_size":43497,"ratio":1.0696158953425465} +{"name":"claim_contract-Claim::constructor","base_size":3712,"alt_size":4408,"ratio":1.1875} +{"name":"claim_contract-Claim::process_log","base_size":15154,"alt_size":16635,"ratio":1.0977299722845453} +{"name":"claim_contract-Claim::public_dispatch","base_size":4175,"alt_size":4817,"ratio":1.1537724550898203} +{"name":"claim_contract-Claim::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::assert_class_id_is_registered","base_size":4047,"alt_size":4414,"ratio":1.0906844576229306} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_private_function","base_size":20389,"alt_size":22511,"ratio":1.1040757271077541} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_unconstrained_function","base_size":20346,"alt_size":22401,"ratio":1.101002654084341} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::register","base_size":221551,"alt_size":230787,"ratio":1.0416879183573986} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::deploy","base_size":7653,"alt_size":8583,"ratio":1.1215209721677772} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::get_update_delay","base_size":1447,"alt_size":2033,"ratio":1.404975812024879} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::public_dispatch","base_size":8624,"alt_size":9804,"ratio":1.1368274582560296} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::set_update_delay","base_size":4093,"alt_size":5087,"ratio":1.2428536525775715} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::update","base_size":4274,"alt_size":5329,"ratio":1.2468413664014975} +{"name":"counter_contract-Counter::decrement","base_size":236216,"alt_size":254480,"ratio":1.07731906390761} +{"name":"counter_contract-Counter::get_counter","base_size":19173,"alt_size":21075,"ratio":1.0992020028164606} +{"name":"counter_contract-Counter::increment","base_size":67041,"alt_size":70337,"ratio":1.0491639444519025} +{"name":"counter_contract-Counter::increment_and_decrement","base_size":252067,"alt_size":270638,"ratio":1.073674856288209} +{"name":"counter_contract-Counter::increment_twice","base_size":82288,"alt_size":86317,"ratio":1.0489621816060666} +{"name":"counter_contract-Counter::initialize","base_size":72005,"alt_size":76021,"ratio":1.055773904589959} +{"name":"counter_contract-Counter::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"counter_contract-Counter::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"crowdfunding_contract-Crowdfunding::_publish_donation_receipts","base_size":532,"alt_size":973,"ratio":1.8289473684210527} +{"name":"crowdfunding_contract-Crowdfunding::donate","base_size":73181,"alt_size":77345,"ratio":1.056900015031224} +{"name":"crowdfunding_contract-Crowdfunding::init","base_size":3744,"alt_size":4312,"ratio":1.1517094017094016} +{"name":"crowdfunding_contract-Crowdfunding::process_log","base_size":15154,"alt_size":16635,"ratio":1.0977299722845453} +{"name":"crowdfunding_contract-Crowdfunding::public_dispatch","base_size":4598,"alt_size":5255,"ratio":1.1428882122662027} +{"name":"crowdfunding_contract-Crowdfunding::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"crowdfunding_contract-Crowdfunding::withdraw","base_size":29044,"alt_size":31332,"ratio":1.0787770279575817} +{"name":"docs_example_contract-DocsExample::get_imm_card","base_size":23407,"alt_size":25226,"ratio":1.077711795616696} +{"name":"docs_example_contract-DocsExample::get_leader","base_size":16639,"alt_size":18185,"ratio":1.0929142376344732} +{"name":"docs_example_contract-DocsExample::get_legendary_card","base_size":18333,"alt_size":19987,"ratio":1.090219822178585} +{"name":"docs_example_contract-DocsExample::get_public_immutable","base_size":16569,"alt_size":18192,"ratio":1.097954010501539} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private","base_size":28627,"alt_size":30684,"ratio":1.0718552415551752} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private_indirect","base_size":22606,"alt_size":24417,"ratio":1.0801114748296912} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public","base_size":345,"alt_size":723,"ratio":2.0956521739130434} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_indirect","base_size":782,"alt_size":1271,"ratio":1.6253196930946292} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_multiple","base_size":425,"alt_size":842,"ratio":1.9811764705882353} +{"name":"docs_example_contract-DocsExample::increase_legendary_points","base_size":73860,"alt_size":78409,"ratio":1.0615894936366097} +{"name":"docs_example_contract-DocsExample::initialize_private","base_size":66697,"alt_size":70326,"ratio":1.0544102433392806} +{"name":"docs_example_contract-DocsExample::initialize_private_immutable","base_size":66776,"alt_size":70239,"ratio":1.0518599496825207} +{"name":"docs_example_contract-DocsExample::initialize_public_immutable","base_size":1238,"alt_size":1824,"ratio":1.4733441033925687} +{"name":"docs_example_contract-DocsExample::insert_note","base_size":66357,"alt_size":69930,"ratio":1.0538451105384512} +{"name":"docs_example_contract-DocsExample::insert_notes","base_size":93157,"alt_size":98188,"ratio":1.054005603443649} +{"name":"docs_example_contract-DocsExample::is_legendary_initialized","base_size":17171,"alt_size":18665,"ratio":1.087007163240347} +{"name":"docs_example_contract-DocsExample::is_priv_imm_initialized","base_size":17089,"alt_size":18679,"ratio":1.0930423079173737} +{"name":"docs_example_contract-DocsExample::match_public_immutable","base_size":28473,"alt_size":30504,"ratio":1.071330734379939} +{"name":"docs_example_contract-DocsExample::process_log","base_size":15386,"alt_size":16729,"ratio":1.0872871441570258} +{"name":"docs_example_contract-DocsExample::public_dispatch","base_size":3390,"alt_size":4145,"ratio":1.2227138643067847} +{"name":"docs_example_contract-DocsExample::read_note","base_size":18509,"alt_size":20277,"ratio":1.095521097844292} +{"name":"docs_example_contract-DocsExample::simple_macro_example","base_size":21701,"alt_size":23456,"ratio":1.080871849223538} +{"name":"docs_example_contract-DocsExample::simple_macro_example_expanded","base_size":4637,"alt_size":5189,"ratio":1.1190424843648912} +{"name":"docs_example_contract-DocsExample::spend_public_authwit","base_size":197,"alt_size":548,"ratio":2.781725888324873} +{"name":"docs_example_contract-DocsExample::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"docs_example_contract-DocsExample::update_leader","base_size":347,"alt_size":763,"ratio":2.1988472622478388} +{"name":"docs_example_contract-DocsExample::update_legendary_card","base_size":70434,"alt_size":74145,"ratio":1.0526876224550643} +{"name":"docs_example_contract-DocsExample::verify_private_authwit","base_size":21772,"alt_size":23518,"ratio":1.0801947455447363} +{"name":"docs_example_contract-DocsExample::view_imm_card","base_size":18266,"alt_size":19923,"ratio":1.0907149895981605} +{"name":"easy_private_token_contract-EasyPrivateToken::constructor","base_size":72005,"alt_size":76021,"ratio":1.055773904589959} +{"name":"easy_private_token_contract-EasyPrivateToken::get_balance","base_size":19173,"alt_size":21075,"ratio":1.0992020028164606} +{"name":"easy_private_token_contract-EasyPrivateToken::mint","base_size":70565,"alt_size":74268,"ratio":1.0524764401615532} +{"name":"easy_private_token_contract-EasyPrivateToken::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"easy_private_token_contract-EasyPrivateToken::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"easy_private_token_contract-EasyPrivateToken::transfer","base_size":276344,"alt_size":294981,"ratio":1.067441305040095} +{"name":"easy_private_voting_contract-EasyPrivateVoting::add_to_tally_public","base_size":1886,"alt_size":2406,"ratio":1.2757158006362672} +{"name":"easy_private_voting_contract-EasyPrivateVoting::cast_vote","base_size":7884,"alt_size":8727,"ratio":1.106925418569254} +{"name":"easy_private_voting_contract-EasyPrivateVoting::constructor","base_size":3014,"alt_size":3559,"ratio":1.1808228268082284} +{"name":"easy_private_voting_contract-EasyPrivateVoting::end_vote","base_size":380,"alt_size":739,"ratio":1.944736842105263} +{"name":"easy_private_voting_contract-EasyPrivateVoting::get_vote","base_size":1245,"alt_size":1809,"ratio":1.453012048192771} +{"name":"easy_private_voting_contract-EasyPrivateVoting::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"easy_private_voting_contract-EasyPrivateVoting::public_dispatch","base_size":4864,"alt_size":5517,"ratio":1.134251644736842} +{"name":"easy_private_voting_contract-EasyPrivateVoting::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::constructor","base_size":76618,"alt_size":80420,"ratio":1.049622804040826} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::entrypoint","base_size":67820,"alt_size":74347,"ratio":1.0962400471837217} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::process_log","base_size":17042,"alt_size":18391,"ratio":1.079157375894848} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::verify_private_authwit","base_size":41611,"alt_size":44192,"ratio":1.0620268678955085} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::constructor","base_size":76618,"alt_size":80420,"ratio":1.049622804040826} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::entrypoint","base_size":67801,"alt_size":74282,"ratio":1.0955885606406985} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::process_log","base_size":17042,"alt_size":18391,"ratio":1.079157375894848} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::verify_private_authwit","base_size":41563,"alt_size":44297,"ratio":1.0657796597935665} +{"name":"escrow_contract-Escrow::constructor","base_size":70605,"alt_size":74545,"ratio":1.0558034133559946} +{"name":"escrow_contract-Escrow::process_log","base_size":22078,"alt_size":23808,"ratio":1.0783585469698342} +{"name":"escrow_contract-Escrow::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"escrow_contract-Escrow::withdraw","base_size":30481,"alt_size":33106,"ratio":1.086119221810308} +{"name":"fee_juice_contract-FeeJuice::_increase_public_balance","base_size":1956,"alt_size":2563,"ratio":1.3103271983640081} +{"name":"fee_juice_contract-FeeJuice::balance_of_public","base_size":1239,"alt_size":1823,"ratio":1.4713478611783697} +{"name":"fee_juice_contract-FeeJuice::check_balance","base_size":1475,"alt_size":2085,"ratio":1.4135593220338982} +{"name":"fee_juice_contract-FeeJuice::claim","base_size":73078,"alt_size":76197,"ratio":1.0426804236569145} +{"name":"fee_juice_contract-FeeJuice::initialize","base_size":5884,"alt_size":6540,"ratio":1.1114887831407205} +{"name":"fee_juice_contract-FeeJuice::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"fee_juice_contract-FeeJuice::public_dispatch","base_size":4499,"alt_size":5371,"ratio":1.1938208490775728} +{"name":"fee_juice_contract-FeeJuice::set_portal","base_size":1144,"alt_size":1737,"ratio":1.5183566433566433} +{"name":"fee_juice_contract-FeeJuice::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"fpc_contract-FPC::complete_refund","base_size":1253,"alt_size":1837,"ratio":1.4660814046288906} +{"name":"fpc_contract-FPC::constructor","base_size":3483,"alt_size":4102,"ratio":1.1777203560149296} +{"name":"fpc_contract-FPC::fee_entrypoint_private","base_size":29899,"alt_size":32384,"ratio":1.0831131475969096} +{"name":"fpc_contract-FPC::fee_entrypoint_public","base_size":29523,"alt_size":31857,"ratio":1.0790570064017884} +{"name":"fpc_contract-FPC::get_accepted_asset","base_size":28403,"alt_size":30603,"ratio":1.0774566066964757} +{"name":"fpc_contract-FPC::pay_refund","base_size":1258,"alt_size":1838,"ratio":1.4610492845786964} +{"name":"fpc_contract-FPC::process_log","base_size":15154,"alt_size":16635,"ratio":1.0977299722845453} +{"name":"fpc_contract-FPC::public_dispatch","base_size":6737,"alt_size":7470,"ratio":1.1088021374499035} +{"name":"fpc_contract-FPC::pull_funds","base_size":1258,"alt_size":1813,"ratio":1.4411764705882353} +{"name":"fpc_contract-FPC::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"import_test_contract-ImportTest::call_no_args","base_size":29858,"alt_size":32298,"ratio":1.0817201420054927} +{"name":"import_test_contract-ImportTest::call_public_fn","base_size":29440,"alt_size":31949,"ratio":1.0852241847826087} +{"name":"import_test_contract-ImportTest::main_contract","base_size":29988,"alt_size":32495,"ratio":1.0836001067093504} +{"name":"import_test_contract-ImportTest::process_log","base_size":22935,"alt_size":24708,"ratio":1.0773054283845651} +{"name":"import_test_contract-ImportTest::pub_call_public_fn","base_size":676,"alt_size":1179,"ratio":1.7440828402366864} +{"name":"import_test_contract-ImportTest::public_dispatch","base_size":1188,"alt_size":1749,"ratio":1.4722222222222223} +{"name":"import_test_contract-ImportTest::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"inclusion_proofs_contract-InclusionProofs::constructor","base_size":2437,"alt_size":3070,"ratio":1.259745588838736} +{"name":"inclusion_proofs_contract-InclusionProofs::create_note","base_size":70570,"alt_size":74443,"ratio":1.0548816777667565} +{"name":"inclusion_proofs_contract-InclusionProofs::nullify_note","base_size":40457,"alt_size":43239,"ratio":1.068764367105816} +{"name":"inclusion_proofs_contract-InclusionProofs::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"inclusion_proofs_contract-InclusionProofs::public_dispatch","base_size":3234,"alt_size":3823,"ratio":1.1821273964131107} +{"name":"inclusion_proofs_contract-InclusionProofs::push_nullifier_public","base_size":309,"alt_size":692,"ratio":2.2394822006472492} +{"name":"inclusion_proofs_contract-InclusionProofs::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_inclusion","base_size":34797,"alt_size":37382,"ratio":1.0742880133344828} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_non_inclusion","base_size":38583,"alt_size":41252,"ratio":1.0691755436332064} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion","base_size":46853,"alt_size":49813,"ratio":1.0631763174183084} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion_fail_case","base_size":31242,"alt_size":33516,"ratio":1.0727866333781448} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_not_nullified","base_size":51610,"alt_size":54684,"ratio":1.0595621003681457} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_validity","base_size":54893,"alt_size":57999,"ratio":1.0565828065509264} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion","base_size":31464,"alt_size":33902,"ratio":1.077485380116959} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion_from_public","base_size":313,"alt_size":690,"ratio":2.2044728434504792} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read","base_size":33536,"alt_size":36157,"ratio":1.07815481870229} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read_unset_slot","base_size":33652,"alt_size":36218,"ratio":1.0762510400570546} +{"name":"lending_contract-Lending::_borrow","base_size":7972,"alt_size":9236,"ratio":1.1585549422980432} +{"name":"lending_contract-Lending::_deposit","base_size":2084,"alt_size":2741,"ratio":1.3152591170825336} +{"name":"lending_contract-Lending::_repay","base_size":5380,"alt_size":6498,"ratio":1.2078066914498142} +{"name":"lending_contract-Lending::_withdraw","base_size":7317,"alt_size":8470,"ratio":1.1575782424490912} +{"name":"lending_contract-Lending::borrow_private","base_size":22563,"alt_size":24566,"ratio":1.0887736559854628} +{"name":"lending_contract-Lending::borrow_public","base_size":803,"alt_size":1292,"ratio":1.6089663760896638} +{"name":"lending_contract-Lending::constructor","base_size":23355,"alt_size":25535,"ratio":1.093341896810105} +{"name":"lending_contract-Lending::deposit_private","base_size":23119,"alt_size":25152,"ratio":1.0879363294260131} +{"name":"lending_contract-Lending::deposit_public","base_size":1111,"alt_size":1608,"ratio":1.4473447344734474} +{"name":"lending_contract-Lending::get_asset","base_size":1671,"alt_size":2292,"ratio":1.371633752244165} +{"name":"lending_contract-Lending::get_assets","base_size":522,"alt_size":953,"ratio":1.8256704980842913} +{"name":"lending_contract-Lending::get_position","base_size":4476,"alt_size":5216,"ratio":1.16532618409294} +{"name":"lending_contract-Lending::init","base_size":1981,"alt_size":2628,"ratio":1.326602725896012} +{"name":"lending_contract-Lending::process_log","base_size":15154,"alt_size":16635,"ratio":1.0977299722845453} +{"name":"lending_contract-Lending::public_dispatch","base_size":30933,"alt_size":34158,"ratio":1.1042575889826398} +{"name":"lending_contract-Lending::repay_private","base_size":23019,"alt_size":25048,"ratio":1.0881445762196447} +{"name":"lending_contract-Lending::repay_public","base_size":1161,"alt_size":1649,"ratio":1.4203273040482343} +{"name":"lending_contract-Lending::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"lending_contract-Lending::update_accumulator","base_size":6404,"alt_size":7448,"ratio":1.1630231105559026} +{"name":"lending_contract-Lending::withdraw_private","base_size":22630,"alt_size":24565,"ratio":1.085505965532479} +{"name":"lending_contract-Lending::withdraw_public","base_size":799,"alt_size":1284,"ratio":1.607008760951189} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::entrypoint","base_size":19274,"alt_size":22132,"ratio":1.1482826605790184} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"nft_contract-NFT::_finalize_transfer_to_private_unsafe","base_size":3624,"alt_size":4393,"ratio":1.2121964679911699} +{"name":"nft_contract-NFT::_finish_transfer_to_public","base_size":1227,"alt_size":1813,"ratio":1.4775876120619398} +{"name":"nft_contract-NFT::_store_payload_in_transient_storage_unsafe","base_size":1225,"alt_size":1746,"ratio":1.4253061224489796} +{"name":"nft_contract-NFT::cancel_authwit","base_size":21353,"alt_size":23246,"ratio":1.0886526483398118} +{"name":"nft_contract-NFT::constructor","base_size":5808,"alt_size":6357,"ratio":1.0945247933884297} +{"name":"nft_contract-NFT::finalize_transfer_to_private","base_size":3569,"alt_size":4357,"ratio":1.2207901372933594} +{"name":"nft_contract-NFT::get_admin","base_size":367,"alt_size":734,"ratio":2} +{"name":"nft_contract-NFT::get_private_nfts","base_size":20357,"alt_size":22430,"ratio":1.1018322935599547} +{"name":"nft_contract-NFT::is_minter","base_size":1240,"alt_size":1836,"ratio":1.4806451612903226} +{"name":"nft_contract-NFT::mint","base_size":2593,"alt_size":3176,"ratio":1.224836097184728} +{"name":"nft_contract-NFT::owner_of","base_size":1824,"alt_size":2372,"ratio":1.3004385964912282} +{"name":"nft_contract-NFT::prepare_private_balance_increase","base_size":66800,"alt_size":70529,"ratio":1.0558233532934131} +{"name":"nft_contract-NFT::private_get_name","base_size":28334,"alt_size":30564,"ratio":1.0787040304934001} +{"name":"nft_contract-NFT::private_get_symbol","base_size":28195,"alt_size":30570,"ratio":1.0842347934030856} +{"name":"nft_contract-NFT::process_log","base_size":15100,"alt_size":16557,"ratio":1.0964900662251655} +{"name":"nft_contract-NFT::public_dispatch","base_size":20666,"alt_size":22926,"ratio":1.1093583663989162} +{"name":"nft_contract-NFT::public_get_name","base_size":375,"alt_size":735,"ratio":1.96} +{"name":"nft_contract-NFT::public_get_symbol","base_size":347,"alt_size":729,"ratio":2.1008645533141213} +{"name":"nft_contract-NFT::set_admin","base_size":376,"alt_size":790,"ratio":2.101063829787234} +{"name":"nft_contract-NFT::set_minter","base_size":1251,"alt_size":1846,"ratio":1.4756195043964828} +{"name":"nft_contract-NFT::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"nft_contract-NFT::transfer_in_private","base_size":99147,"alt_size":104038,"ratio":1.0493307916527983} +{"name":"nft_contract-NFT::transfer_in_public","base_size":3849,"alt_size":4525,"ratio":1.1756300337750065} +{"name":"nft_contract-NFT::transfer_to_private","base_size":66805,"alt_size":70684,"ratio":1.0580645161290323} +{"name":"nft_contract-NFT::transfer_to_public","base_size":50556,"alt_size":53653,"ratio":1.061258802120421} +{"name":"parent_contract-Parent::enqueue_call_to_child","base_size":22160,"alt_size":23839,"ratio":1.0757671480144404} +{"name":"parent_contract-Parent::enqueue_call_to_child_twice","base_size":22174,"alt_size":23961,"ratio":1.080589880039686} +{"name":"parent_contract-Parent::enqueue_call_to_pub_entry_point","base_size":22158,"alt_size":23786,"ratio":1.0734723350482895} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_first","base_size":22477,"alt_size":24344,"ratio":1.0830626863015527} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_last","base_size":22445,"alt_size":24290,"ratio":1.0822009356204054} +{"name":"parent_contract-Parent::enqueue_calls_to_pub_entry_point","base_size":22052,"alt_size":23879,"ratio":1.0828496281516415} +{"name":"parent_contract-Parent::enqueue_static_call_to_pub_function","base_size":22152,"alt_size":23849,"ratio":1.0766070783676418} +{"name":"parent_contract-Parent::enqueue_static_nested_call_to_pub_function","base_size":22013,"alt_size":23775,"ratio":1.08004361059374} +{"name":"parent_contract-Parent::entry_point","base_size":22420,"alt_size":24247,"ratio":1.0814897413024085} +{"name":"parent_contract-Parent::private_call","base_size":22488,"alt_size":24253,"ratio":1.0784863038064745} +{"name":"parent_contract-Parent::private_nested_static_call","base_size":22472,"alt_size":24396,"ratio":1.08561765752937} +{"name":"parent_contract-Parent::private_static_call","base_size":22390,"alt_size":24386,"ratio":1.0891469405984815} +{"name":"parent_contract-Parent::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"parent_contract-Parent::pub_entry_point","base_size":747,"alt_size":1269,"ratio":1.6987951807228916} +{"name":"parent_contract-Parent::pub_entry_point_twice","base_size":1033,"alt_size":1548,"ratio":1.4985479186834463} +{"name":"parent_contract-Parent::public_dispatch","base_size":4099,"alt_size":4912,"ratio":1.198341058794828} +{"name":"parent_contract-Parent::public_nested_static_call","base_size":2701,"alt_size":3407,"ratio":1.2613846723435764} +{"name":"parent_contract-Parent::public_static_call","base_size":1189,"alt_size":1755,"ratio":1.4760302775441547} +{"name":"parent_contract-Parent::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"pending_note_hashes_contract-PendingNoteHashes::dummy","base_size":21375,"alt_size":22984,"ratio":1.0752748538011696} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_note_zero_balance","base_size":57201,"alt_size":62117,"ratio":1.0859425534518627} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_then_nullify_note","base_size":40632,"alt_size":43453,"ratio":1.0694280370151605} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note","base_size":70652,"alt_size":74375,"ratio":1.0526948989412896} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_extra_emit","base_size":81793,"alt_size":85778,"ratio":1.0487205506583692} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_static_randomness","base_size":66696,"alt_size":70166,"ratio":1.0520271080724481} +{"name":"pending_note_hashes_contract-PendingNoteHashes::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"pending_note_hashes_contract-PendingNoteHashes::recursively_destroy_and_create_notes","base_size":432377,"alt_size":460237,"ratio":1.064434509698712} +{"name":"pending_note_hashes_contract-PendingNoteHashes::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_bad_get_then_insert_flat","base_size":90538,"alt_size":95555,"ratio":1.055413196668802} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_emit_bad_note_log","base_size":81631,"alt_size":85700,"ratio":1.0498462593867526} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert1_then_get2_then_nullify2_all_in_nested_calls","base_size":22403,"alt_size":24261,"ratio":1.0829353211623443} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify1_all_in_nested_calls","base_size":22389,"alt_size":24251,"ratio":1.083165840368038} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify2_all_in_nested_calls","base_size":22602,"alt_size":24326,"ratio":1.0762764357136536} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_all_in_nested_calls","base_size":22406,"alt_size":24206,"ratio":1.0803356243863251} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_flat","base_size":234489,"alt_size":253714,"ratio":1.0819867882928411} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_recursively_create_notes","base_size":299554,"alt_size":311745,"ratio":1.0406971697924248} +{"name":"price_feed_contract-PriceFeed::get_price","base_size":1236,"alt_size":1812,"ratio":1.4660194174757282} +{"name":"price_feed_contract-PriceFeed::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"price_feed_contract-PriceFeed::public_dispatch","base_size":2484,"alt_size":3212,"ratio":1.2930756843800322} +{"name":"price_feed_contract-PriceFeed::set_price","base_size":1151,"alt_size":1696,"ratio":1.473501303214596} +{"name":"price_feed_contract-PriceFeed::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"router_contract-Router::_check_block_number","base_size":995,"alt_size":1537,"ratio":1.5447236180904522} +{"name":"router_contract-Router::_check_timestamp","base_size":1030,"alt_size":1561,"ratio":1.5155339805825243} +{"name":"router_contract-Router::check_block_number","base_size":4928,"alt_size":5555,"ratio":1.1272321428571428} +{"name":"router_contract-Router::check_timestamp","base_size":4944,"alt_size":5562,"ratio":1.125} +{"name":"router_contract-Router::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"router_contract-Router::public_dispatch","base_size":2001,"alt_size":2660,"ratio":1.329335332333833} +{"name":"router_contract-Router::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"schnorr_account_contract-SchnorrAccount::constructor","base_size":64119,"alt_size":67241,"ratio":1.0486907157004943} +{"name":"schnorr_account_contract-SchnorrAccount::entrypoint","base_size":67390,"alt_size":73078,"ratio":1.084404214275115} +{"name":"schnorr_account_contract-SchnorrAccount::lookup_validity","base_size":24045,"alt_size":25868,"ratio":1.075816177999584} +{"name":"schnorr_account_contract-SchnorrAccount::process_log","base_size":15457,"alt_size":16693,"ratio":1.0799637704599858} +{"name":"schnorr_account_contract-SchnorrAccount::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"schnorr_account_contract-SchnorrAccount::verify_private_authwit","base_size":41146,"alt_size":43535,"ratio":1.0580615369659263} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::entrypoint","base_size":49331,"alt_size":53697,"ratio":1.0885041860087976} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::verify_private_authwit","base_size":22056,"alt_size":23403,"ratio":1.0610718171926006} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::entrypoint","base_size":45825,"alt_size":50603,"ratio":1.104266230223677} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::process_log","base_size":1279,"alt_size":1655,"ratio":1.293979671618452} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::verify_private_authwit","base_size":18615,"alt_size":19946,"ratio":1.07150147730325} +{"name":"spam_contract-Spam::process_log","base_size":22044,"alt_size":23784,"ratio":1.0789330430048993} +{"name":"spam_contract-Spam::public_dispatch","base_size":2421,"alt_size":3092,"ratio":1.2771581990912846} +{"name":"spam_contract-Spam::public_spam","base_size":1899,"alt_size":2508,"ratio":1.320695102685624} +{"name":"spam_contract-Spam::spam","base_size":96835,"alt_size":109031,"ratio":1.125946197139464} +{"name":"spam_contract-Spam::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"stateful_test_contract-StatefulTest::constructor","base_size":24200,"alt_size":26408,"ratio":1.0912396694214876} +{"name":"stateful_test_contract-StatefulTest::create_note","base_size":72583,"alt_size":76544,"ratio":1.0545720072193214} +{"name":"stateful_test_contract-StatefulTest::create_note_no_init_check","base_size":72641,"alt_size":76358,"ratio":1.0511694497597774} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create","base_size":452799,"alt_size":475999,"ratio":1.0512368622722223} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create_no_init_check","base_size":452957,"alt_size":475946,"ratio":1.0507531619999249} +{"name":"stateful_test_contract-StatefulTest::get_public_value","base_size":1166,"alt_size":1702,"ratio":1.4596912521440824} +{"name":"stateful_test_contract-StatefulTest::increment_public_value","base_size":1203,"alt_size":1790,"ratio":1.487946799667498} +{"name":"stateful_test_contract-StatefulTest::increment_public_value_no_init_check","base_size":1112,"alt_size":1695,"ratio":1.5242805755395683} +{"name":"stateful_test_contract-StatefulTest::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"stateful_test_contract-StatefulTest::public_constructor","base_size":3363,"alt_size":3974,"ratio":1.1816830211121023} +{"name":"stateful_test_contract-StatefulTest::public_dispatch","base_size":5887,"alt_size":6535,"ratio":1.1100730422965857} +{"name":"stateful_test_contract-StatefulTest::summed_values","base_size":19173,"alt_size":21075,"ratio":1.0992020028164606} +{"name":"stateful_test_contract-StatefulTest::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"stateful_test_contract-StatefulTest::wrong_constructor","base_size":24134,"alt_size":26179,"ratio":1.0847352283086102} +{"name":"static_child_contract-StaticChild::private_get_value","base_size":51394,"alt_size":54245,"ratio":1.055473401564385} +{"name":"static_child_contract-StaticChild::private_illegal_set_value","base_size":66648,"alt_size":70428,"ratio":1.056715880446525} +{"name":"static_child_contract-StaticChild::private_set_value","base_size":66805,"alt_size":70459,"ratio":1.0546965047526382} +{"name":"static_child_contract-StaticChild::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"static_child_contract-StaticChild::pub_get_value","base_size":368,"alt_size":759,"ratio":2.0625} +{"name":"static_child_contract-StaticChild::pub_illegal_inc_value","base_size":452,"alt_size":880,"ratio":1.9469026548672566} +{"name":"static_child_contract-StaticChild::pub_inc_value","base_size":398,"alt_size":840,"ratio":2.1105527638190953} +{"name":"static_child_contract-StaticChild::pub_set_value","base_size":381,"alt_size":809,"ratio":2.1233595800524934} +{"name":"static_child_contract-StaticChild::public_dispatch","base_size":1389,"alt_size":1920,"ratio":1.3822894168466522} +{"name":"static_child_contract-StaticChild::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"static_parent_contract-StaticParent::enqueue_call","base_size":22046,"alt_size":23870,"ratio":1.0827360972512021} +{"name":"static_parent_contract-StaticParent::enqueue_public_get_value_from_child","base_size":22073,"alt_size":23810,"ratio":1.078693426357994} +{"name":"static_parent_contract-StaticParent::enqueue_static_call_to_pub_function","base_size":22152,"alt_size":23849,"ratio":1.0766070783676418} +{"name":"static_parent_contract-StaticParent::enqueue_static_nested_call_to_pub_function","base_size":22057,"alt_size":23782,"ratio":1.078206465067779} +{"name":"static_parent_contract-StaticParent::private_call","base_size":22488,"alt_size":24253,"ratio":1.0784863038064745} +{"name":"static_parent_contract-StaticParent::private_call_3_args","base_size":22508,"alt_size":24429,"ratio":1.0853474320241692} +{"name":"static_parent_contract-StaticParent::private_get_value_from_child","base_size":22453,"alt_size":24279,"ratio":1.0813254353538502} +{"name":"static_parent_contract-StaticParent::private_nested_static_call","base_size":22442,"alt_size":24345,"ratio":1.0847963639604314} +{"name":"static_parent_contract-StaticParent::private_nested_static_call_3_args","base_size":22492,"alt_size":24294,"ratio":1.0801173750666904} +{"name":"static_parent_contract-StaticParent::private_static_call","base_size":22390,"alt_size":24386,"ratio":1.0891469405984815} +{"name":"static_parent_contract-StaticParent::private_static_call_3_args","base_size":22512,"alt_size":24394,"ratio":1.0835998578535893} +{"name":"static_parent_contract-StaticParent::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"static_parent_contract-StaticParent::public_call","base_size":747,"alt_size":1269,"ratio":1.6987951807228916} +{"name":"static_parent_contract-StaticParent::public_dispatch","base_size":2221,"alt_size":2769,"ratio":1.2467357046375507} +{"name":"static_parent_contract-StaticParent::public_get_value_from_child","base_size":729,"alt_size":1215,"ratio":1.6666666666666667} +{"name":"static_parent_contract-StaticParent::public_nested_static_call","base_size":947,"alt_size":1472,"ratio":1.5543822597676875} +{"name":"static_parent_contract-StaticParent::public_static_call","base_size":1189,"alt_size":1755,"ratio":1.4760302775441547} +{"name":"static_parent_contract-StaticParent::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"test_contract-Test::assert_header_private","base_size":29354,"alt_size":31722,"ratio":1.0806704367377529} +{"name":"test_contract-Test::assert_private_global_vars","base_size":28839,"alt_size":31230,"ratio":1.0829085613232081} +{"name":"test_contract-Test::assert_public_global_vars","base_size":529,"alt_size":940,"ratio":1.776937618147448} +{"name":"test_contract-Test::call_create_note","base_size":78135,"alt_size":82377,"ratio":1.054290650796698} +{"name":"test_contract-Test::call_destroy_note","base_size":71911,"alt_size":78240,"ratio":1.0880115698571846} +{"name":"test_contract-Test::call_get_notes","base_size":64935,"alt_size":70803,"ratio":1.0903672903672903} +{"name":"test_contract-Test::call_get_notes_many","base_size":64853,"alt_size":70630,"ratio":1.0890783772531725} +{"name":"test_contract-Test::call_view_notes","base_size":25750,"alt_size":28234,"ratio":1.0964660194174758} +{"name":"test_contract-Test::call_view_notes_many","base_size":25844,"alt_size":28307,"ratio":1.0953025847392044} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_private","base_size":77083,"alt_size":81241,"ratio":1.0539418548836967} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_public","base_size":5303,"alt_size":6082,"ratio":1.1468979822741845} +{"name":"test_contract-Test::consume_mint_to_private_message","base_size":84273,"alt_size":88804,"ratio":1.05376573754346} +{"name":"test_contract-Test::consume_mint_to_public_message","base_size":7825,"alt_size":8825,"ratio":1.1277955271565496} +{"name":"test_contract-Test::consume_note_from_secret","base_size":49918,"alt_size":53551,"ratio":1.0727793581473617} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_private","base_size":29025,"alt_size":31204,"ratio":1.0750732127476315} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_public","base_size":244,"alt_size":608,"ratio":2.4918032786885247} +{"name":"test_contract-Test::create_l2_to_l1_message_public","base_size":1850,"alt_size":2368,"ratio":1.28} +{"name":"test_contract-Test::deliver_note","base_size":43379,"alt_size":46705,"ratio":1.0766730445607322} +{"name":"test_contract-Test::deploy_contract","base_size":31740,"alt_size":34604,"ratio":1.0902331442974165} +{"name":"test_contract-Test::dummy_public_call","base_size":251,"alt_size":600,"ratio":2.3904382470119523} +{"name":"test_contract-Test::emit_array_as_encrypted_log","base_size":51594,"alt_size":56154,"ratio":1.0883823700430282} +{"name":"test_contract-Test::emit_encrypted_logs_nested","base_size":74678,"alt_size":78978,"ratio":1.057580545810011} +{"name":"test_contract-Test::emit_nullifier","base_size":29025,"alt_size":31516,"ratio":1.0858225667527992} +{"name":"test_contract-Test::emit_nullifier_public","base_size":216,"alt_size":590,"ratio":2.7314814814814814} +{"name":"test_contract-Test::emit_public","base_size":1104,"alt_size":1628,"ratio":1.4746376811594204} +{"name":"test_contract-Test::get_constant","base_size":25065,"alt_size":27586,"ratio":1.1005784959106324} +{"name":"test_contract-Test::get_master_incoming_viewing_public_key","base_size":30981,"alt_size":33860,"ratio":1.0929279235660567} +{"name":"test_contract-Test::get_ovsk_app","base_size":29812,"alt_size":32313,"ratio":1.0838923923252382} +{"name":"test_contract-Test::get_this_address","base_size":29123,"alt_size":31597,"ratio":1.08495003948769} +{"name":"test_contract-Test::is_time_equal","base_size":263,"alt_size":642,"ratio":2.44106463878327} +{"name":"test_contract-Test::process_log","base_size":22905,"alt_size":24685,"ratio":1.0777122898930365} +{"name":"test_contract-Test::public_dispatch","base_size":15580,"alt_size":17249,"ratio":1.1071245186136072} +{"name":"test_contract-Test::set_constant","base_size":30295,"alt_size":32705,"ratio":1.0795510810364746} +{"name":"test_contract-Test::set_tx_max_block_number","base_size":29406,"alt_size":32004,"ratio":1.0883493164660274} +{"name":"test_contract-Test::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"test_contract-Test::test_code_gen","base_size":29600,"alt_size":32031,"ratio":1.0821283783783784} +{"name":"test_contract-Test::test_nullifier_key_freshness","base_size":30878,"alt_size":33766,"ratio":1.0935293736640974} +{"name":"test_contract-Test::test_setting_fee_payer","base_size":29431,"alt_size":31919,"ratio":1.0845367129897048} +{"name":"test_contract-Test::test_setting_teardown","base_size":29376,"alt_size":31932,"ratio":1.0870098039215685} +{"name":"test_log_contract-TestLog::emit_encrypted_events","base_size":100662,"alt_size":105340,"ratio":1.0464723530229878} +{"name":"test_log_contract-TestLog::emit_unencrypted_events","base_size":663,"alt_size":1122,"ratio":1.6923076923076923} +{"name":"test_log_contract-TestLog::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"test_log_contract-TestLog::public_dispatch","base_size":1499,"alt_size":2070,"ratio":1.380920613742495} +{"name":"test_log_contract-TestLog::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"token_blacklist_contract-TokenBlacklist::_increase_public_balance","base_size":2037,"alt_size":2658,"ratio":1.304860088365243} +{"name":"token_blacklist_contract-TokenBlacklist::_reduce_total_supply","base_size":590,"alt_size":1057,"ratio":1.7915254237288136} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_private","base_size":24248,"alt_size":26485,"ratio":1.0922550313427912} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_public","base_size":1312,"alt_size":1917,"ratio":1.4611280487804879} +{"name":"token_blacklist_contract-TokenBlacklist::burn","base_size":252437,"alt_size":271060,"ratio":1.0737728621398606} +{"name":"token_blacklist_contract-TokenBlacklist::burn_public","base_size":5624,"alt_size":6318,"ratio":1.1233997155049786} +{"name":"token_blacklist_contract-TokenBlacklist::constructor","base_size":5720,"alt_size":6782,"ratio":1.1856643356643357} +{"name":"token_blacklist_contract-TokenBlacklist::deliver_transparent_note","base_size":37047,"alt_size":39832,"ratio":1.075174777984722} +{"name":"token_blacklist_contract-TokenBlacklist::get_roles","base_size":1691,"alt_size":2279,"ratio":1.3477232406859847} +{"name":"token_blacklist_contract-TokenBlacklist::mint_private","base_size":2880,"alt_size":3404,"ratio":1.1819444444444445} +{"name":"token_blacklist_contract-TokenBlacklist::mint_public","base_size":3750,"alt_size":4366,"ratio":1.1642666666666666} +{"name":"token_blacklist_contract-TokenBlacklist::process_log","base_size":18615,"alt_size":20037,"ratio":1.0763900080580178} +{"name":"token_blacklist_contract-TokenBlacklist::public_dispatch","base_size":48080,"alt_size":50353,"ratio":1.04727537437604} +{"name":"token_blacklist_contract-TokenBlacklist::redeem_shield","base_size":112463,"alt_size":117798,"ratio":1.0474378239954474} +{"name":"token_blacklist_contract-TokenBlacklist::shield","base_size":6609,"alt_size":7387,"ratio":1.1177182629747315} +{"name":"token_blacklist_contract-TokenBlacklist::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"token_blacklist_contract-TokenBlacklist::total_supply","base_size":451,"alt_size":868,"ratio":1.9246119733924612} +{"name":"token_blacklist_contract-TokenBlacklist::transfer","base_size":241705,"alt_size":262855,"ratio":1.0875033615357563} +{"name":"token_blacklist_contract-TokenBlacklist::transfer_public","base_size":7362,"alt_size":8167,"ratio":1.1093452866069002} +{"name":"token_blacklist_contract-TokenBlacklist::unshield","base_size":260032,"alt_size":278431,"ratio":1.070756676101403} +{"name":"token_blacklist_contract-TokenBlacklist::update_roles","base_size":5230,"alt_size":6200,"ratio":1.1854684512428297} +{"name":"token_bridge_contract-TokenBridge::claim_private","base_size":83713,"alt_size":88412,"ratio":1.0561322614169841} +{"name":"token_bridge_contract-TokenBridge::claim_public","base_size":8518,"alt_size":9631,"ratio":1.130664475228927} +{"name":"token_bridge_contract-TokenBridge::constructor","base_size":3483,"alt_size":4102,"ratio":1.1777203560149296} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_private","base_size":49544,"alt_size":52691,"ratio":1.0635192959793316} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_public","base_size":3948,"alt_size":4805,"ratio":1.2170719351570416} +{"name":"token_bridge_contract-TokenBridge::get_config","base_size":28402,"alt_size":30654,"ratio":1.0792901908316315} +{"name":"token_bridge_contract-TokenBridge::get_config_public","base_size":428,"alt_size":825,"ratio":1.9275700934579438} +{"name":"token_bridge_contract-TokenBridge::process_log","base_size":15154,"alt_size":16635,"ratio":1.0977299722845453} +{"name":"token_bridge_contract-TokenBridge::public_dispatch","base_size":15017,"alt_size":17134,"ratio":1.1409735632949325} +{"name":"token_bridge_contract-TokenBridge::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"token_contract-Token::_finalize_mint_to_private_unsafe","base_size":3726,"alt_size":4532,"ratio":1.2163177670424048} +{"name":"token_contract-Token::_finalize_transfer_to_private_unsafe","base_size":4227,"alt_size":5044,"ratio":1.1932812869647504} +{"name":"token_contract-Token::_increase_public_balance","base_size":2009,"alt_size":2586,"ratio":1.2872075659532105} +{"name":"token_contract-Token::_recurse_subtract_balance","base_size":110226,"alt_size":119993,"ratio":1.0886088581641356} +{"name":"token_contract-Token::_reduce_total_supply","base_size":559,"alt_size":1016,"ratio":1.8175313059033988} +{"name":"token_contract-Token::_store_payload_in_transient_storage_unsafe","base_size":1225,"alt_size":1746,"ratio":1.4253061224489796} +{"name":"token_contract-Token::balance_of_private","base_size":19316,"alt_size":21440,"ratio":1.1099606543797889} +{"name":"token_contract-Token::balance_of_public","base_size":1320,"alt_size":1911,"ratio":1.4477272727272728} +{"name":"token_contract-Token::burn_private","base_size":232328,"alt_size":252229,"ratio":1.0856590682139045} +{"name":"token_contract-Token::burn_public","base_size":4353,"alt_size":5316,"ratio":1.2212267401791868} +{"name":"token_contract-Token::cancel_authwit","base_size":21426,"alt_size":23329,"ratio":1.088817324745636} +{"name":"token_contract-Token::constructor","base_size":6193,"alt_size":6753,"ratio":1.0904246730179235} +{"name":"token_contract-Token::finalize_mint_to_private","base_size":3676,"alt_size":4496,"ratio":1.2230685527747551} +{"name":"token_contract-Token::finalize_transfer_to_private","base_size":4168,"alt_size":5026,"ratio":1.2058541266794627} +{"name":"token_contract-Token::get_admin","base_size":357,"alt_size":730,"ratio":2.044817927170868} +{"name":"token_contract-Token::is_minter","base_size":1245,"alt_size":1833,"ratio":1.472289156626506} +{"name":"token_contract-Token::mint_to_private","base_size":67137,"alt_size":70951,"ratio":1.0568092110162801} +{"name":"token_contract-Token::mint_to_public","base_size":2621,"alt_size":3213,"ratio":1.2258679893170545} +{"name":"token_contract-Token::prepare_private_balance_increase","base_size":66967,"alt_size":70693,"ratio":1.0556393447518928} +{"name":"token_contract-Token::private_get_decimals","base_size":28406,"alt_size":30618,"ratio":1.0778708723509118} +{"name":"token_contract-Token::private_get_name","base_size":28380,"alt_size":30661,"ratio":1.0803735024665257} +{"name":"token_contract-Token::private_get_symbol","base_size":28357,"alt_size":30684,"ratio":1.0820608668053744} +{"name":"token_contract-Token::process_log","base_size":15154,"alt_size":16635,"ratio":1.0977299722845453} +{"name":"token_contract-Token::public_dispatch","base_size":32221,"alt_size":37300,"ratio":1.157630117004438} +{"name":"token_contract-Token::public_get_decimals","base_size":384,"alt_size":783,"ratio":2.0390625} +{"name":"token_contract-Token::public_get_name","base_size":374,"alt_size":746,"ratio":1.9946524064171123} +{"name":"token_contract-Token::public_get_symbol","base_size":361,"alt_size":753,"ratio":2.085872576177285} +{"name":"token_contract-Token::set_admin","base_size":386,"alt_size":771,"ratio":1.9974093264248705} +{"name":"token_contract-Token::set_minter","base_size":1255,"alt_size":1831,"ratio":1.4589641434262948} +{"name":"token_contract-Token::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"token_contract-Token::total_supply","base_size":455,"alt_size":848,"ratio":1.8637362637362638} +{"name":"token_contract-Token::transfer","base_size":116065,"alt_size":127661,"ratio":1.0999095334510836} +{"name":"token_contract-Token::transfer_in_private","base_size":288372,"alt_size":311699,"ratio":1.0808920422232395} +{"name":"token_contract-Token::transfer_in_public","base_size":5501,"alt_size":6411,"ratio":1.1654244682784949} +{"name":"token_contract-Token::transfer_to_private","base_size":67108,"alt_size":71024,"ratio":1.0583536985158253} +{"name":"token_contract-Token::transfer_to_public","base_size":232245,"alt_size":252091,"ratio":1.0854528622790587} +{"name":"uniswap_contract-Uniswap::_approve_bridge_and_exit_input_asset_to_L1","base_size":5800,"alt_size":6481,"ratio":1.1174137931034482} +{"name":"uniswap_contract-Uniswap::constructor","base_size":2954,"alt_size":3554,"ratio":1.2031144211238998} +{"name":"uniswap_contract-Uniswap::process_log","base_size":15154,"alt_size":16635,"ratio":1.0977299722845453} +{"name":"uniswap_contract-Uniswap::public_dispatch","base_size":16599,"alt_size":18095,"ratio":1.0901259111994699} +{"name":"uniswap_contract-Uniswap::swap_private","base_size":73247,"alt_size":77278,"ratio":1.0550329706336095} +{"name":"uniswap_contract-Uniswap::swap_public","base_size":8226,"alt_size":9280,"ratio":1.1281303185023097} +{"name":"uniswap_contract-Uniswap::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"updatable_contract-Updatable::get_private_value","base_size":18282,"alt_size":19920,"ratio":1.089596324253364} +{"name":"updatable_contract-Updatable::get_public_value","base_size":16531,"alt_size":18173,"ratio":1.0993285342689492} +{"name":"updatable_contract-Updatable::get_update_delay","base_size":791,"alt_size":1265,"ratio":1.5992414664981036} +{"name":"updatable_contract-Updatable::initialize","base_size":68664,"alt_size":72190,"ratio":1.0513515087964582} +{"name":"updatable_contract-Updatable::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"updatable_contract-Updatable::public_dispatch","base_size":1384,"alt_size":1923,"ratio":1.3894508670520231} +{"name":"updatable_contract-Updatable::set_public_value","base_size":327,"alt_size":699,"ratio":2.1376146788990824} +{"name":"updatable_contract-Updatable::set_update_delay","base_size":21906,"alt_size":23765,"ratio":1.084862594722907} +{"name":"updatable_contract-Updatable::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} +{"name":"updatable_contract-Updatable::update_to","base_size":21930,"alt_size":23749,"ratio":1.0829457364341086} +{"name":"updated_contract-Updated::get_private_value","base_size":18282,"alt_size":19920,"ratio":1.089596324253364} +{"name":"updated_contract-Updated::get_public_value","base_size":16531,"alt_size":18173,"ratio":1.0993285342689492} +{"name":"updated_contract-Updated::get_update_delay","base_size":702,"alt_size":1183,"ratio":1.6851851851851851} +{"name":"updated_contract-Updated::process_log","base_size":15373,"alt_size":16700,"ratio":1.0863201717296558} +{"name":"updated_contract-Updated::public_dispatch","base_size":1255,"alt_size":1814,"ratio":1.445418326693227} +{"name":"updated_contract-Updated::set_private_value","base_size":65966,"alt_size":69334,"ratio":1.0510566049176848} +{"name":"updated_contract-Updated::set_public_value","base_size":231,"alt_size":552,"ratio":2.3896103896103895} +{"name":"updated_contract-Updated::sync_notes","base_size":194,"alt_size":516,"ratio":2.6597938144329896} diff --git a/scripts/bytecode-sizes/bincode-vs-cbor.png b/scripts/bytecode-sizes/bincode-vs-cbor.png new file mode 100644 index 00000000000..7edf72be23f Binary files /dev/null and b/scripts/bytecode-sizes/bincode-vs-cbor.png differ diff --git a/scripts/bytecode-sizes/bincode-vs-flexbuffers.jsonl b/scripts/bytecode-sizes/bincode-vs-flexbuffers.jsonl new file mode 100644 index 00000000000..0c788cc379e --- /dev/null +++ b/scripts/bytecode-sizes/bincode-vs-flexbuffers.jsonl @@ -0,0 +1,645 @@ +{"name":"parity_base","base_size":38512,"alt_size":132137,"ratio":3.431060448691317} +{"name":"parity_root","base_size":56652,"alt_size":195369,"ratio":3.4485808091506036} +{"name":"private_kernel_init","base_size":220963,"alt_size":877913,"ratio":3.9731221969288977} +{"name":"private_kernel_init_simulated","base_size":58910,"alt_size":385003,"ratio":6.535443897470718} +{"name":"private_kernel_inner","base_size":360037,"alt_size":1474626,"ratio":4.0957623799776135} +{"name":"private_kernel_inner_simulated","base_size":86003,"alt_size":548470,"ratio":6.377335674336941} +{"name":"private_kernel_reset","base_size":900341,"alt_size":3563809,"ratio":3.958288026425543} +{"name":"private_kernel_reset_simulated","base_size":109155,"alt_size":676273,"ratio":6.195529293206907} +{"name":"private_kernel_tail","base_size":119739,"alt_size":643104,"ratio":5.3708816676270885} +{"name":"private_kernel_tail_simulated","base_size":47129,"alt_size":290026,"ratio":6.153875533111248} +{"name":"private_kernel_tail_to_public","base_size":213723,"alt_size":1032856,"ratio":4.832685298259897} +{"name":"private_kernel_tail_to_public_simulated","base_size":69150,"alt_size":443226,"ratio":6.409631236442516} +{"name":"rollup_base_private","base_size":1395946,"alt_size":4945646,"ratio":3.5428634058910586} +{"name":"rollup_base_private_simulated","base_size":81316,"alt_size":527527,"ratio":6.487370259235575} +{"name":"rollup_base_public","base_size":679704,"alt_size":2397504,"ratio":3.5272765792168355} +{"name":"rollup_base_public_simulated","base_size":77006,"alt_size":455061,"ratio":5.909422642391502} +{"name":"rollup_block_merge","base_size":106886,"alt_size":531093,"ratio":4.968779821492057} +{"name":"rollup_block_root","base_size":14975740,"alt_size":49341442,"ratio":3.294758188910865} +{"name":"rollup_block_root_empty","base_size":20689,"alt_size":66040,"ratio":3.1920344144231234} +{"name":"rollup_block_root_simulated","base_size":82459,"alt_size":437365,"ratio":5.304029881516875} +{"name":"rollup_block_root_single_tx","base_size":14959959,"alt_size":49235159,"ratio":3.29112927381686} +{"name":"rollup_block_root_single_tx_simulated","base_size":76009,"alt_size":393224,"ratio":5.173387362022918} +{"name":"rollup_merge","base_size":29269,"alt_size":101367,"ratio":3.463288803853907} +{"name":"rollup_root","base_size":106709,"alt_size":530963,"ratio":4.9758033530442605} +{"name":"amm_contract-AMM::_add_liquidity","base_size":7622,"alt_size":44005,"ratio":5.773419050118079} +{"name":"amm_contract-AMM::_remove_liquidity","base_size":4902,"alt_size":27078,"ratio":5.523867809057528} +{"name":"amm_contract-AMM::_swap_exact_tokens_for_tokens","base_size":3837,"alt_size":19947,"ratio":5.19859265050821} +{"name":"amm_contract-AMM::_swap_tokens_for_exact_tokens","base_size":4339,"alt_size":22802,"ratio":5.255127909656603} +{"name":"amm_contract-AMM::add_liquidity","base_size":32091,"alt_size":177007,"ratio":5.515783241407248} +{"name":"amm_contract-AMM::constructor","base_size":3729,"alt_size":22424,"ratio":6.013408420488067} +{"name":"amm_contract-AMM::get_amount_in_for_exact_out","base_size":18345,"alt_size":129931,"ratio":7.082638321068411} +{"name":"amm_contract-AMM::get_amount_out_for_exact_in","base_size":18221,"alt_size":129506,"ratio":7.107513308819494} +{"name":"amm_contract-AMM::process_log","base_size":15154,"alt_size":107077,"ratio":7.06592318859707} +{"name":"amm_contract-AMM::public_dispatch","base_size":21009,"alt_size":132727,"ratio":6.317625779427864} +{"name":"amm_contract-AMM::remove_liquidity","base_size":29866,"alt_size":169544,"ratio":5.676823143373736} +{"name":"amm_contract-AMM::swap_exact_tokens_for_tokens","base_size":29805,"alt_size":169249,"ratio":5.678543868478443} +{"name":"amm_contract-AMM::swap_tokens_for_exact_tokens","base_size":29991,"alt_size":170054,"ratio":5.670167716981761} +{"name":"amm_contract-AMM::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"app_subscription_contract-AppSubscription::constructor","base_size":4363,"alt_size":24341,"ratio":5.5789594315837725} +{"name":"app_subscription_contract-AppSubscription::entrypoint","base_size":99041,"alt_size":445495,"ratio":4.498086650982926} +{"name":"app_subscription_contract-AppSubscription::is_initialized","base_size":24104,"alt_size":179915,"ratio":7.464113840026552} +{"name":"app_subscription_contract-AppSubscription::process_log","base_size":21895,"alt_size":160846,"ratio":7.346243434574104} +{"name":"app_subscription_contract-AppSubscription::public_dispatch","base_size":4869,"alt_size":28124,"ratio":5.776134729924009} +{"name":"app_subscription_contract-AppSubscription::subscribe","base_size":95196,"alt_size":428609,"ratio":4.502384553972856} +{"name":"app_subscription_contract-AppSubscription::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"auth_contract-Auth::constructor","base_size":2997,"alt_size":16666,"ratio":5.560894227560894} +{"name":"auth_contract-Auth::do_private_authorized_thing","base_size":12949,"alt_size":46204,"ratio":3.568151980847942} +{"name":"auth_contract-Auth::get_authorized","base_size":836,"alt_size":3816,"ratio":4.564593301435407} +{"name":"auth_contract-Auth::get_authorized_delay","base_size":663,"alt_size":3102,"ratio":4.678733031674208} +{"name":"auth_contract-Auth::get_authorized_in_private","base_size":13295,"alt_size":47732,"ratio":3.5902218879277923} +{"name":"auth_contract-Auth::get_scheduled_authorized","base_size":748,"alt_size":3378,"ratio":4.516042780748663} +{"name":"auth_contract-Auth::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"auth_contract-Auth::public_dispatch","base_size":9866,"alt_size":67633,"ratio":6.855159132373809} +{"name":"auth_contract-Auth::set_authorized","base_size":3466,"alt_size":24157,"ratio":6.969705712637046} +{"name":"auth_contract-Auth::set_authorized_delay","base_size":3492,"alt_size":24239,"ratio":6.941294387170676} +{"name":"auth_contract-Auth::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"auth_registry_contract-AuthRegistry::_set_authorized","base_size":1740,"alt_size":9411,"ratio":5.408620689655172} +{"name":"auth_registry_contract-AuthRegistry::consume","base_size":3874,"alt_size":26659,"ratio":6.881517811048012} +{"name":"auth_registry_contract-AuthRegistry::is_consumable","base_size":1730,"alt_size":9454,"ratio":5.4647398843930635} +{"name":"auth_registry_contract-AuthRegistry::is_reject_all","base_size":1143,"alt_size":5903,"ratio":5.164479440069991} +{"name":"auth_registry_contract-AuthRegistry::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"auth_registry_contract-AuthRegistry::public_dispatch","base_size":7767,"alt_size":66022,"ratio":8.500321874597656} +{"name":"auth_registry_contract-AuthRegistry::set_authorized","base_size":1693,"alt_size":9222,"ratio":5.447135262847017} +{"name":"auth_registry_contract-AuthRegistry::set_authorized_private","base_size":5800,"alt_size":23807,"ratio":4.104655172413793} +{"name":"auth_registry_contract-AuthRegistry::set_reject_all","base_size":1113,"alt_size":5747,"ratio":5.163522012578617} +{"name":"auth_registry_contract-AuthRegistry::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"auth_registry_contract-AuthRegistry::unconstrained_is_consumable","base_size":1756,"alt_size":9759,"ratio":5.55751708428246} +{"name":"auth_wit_test_contract-AuthWitTest::consume","base_size":5464,"alt_size":20881,"ratio":3.821559297218155} +{"name":"auth_wit_test_contract-AuthWitTest::consume_public","base_size":749,"alt_size":3676,"ratio":4.907877169559413} +{"name":"auth_wit_test_contract-AuthWitTest::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"auth_wit_test_contract-AuthWitTest::public_dispatch","base_size":1308,"alt_size":6573,"ratio":5.025229357798165} +{"name":"auth_wit_test_contract-AuthWitTest::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_f1600","base_size":712,"alt_size":2997,"ratio":4.209269662921348} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_hash","base_size":2062,"alt_size":9971,"ratio":4.835596508244423} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash","base_size":2820,"alt_size":10828,"ratio":3.8397163120567375} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash_with_index","base_size":2797,"alt_size":10829,"ratio":3.871648194494101} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::poseidon2_hash","base_size":1636,"alt_size":7995,"ratio":4.886919315403423} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::public_dispatch","base_size":39194,"alt_size":296545,"ratio":7.566081543093331} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_10","base_size":2487,"alt_size":12304,"ratio":4.947326095697628} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_100","base_size":3910,"alt_size":18085,"ratio":4.625319693094629} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_20","base_size":2503,"alt_size":12424,"ratio":4.963643627646824} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_2048","base_size":22473,"alt_size":95793,"ratio":4.262581764784408} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_255","base_size":5869,"alt_size":25511,"ratio":4.346737093201567} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_256","base_size":5530,"alt_size":24470,"ratio":4.424954792043399} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_30","base_size":2708,"alt_size":13128,"ratio":4.847858197932053} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_40","base_size":2761,"alt_size":13271,"ratio":4.806591814559942} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_50","base_size":2905,"alt_size":13927,"ratio":4.7941480206540446} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_511","base_size":8590,"alt_size":36944,"ratio":4.30081490104773} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_512","base_size":8154,"alt_size":35733,"ratio":4.382266372332597} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_60","base_size":2998,"alt_size":14050,"ratio":4.686457638425617} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_70","base_size":3715,"alt_size":17192,"ratio":4.627725437415881} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_80","base_size":3610,"alt_size":17332,"ratio":4.801108033240998} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_90","base_size":3825,"alt_size":18059,"ratio":4.721307189542483} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"avm_initializer_test_contract-AvmInitializerTest::constructor","base_size":2520,"alt_size":12912,"ratio":5.123809523809523} +{"name":"avm_initializer_test_contract-AvmInitializerTest::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"avm_initializer_test_contract-AvmInitializerTest::public_dispatch","base_size":3106,"alt_size":16491,"ratio":5.309401159047006} +{"name":"avm_initializer_test_contract-AvmInitializerTest::read_storage_immutable","base_size":321,"alt_size":1420,"ratio":4.423676012461059} +{"name":"avm_initializer_test_contract-AvmInitializerTest::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"avm_test_contract-AvmTest::add_args_return","base_size":228,"alt_size":1162,"ratio":5.0964912280701755} +{"name":"avm_test_contract-AvmTest::add_storage_map","base_size":2300,"alt_size":12854,"ratio":5.588695652173913} +{"name":"avm_test_contract-AvmTest::add_u128","base_size":345,"alt_size":1697,"ratio":4.918840579710145} +{"name":"avm_test_contract-AvmTest::assert_calldata_copy","base_size":615,"alt_size":2958,"ratio":4.809756097560975} +{"name":"avm_test_contract-AvmTest::assert_nullifier_exists","base_size":286,"alt_size":1321,"ratio":4.618881118881119} +{"name":"avm_test_contract-AvmTest::assert_same","base_size":254,"alt_size":1275,"ratio":5.019685039370079} +{"name":"avm_test_contract-AvmTest::assertion_failure","base_size":213,"alt_size":1089,"ratio":5.112676056338028} +{"name":"avm_test_contract-AvmTest::bulk_testing","base_size":18366,"alt_size":120787,"ratio":6.5766633997604265} +{"name":"avm_test_contract-AvmTest::create_different_nullifier_in_nested_call","base_size":737,"alt_size":3410,"ratio":4.626865671641791} +{"name":"avm_test_contract-AvmTest::create_same_nullifier_in_nested_call","base_size":706,"alt_size":3324,"ratio":4.708215297450425} +{"name":"avm_test_contract-AvmTest::debug_logging","base_size":1075,"alt_size":7343,"ratio":6.830697674418604} +{"name":"avm_test_contract-AvmTest::divide_by_zero","base_size":209,"alt_size":1065,"ratio":5.095693779904306} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add","base_size":665,"alt_size":3332,"ratio":5.010526315789473} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add_and_double","base_size":323,"alt_size":1272,"ratio":3.9380804953560373} +{"name":"avm_test_contract-AvmTest::emit_nullifier_and_check","base_size":310,"alt_size":1382,"ratio":4.458064516129032} +{"name":"avm_test_contract-AvmTest::emit_public_log","base_size":2015,"alt_size":11559,"ratio":5.736476426799007} +{"name":"avm_test_contract-AvmTest::enqueue_public_from_private","base_size":5008,"alt_size":19665,"ratio":3.926717252396166} +{"name":"avm_test_contract-AvmTest::external_call_to_assertion_failure","base_size":663,"alt_size":3147,"ratio":4.746606334841629} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero","base_size":673,"alt_size":3153,"ratio":4.684992570579495} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero_recovers","base_size":2193,"alt_size":11581,"ratio":5.280893752849977} +{"name":"avm_test_contract-AvmTest::get_address","base_size":212,"alt_size":1041,"ratio":4.910377358490566} +{"name":"avm_test_contract-AvmTest::get_args_hash","base_size":1810,"alt_size":9106,"ratio":5.030939226519337} +{"name":"avm_test_contract-AvmTest::get_block_number","base_size":216,"alt_size":1053,"ratio":4.875} +{"name":"avm_test_contract-AvmTest::get_chain_id","base_size":210,"alt_size":1044,"ratio":4.9714285714285715} +{"name":"avm_test_contract-AvmTest::get_da_gas_left","base_size":216,"alt_size":1050,"ratio":4.861111111111111} +{"name":"avm_test_contract-AvmTest::get_fee_per_da_gas","base_size":218,"alt_size":1053,"ratio":4.830275229357798} +{"name":"avm_test_contract-AvmTest::get_fee_per_l2_gas","base_size":216,"alt_size":1058,"ratio":4.898148148148148} +{"name":"avm_test_contract-AvmTest::get_l2_gas_left","base_size":215,"alt_size":1040,"ratio":4.837209302325581} +{"name":"avm_test_contract-AvmTest::get_sender","base_size":214,"alt_size":1037,"ratio":4.845794392523365} +{"name":"avm_test_contract-AvmTest::get_timestamp","base_size":220,"alt_size":1044,"ratio":4.745454545454545} +{"name":"avm_test_contract-AvmTest::get_transaction_fee","base_size":219,"alt_size":1051,"ratio":4.799086757990867} +{"name":"avm_test_contract-AvmTest::get_version","base_size":216,"alt_size":1040,"ratio":4.814814814814815} +{"name":"avm_test_contract-AvmTest::helper_with_failed_assertion","base_size":111,"alt_size":365,"ratio":3.2882882882882885} +{"name":"avm_test_contract-AvmTest::inner_helper_with_failed_assertion","base_size":111,"alt_size":365,"ratio":3.2882882882882885} +{"name":"avm_test_contract-AvmTest::l1_to_l2_msg_exists","base_size":266,"alt_size":1254,"ratio":4.714285714285714} +{"name":"avm_test_contract-AvmTest::modulo2","base_size":216,"alt_size":1166,"ratio":5.398148148148148} +{"name":"avm_test_contract-AvmTest::n_new_l2_to_l1_msgs","base_size":279,"alt_size":1398,"ratio":5.010752688172043} +{"name":"avm_test_contract-AvmTest::n_new_note_hashes","base_size":280,"alt_size":1405,"ratio":5.017857142857143} +{"name":"avm_test_contract-AvmTest::n_new_nullifiers","base_size":279,"alt_size":1400,"ratio":5.017921146953405} +{"name":"avm_test_contract-AvmTest::n_new_public_logs","base_size":386,"alt_size":1954,"ratio":5.062176165803109} +{"name":"avm_test_contract-AvmTest::n_storage_writes","base_size":1174,"alt_size":5918,"ratio":5.040885860306644} +{"name":"avm_test_contract-AvmTest::nested_call_to_add","base_size":761,"alt_size":3548,"ratio":4.662286465177398} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_n_times_different_addresses","base_size":1092,"alt_size":4815,"ratio":4.40934065934066} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_with_gas","base_size":713,"alt_size":3537,"ratio":4.9607293127629735} +{"name":"avm_test_contract-AvmTest::nested_call_to_assert_same","base_size":765,"alt_size":3553,"ratio":4.644444444444445} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing","base_size":667,"alt_size":3120,"ratio":4.677661169415292} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing_recovers","base_size":414,"alt_size":2095,"ratio":5.0603864734299515} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_add","base_size":753,"alt_size":3577,"ratio":4.750332005312085} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_set_storage","base_size":698,"alt_size":3219,"ratio":4.611747851002866} +{"name":"avm_test_contract-AvmTest::new_note_hash","base_size":224,"alt_size":1107,"ratio":4.941964285714286} +{"name":"avm_test_contract-AvmTest::new_nullifier","base_size":216,"alt_size":1107,"ratio":5.125} +{"name":"avm_test_contract-AvmTest::note_hash_exists","base_size":266,"alt_size":1266,"ratio":4.7593984962406015} +{"name":"avm_test_contract-AvmTest::nullifier_collision","base_size":230,"alt_size":1157,"ratio":5.030434782608696} +{"name":"avm_test_contract-AvmTest::nullifier_exists","base_size":265,"alt_size":1231,"ratio":4.645283018867924} +{"name":"avm_test_contract-AvmTest::pedersen_commit","base_size":1168,"alt_size":5364,"ratio":4.592465753424658} +{"name":"avm_test_contract-AvmTest::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"avm_test_contract-AvmTest::public_dispatch","base_size":39990,"alt_size":301076,"ratio":7.528782195548887} +{"name":"avm_test_contract-AvmTest::read_assert_storage_single","base_size":266,"alt_size":1287,"ratio":4.838345864661654} +{"name":"avm_test_contract-AvmTest::read_storage_list","base_size":392,"alt_size":1861,"ratio":4.747448979591836} +{"name":"avm_test_contract-AvmTest::read_storage_map","base_size":1110,"alt_size":5734,"ratio":5.165765765765766} +{"name":"avm_test_contract-AvmTest::read_storage_single","base_size":231,"alt_size":1109,"ratio":4.800865800865801} +{"name":"avm_test_contract-AvmTest::return_oracle","base_size":510,"alt_size":2558,"ratio":5.015686274509804} +{"name":"avm_test_contract-AvmTest::returndata_copy_oracle","base_size":1359,"alt_size":6682,"ratio":4.916850625459897} +{"name":"avm_test_contract-AvmTest::revert_oracle","base_size":496,"alt_size":2552,"ratio":5.145161290322581} +{"name":"avm_test_contract-AvmTest::send_l2_to_l1_msg","base_size":244,"alt_size":1179,"ratio":4.831967213114754} +{"name":"avm_test_contract-AvmTest::set_opcode_big_field","base_size":214,"alt_size":1023,"ratio":4.780373831775701} +{"name":"avm_test_contract-AvmTest::set_opcode_really_big_field","base_size":211,"alt_size":1022,"ratio":4.843601895734597} +{"name":"avm_test_contract-AvmTest::set_opcode_small_field","base_size":211,"alt_size":1021,"ratio":4.838862559241706} +{"name":"avm_test_contract-AvmTest::set_opcode_u32","base_size":196,"alt_size":961,"ratio":4.903061224489796} +{"name":"avm_test_contract-AvmTest::set_opcode_u64","base_size":195,"alt_size":979,"ratio":5.02051282051282} +{"name":"avm_test_contract-AvmTest::set_opcode_u8","base_size":187,"alt_size":975,"ratio":5.213903743315508} +{"name":"avm_test_contract-AvmTest::set_read_storage_single","base_size":262,"alt_size":1248,"ratio":4.763358778625954} +{"name":"avm_test_contract-AvmTest::set_storage_list","base_size":264,"alt_size":1296,"ratio":4.909090909090909} +{"name":"avm_test_contract-AvmTest::set_storage_map","base_size":1677,"alt_size":9112,"ratio":5.433512224209899} +{"name":"avm_test_contract-AvmTest::set_storage_single","base_size":230,"alt_size":1154,"ratio":5.017391304347826} +{"name":"avm_test_contract-AvmTest::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance","base_size":540,"alt_size":2455,"ratio":4.546296296296297} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance_matches","base_size":564,"alt_size":2531,"ratio":4.48758865248227} +{"name":"avm_test_contract-AvmTest::to_radix_le","base_size":472,"alt_size":2366,"ratio":5.012711864406779} +{"name":"avm_test_contract-AvmTest::u128_addition_overflow","base_size":1031,"alt_size":6826,"ratio":6.620756547041707} +{"name":"avm_test_contract-AvmTest::u128_from_integer_overflow","base_size":606,"alt_size":3979,"ratio":6.566006600660066} +{"name":"avm_test_contract-AvmTest::variable_base_msm","base_size":571,"alt_size":2887,"ratio":5.056042031523643} +{"name":"benchmarking_contract-Benchmarking::broadcast","base_size":1192,"alt_size":6170,"ratio":5.176174496644295} +{"name":"benchmarking_contract-Benchmarking::create_note","base_size":70451,"alt_size":312547,"ratio":4.43637421754127} +{"name":"benchmarking_contract-Benchmarking::increment_balance","base_size":2177,"alt_size":11486,"ratio":5.276067983463482} +{"name":"benchmarking_contract-Benchmarking::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"benchmarking_contract-Benchmarking::public_dispatch","base_size":6092,"alt_size":38219,"ratio":6.273637557452396} +{"name":"benchmarking_contract-Benchmarking::recreate_note","base_size":89161,"alt_size":390058,"ratio":4.374760265138345} +{"name":"benchmarking_contract-Benchmarking::sha256_hash_2048","base_size":22473,"alt_size":95793,"ratio":4.262581764784408} +{"name":"benchmarking_contract-Benchmarking::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"card_game_contract-CardGame::buy_pack","base_size":120555,"alt_size":484032,"ratio":4.015030484011447} +{"name":"card_game_contract-CardGame::claim_cards","base_size":149790,"alt_size":563284,"ratio":3.760491354563055} +{"name":"card_game_contract-CardGame::join_game","base_size":329284,"alt_size":1167966,"ratio":3.5469867955928622} +{"name":"card_game_contract-CardGame::on_card_played","base_size":3651,"alt_size":19985,"ratio":5.473842782799233} +{"name":"card_game_contract-CardGame::on_cards_claimed","base_size":4786,"alt_size":24387,"ratio":5.09548683660677} +{"name":"card_game_contract-CardGame::on_game_joined","base_size":2716,"alt_size":14207,"ratio":5.230854197349043} +{"name":"card_game_contract-CardGame::play_card","base_size":240993,"alt_size":879678,"ratio":3.65022220562423} +{"name":"card_game_contract-CardGame::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"card_game_contract-CardGame::public_dispatch","base_size":13560,"alt_size":84048,"ratio":6.198230088495575} +{"name":"card_game_contract-CardGame::start_game","base_size":3907,"alt_size":22724,"ratio":5.8162272843614025} +{"name":"card_game_contract-CardGame::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"card_game_contract-CardGame::view_collection_cards","base_size":19406,"alt_size":145108,"ratio":7.477481191384108} +{"name":"card_game_contract-CardGame::view_game","base_size":18112,"alt_size":134004,"ratio":7.39863074204947} +{"name":"card_game_contract-CardGame::view_game_cards","base_size":19932,"alt_size":148503,"ratio":7.45048163756773} +{"name":"child_contract-Child::private_get_value","base_size":44885,"alt_size":234434,"ratio":5.222992090898964} +{"name":"child_contract-Child::private_set_value","base_size":70713,"alt_size":313838,"ratio":4.4381938257463265} +{"name":"child_contract-Child::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"child_contract-Child::pub_get_value","base_size":304,"alt_size":1460,"ratio":4.802631578947368} +{"name":"child_contract-Child::pub_inc_value","base_size":398,"alt_size":1919,"ratio":4.821608040201005} +{"name":"child_contract-Child::pub_inc_value_internal","base_size":457,"alt_size":2153,"ratio":4.711159737417943} +{"name":"child_contract-Child::pub_set_value","base_size":381,"alt_size":1814,"ratio":4.761154855643045} +{"name":"child_contract-Child::public_dispatch","base_size":2811,"alt_size":17759,"ratio":6.317680540732836} +{"name":"child_contract-Child::set_value_twice_with_nested_first","base_size":838,"alt_size":3939,"ratio":4.700477326968974} +{"name":"child_contract-Child::set_value_twice_with_nested_last","base_size":847,"alt_size":3872,"ratio":4.571428571428571} +{"name":"child_contract-Child::set_value_with_two_nested_calls","base_size":1091,"alt_size":5602,"ratio":5.134738771769019} +{"name":"child_contract-Child::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"child_contract-Child::value","base_size":21817,"alt_size":140742,"ratio":6.451024430489985} +{"name":"child_contract-Child::value_internal","base_size":21771,"alt_size":140708,"ratio":6.463093105507326} +{"name":"claim_contract-Claim::claim","base_size":40666,"alt_size":202301,"ratio":4.974696306496828} +{"name":"claim_contract-Claim::constructor","base_size":3712,"alt_size":22066,"ratio":5.944504310344827} +{"name":"claim_contract-Claim::process_log","base_size":15154,"alt_size":107077,"ratio":7.06592318859707} +{"name":"claim_contract-Claim::public_dispatch","base_size":4175,"alt_size":25485,"ratio":6.104191616766467} +{"name":"claim_contract-Claim::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::assert_class_id_is_registered","base_size":4047,"alt_size":14901,"ratio":3.681986656782802} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_private_function","base_size":20389,"alt_size":70594,"ratio":3.4623571533670114} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_unconstrained_function","base_size":20346,"alt_size":70252,"ratio":3.452865428093974} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::register","base_size":221551,"alt_size":832290,"ratio":3.7566519672671306} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::deploy","base_size":7653,"alt_size":29130,"ratio":3.8063504508036066} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::get_update_delay","base_size":1447,"alt_size":7454,"ratio":5.151347615756738} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::public_dispatch","base_size":8624,"alt_size":59488,"ratio":6.8979591836734695} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::set_update_delay","base_size":4093,"alt_size":28800,"ratio":7.036403615929636} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::update","base_size":4274,"alt_size":29430,"ratio":6.88582124473561} +{"name":"counter_contract-Counter::decrement","base_size":236216,"alt_size":916247,"ratio":3.8788524062722254} +{"name":"counter_contract-Counter::get_counter","base_size":19173,"alt_size":145806,"ratio":7.604756689094039} +{"name":"counter_contract-Counter::increment","base_size":67041,"alt_size":301734,"ratio":4.500738354141496} +{"name":"counter_contract-Counter::increment_and_decrement","base_size":252067,"alt_size":968206,"ratio":3.8410660657682283} +{"name":"counter_contract-Counter::increment_twice","base_size":82288,"alt_size":351593,"ratio":4.272712910752479} +{"name":"counter_contract-Counter::initialize","base_size":72005,"alt_size":316972,"ratio":4.402083188667453} +{"name":"counter_contract-Counter::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"counter_contract-Counter::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"crowdfunding_contract-Crowdfunding::_publish_donation_receipts","base_size":532,"alt_size":2508,"ratio":4.714285714285714} +{"name":"crowdfunding_contract-Crowdfunding::donate","base_size":73181,"alt_size":320957,"ratio":4.385796859840669} +{"name":"crowdfunding_contract-Crowdfunding::init","base_size":3744,"alt_size":22493,"ratio":6.007745726495727} +{"name":"crowdfunding_contract-Crowdfunding::process_log","base_size":15154,"alt_size":107077,"ratio":7.06592318859707} +{"name":"crowdfunding_contract-Crowdfunding::public_dispatch","base_size":4598,"alt_size":28413,"ratio":6.179425837320574} +{"name":"crowdfunding_contract-Crowdfunding::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"crowdfunding_contract-Crowdfunding::withdraw","base_size":29044,"alt_size":163766,"ratio":5.638548409310013} +{"name":"docs_example_contract-DocsExample::get_imm_card","base_size":23407,"alt_size":150042,"ratio":6.410133720681848} +{"name":"docs_example_contract-DocsExample::get_leader","base_size":16639,"alt_size":125039,"ratio":7.5148145922230905} +{"name":"docs_example_contract-DocsExample::get_legendary_card","base_size":18333,"alt_size":139524,"ratio":7.610538373424971} +{"name":"docs_example_contract-DocsExample::get_public_immutable","base_size":16569,"alt_size":125007,"ratio":7.5446315408292595} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private","base_size":28627,"alt_size":166373,"ratio":5.811751144024871} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private_indirect","base_size":22606,"alt_size":146120,"ratio":6.46377068035035} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public","base_size":345,"alt_size":1556,"ratio":4.510144927536232} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_indirect","base_size":782,"alt_size":3744,"ratio":4.78772378516624} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_multiple","base_size":425,"alt_size":2316,"ratio":5.449411764705882} +{"name":"docs_example_contract-DocsExample::increase_legendary_points","base_size":73860,"alt_size":332350,"ratio":4.499729217438397} +{"name":"docs_example_contract-DocsExample::initialize_private","base_size":66697,"alt_size":298994,"ratio":4.482870294016223} +{"name":"docs_example_contract-DocsExample::initialize_private_immutable","base_size":66776,"alt_size":298925,"ratio":4.476533485084461} +{"name":"docs_example_contract-DocsExample::initialize_public_immutable","base_size":1238,"alt_size":6456,"ratio":5.21486268174475} +{"name":"docs_example_contract-DocsExample::insert_note","base_size":66357,"alt_size":298099,"ratio":4.49235197492352} +{"name":"docs_example_contract-DocsExample::insert_notes","base_size":93157,"alt_size":383424,"ratio":4.115890378608156} +{"name":"docs_example_contract-DocsExample::is_legendary_initialized","base_size":17171,"alt_size":127810,"ratio":7.443363811076815} +{"name":"docs_example_contract-DocsExample::is_priv_imm_initialized","base_size":17089,"alt_size":127701,"ratio":7.472701737960091} +{"name":"docs_example_contract-DocsExample::match_public_immutable","base_size":28473,"alt_size":164761,"ratio":5.7865697327292525} +{"name":"docs_example_contract-DocsExample::process_log","base_size":15386,"alt_size":112960,"ratio":7.341739243468088} +{"name":"docs_example_contract-DocsExample::public_dispatch","base_size":3390,"alt_size":18848,"ratio":5.559882005899705} +{"name":"docs_example_contract-DocsExample::read_note","base_size":18509,"alt_size":139287,"ratio":7.525366038143606} +{"name":"docs_example_contract-DocsExample::simple_macro_example","base_size":21701,"alt_size":140703,"ratio":6.4837104280908715} +{"name":"docs_example_contract-DocsExample::simple_macro_example_expanded","base_size":4637,"alt_size":16995,"ratio":3.6650851843864567} +{"name":"docs_example_contract-DocsExample::spend_public_authwit","base_size":197,"alt_size":1095,"ratio":5.558375634517766} +{"name":"docs_example_contract-DocsExample::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"docs_example_contract-DocsExample::update_leader","base_size":347,"alt_size":1577,"ratio":4.544668587896253} +{"name":"docs_example_contract-DocsExample::update_legendary_card","base_size":70434,"alt_size":318790,"ratio":4.526081153988131} +{"name":"docs_example_contract-DocsExample::verify_private_authwit","base_size":21772,"alt_size":140792,"ratio":6.466654418519199} +{"name":"docs_example_contract-DocsExample::view_imm_card","base_size":18266,"alt_size":139101,"ratio":7.615296178692653} +{"name":"easy_private_token_contract-EasyPrivateToken::constructor","base_size":72005,"alt_size":316972,"ratio":4.402083188667453} +{"name":"easy_private_token_contract-EasyPrivateToken::get_balance","base_size":19173,"alt_size":145806,"ratio":7.604756689094039} +{"name":"easy_private_token_contract-EasyPrivateToken::mint","base_size":70565,"alt_size":311891,"ratio":4.419910720612202} +{"name":"easy_private_token_contract-EasyPrivateToken::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"easy_private_token_contract-EasyPrivateToken::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"easy_private_token_contract-EasyPrivateToken::transfer","base_size":276344,"alt_size":1037077,"ratio":3.7528478997191907} +{"name":"easy_private_voting_contract-EasyPrivateVoting::add_to_tally_public","base_size":1886,"alt_size":9931,"ratio":5.265641569459173} +{"name":"easy_private_voting_contract-EasyPrivateVoting::cast_vote","base_size":7884,"alt_size":29468,"ratio":3.7376966007102994} +{"name":"easy_private_voting_contract-EasyPrivateVoting::constructor","base_size":3014,"alt_size":16725,"ratio":5.5491041804910415} +{"name":"easy_private_voting_contract-EasyPrivateVoting::end_vote","base_size":380,"alt_size":1622,"ratio":4.268421052631579} +{"name":"easy_private_voting_contract-EasyPrivateVoting::get_vote","base_size":1245,"alt_size":6151,"ratio":4.940562248995984} +{"name":"easy_private_voting_contract-EasyPrivateVoting::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"easy_private_voting_contract-EasyPrivateVoting::public_dispatch","base_size":4864,"alt_size":29789,"ratio":6.124383223684211} +{"name":"easy_private_voting_contract-EasyPrivateVoting::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::constructor","base_size":76618,"alt_size":335049,"ratio":4.372980239630374} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::entrypoint","base_size":67820,"alt_size":327912,"ratio":4.835033913299911} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::process_log","base_size":17042,"alt_size":123092,"ratio":7.22286116652975} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::verify_private_authwit","base_size":41611,"alt_size":227776,"ratio":5.473937180072577} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::constructor","base_size":76618,"alt_size":335049,"ratio":4.372980239630374} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::entrypoint","base_size":67801,"alt_size":327912,"ratio":4.836388843822363} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::process_log","base_size":17042,"alt_size":123092,"ratio":7.22286116652975} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::verify_private_authwit","base_size":41563,"alt_size":227615,"ratio":5.476385246493275} +{"name":"escrow_contract-Escrow::constructor","base_size":70605,"alt_size":336419,"ratio":4.764804192337653} +{"name":"escrow_contract-Escrow::process_log","base_size":22078,"alt_size":158244,"ratio":7.167497055892744} +{"name":"escrow_contract-Escrow::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"escrow_contract-Escrow::withdraw","base_size":30481,"alt_size":198058,"ratio":6.497752698402284} +{"name":"fee_juice_contract-FeeJuice::_increase_public_balance","base_size":1956,"alt_size":10220,"ratio":5.224948875255624} +{"name":"fee_juice_contract-FeeJuice::balance_of_public","base_size":1239,"alt_size":6209,"ratio":5.011299435028248} +{"name":"fee_juice_contract-FeeJuice::check_balance","base_size":1475,"alt_size":7232,"ratio":4.903050847457627} +{"name":"fee_juice_contract-FeeJuice::claim","base_size":73078,"alt_size":260342,"ratio":3.5625222365144094} +{"name":"fee_juice_contract-FeeJuice::initialize","base_size":5884,"alt_size":24018,"ratio":4.081917063222297} +{"name":"fee_juice_contract-FeeJuice::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"fee_juice_contract-FeeJuice::public_dispatch","base_size":4499,"alt_size":29138,"ratio":6.476550344521005} +{"name":"fee_juice_contract-FeeJuice::set_portal","base_size":1144,"alt_size":5701,"ratio":4.983391608391608} +{"name":"fee_juice_contract-FeeJuice::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"fpc_contract-FPC::complete_refund","base_size":1253,"alt_size":5816,"ratio":4.641660015961692} +{"name":"fpc_contract-FPC::constructor","base_size":3483,"alt_size":19863,"ratio":5.702842377260982} +{"name":"fpc_contract-FPC::fee_entrypoint_private","base_size":29899,"alt_size":171076,"ratio":5.7217967156092175} +{"name":"fpc_contract-FPC::fee_entrypoint_public","base_size":29523,"alt_size":167903,"ratio":5.6871930359380825} +{"name":"fpc_contract-FPC::get_accepted_asset","base_size":28403,"alt_size":159964,"ratio":5.631940287997747} +{"name":"fpc_contract-FPC::pay_refund","base_size":1258,"alt_size":5941,"ratio":4.722575516693164} +{"name":"fpc_contract-FPC::process_log","base_size":15154,"alt_size":107077,"ratio":7.06592318859707} +{"name":"fpc_contract-FPC::public_dispatch","base_size":6737,"alt_size":40442,"ratio":6.002968680421553} +{"name":"fpc_contract-FPC::pull_funds","base_size":1258,"alt_size":6274,"ratio":4.987281399046105} +{"name":"fpc_contract-FPC::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"import_test_contract-ImportTest::call_no_args","base_size":29858,"alt_size":198018,"ratio":6.631991426083462} +{"name":"import_test_contract-ImportTest::call_public_fn","base_size":29440,"alt_size":194463,"ratio":6.605400815217391} +{"name":"import_test_contract-ImportTest::main_contract","base_size":29988,"alt_size":198194,"ratio":6.609110310790983} +{"name":"import_test_contract-ImportTest::process_log","base_size":22935,"alt_size":165186,"ratio":7.202354480052322} +{"name":"import_test_contract-ImportTest::pub_call_public_fn","base_size":676,"alt_size":3268,"ratio":4.834319526627219} +{"name":"import_test_contract-ImportTest::public_dispatch","base_size":1188,"alt_size":6063,"ratio":5.103535353535354} +{"name":"import_test_contract-ImportTest::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"inclusion_proofs_contract-InclusionProofs::constructor","base_size":2437,"alt_size":12955,"ratio":5.315962248666393} +{"name":"inclusion_proofs_contract-InclusionProofs::create_note","base_size":70570,"alt_size":312297,"ratio":4.425350715601531} +{"name":"inclusion_proofs_contract-InclusionProofs::nullify_note","base_size":40457,"alt_size":222954,"ratio":5.510888103418444} +{"name":"inclusion_proofs_contract-InclusionProofs::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"inclusion_proofs_contract-InclusionProofs::public_dispatch","base_size":3234,"alt_size":17711,"ratio":5.476499690785405} +{"name":"inclusion_proofs_contract-InclusionProofs::push_nullifier_public","base_size":309,"alt_size":1406,"ratio":4.550161812297735} +{"name":"inclusion_proofs_contract-InclusionProofs::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_inclusion","base_size":34797,"alt_size":187914,"ratio":5.400293128717993} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_non_inclusion","base_size":38583,"alt_size":202962,"ratio":5.260399657880414} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion","base_size":46853,"alt_size":248475,"ratio":5.303289010308839} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion_fail_case","base_size":31242,"alt_size":178018,"ratio":5.698034696882402} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_not_nullified","base_size":51610,"alt_size":267192,"ratio":5.177136213912033} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_validity","base_size":54893,"alt_size":279805,"ratio":5.097280163226641} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion","base_size":31464,"alt_size":178247,"ratio":5.665109331299263} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion_from_public","base_size":313,"alt_size":1529,"ratio":4.884984025559105} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read","base_size":33536,"alt_size":187655,"ratio":5.595628578244275} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read_unset_slot","base_size":33652,"alt_size":187660,"ratio":5.576488767383811} +{"name":"lending_contract-Lending::_borrow","base_size":7972,"alt_size":44954,"ratio":5.638986452584044} +{"name":"lending_contract-Lending::_deposit","base_size":2084,"alt_size":10402,"ratio":4.991362763915547} +{"name":"lending_contract-Lending::_repay","base_size":5380,"alt_size":29070,"ratio":5.403345724907063} +{"name":"lending_contract-Lending::_withdraw","base_size":7317,"alt_size":40733,"ratio":5.566899002323357} +{"name":"lending_contract-Lending::borrow_private","base_size":22563,"alt_size":138372,"ratio":6.1326951203297435} +{"name":"lending_contract-Lending::borrow_public","base_size":803,"alt_size":3833,"ratio":4.773349937733499} +{"name":"lending_contract-Lending::constructor","base_size":23355,"alt_size":141218,"ratio":6.046585313637337} +{"name":"lending_contract-Lending::deposit_private","base_size":23119,"alt_size":141845,"ratio":6.1354297331199446} +{"name":"lending_contract-Lending::deposit_public","base_size":1111,"alt_size":5979,"ratio":5.3816381638163815} +{"name":"lending_contract-Lending::get_asset","base_size":1671,"alt_size":8397,"ratio":5.025134649910234} +{"name":"lending_contract-Lending::get_assets","base_size":522,"alt_size":2362,"ratio":4.524904214559387} +{"name":"lending_contract-Lending::get_position","base_size":4476,"alt_size":24298,"ratio":5.428507596067917} +{"name":"lending_contract-Lending::init","base_size":1981,"alt_size":10114,"ratio":5.1055022715800105} +{"name":"lending_contract-Lending::process_log","base_size":15154,"alt_size":107077,"ratio":7.06592318859707} +{"name":"lending_contract-Lending::public_dispatch","base_size":30933,"alt_size":195103,"ratio":6.307277018071315} +{"name":"lending_contract-Lending::repay_private","base_size":23019,"alt_size":140479,"ratio":6.102741213779921} +{"name":"lending_contract-Lending::repay_public","base_size":1161,"alt_size":5819,"ratio":5.012058570198105} +{"name":"lending_contract-Lending::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"lending_contract-Lending::update_accumulator","base_size":6404,"alt_size":34223,"ratio":5.344003747657714} +{"name":"lending_contract-Lending::withdraw_private","base_size":22630,"alt_size":138430,"ratio":6.117101193106496} +{"name":"lending_contract-Lending::withdraw_public","base_size":799,"alt_size":3839,"ratio":4.804755944931164} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::entrypoint","base_size":19274,"alt_size":70395,"ratio":3.6523295631420565} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"nft_contract-NFT::_finalize_transfer_to_private_unsafe","base_size":3624,"alt_size":19855,"ratio":5.478752759381899} +{"name":"nft_contract-NFT::_finish_transfer_to_public","base_size":1227,"alt_size":6130,"ratio":4.995925020374898} +{"name":"nft_contract-NFT::_store_payload_in_transient_storage_unsafe","base_size":1225,"alt_size":5871,"ratio":4.79265306122449} +{"name":"nft_contract-NFT::cancel_authwit","base_size":21353,"alt_size":133621,"ratio":6.257715543483351} +{"name":"nft_contract-NFT::constructor","base_size":5808,"alt_size":33062,"ratio":5.692493112947658} +{"name":"nft_contract-NFT::finalize_transfer_to_private","base_size":3569,"alt_size":19640,"ratio":5.502942000560381} +{"name":"nft_contract-NFT::get_admin","base_size":367,"alt_size":1624,"ratio":4.425068119891008} +{"name":"nft_contract-NFT::get_private_nfts","base_size":20357,"alt_size":148533,"ratio":7.296409097607703} +{"name":"nft_contract-NFT::is_minter","base_size":1240,"alt_size":6194,"ratio":4.995161290322581} +{"name":"nft_contract-NFT::mint","base_size":2593,"alt_size":17019,"ratio":6.563440030852295} +{"name":"nft_contract-NFT::owner_of","base_size":1824,"alt_size":9816,"ratio":5.381578947368421} +{"name":"nft_contract-NFT::prepare_private_balance_increase","base_size":66800,"alt_size":292157,"ratio":4.373607784431138} +{"name":"nft_contract-NFT::private_get_name","base_size":28334,"alt_size":159523,"ratio":5.630091056681019} +{"name":"nft_contract-NFT::private_get_symbol","base_size":28195,"alt_size":159548,"ratio":5.658733818052847} +{"name":"nft_contract-NFT::process_log","base_size":15100,"alt_size":106448,"ratio":7.04953642384106} +{"name":"nft_contract-NFT::public_dispatch","base_size":20666,"alt_size":149527,"ratio":7.235410819703861} +{"name":"nft_contract-NFT::public_get_name","base_size":375,"alt_size":1620,"ratio":4.32} +{"name":"nft_contract-NFT::public_get_symbol","base_size":347,"alt_size":1593,"ratio":4.590778097982709} +{"name":"nft_contract-NFT::set_admin","base_size":376,"alt_size":1702,"ratio":4.526595744680851} +{"name":"nft_contract-NFT::set_minter","base_size":1251,"alt_size":6255,"ratio":5} +{"name":"nft_contract-NFT::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"nft_contract-NFT::transfer_in_private","base_size":99147,"alt_size":415691,"ratio":4.19267350499763} +{"name":"nft_contract-NFT::transfer_in_public","base_size":3849,"alt_size":21443,"ratio":5.571057417511041} +{"name":"nft_contract-NFT::transfer_to_private","base_size":66805,"alt_size":292396,"ratio":4.376858019609311} +{"name":"nft_contract-NFT::transfer_to_public","base_size":50556,"alt_size":252027,"ratio":4.985105625445051} +{"name":"parent_contract-Parent::enqueue_call_to_child","base_size":22160,"alt_size":142182,"ratio":6.416155234657039} +{"name":"parent_contract-Parent::enqueue_call_to_child_twice","base_size":22174,"alt_size":142630,"ratio":6.432308108595652} +{"name":"parent_contract-Parent::enqueue_call_to_pub_entry_point","base_size":22158,"alt_size":142003,"ratio":6.40865601588591} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_first","base_size":22477,"alt_size":145692,"ratio":6.481825866441251} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_last","base_size":22445,"alt_size":145486,"ratio":6.481889062151927} +{"name":"parent_contract-Parent::enqueue_calls_to_pub_entry_point","base_size":22052,"alt_size":142335,"ratio":6.454516597134047} +{"name":"parent_contract-Parent::enqueue_static_call_to_pub_function","base_size":22152,"alt_size":141995,"ratio":6.410030697002528} +{"name":"parent_contract-Parent::enqueue_static_nested_call_to_pub_function","base_size":22013,"alt_size":142017,"ratio":6.451505928315086} +{"name":"parent_contract-Parent::entry_point","base_size":22420,"alt_size":143901,"ratio":6.418421052631579} +{"name":"parent_contract-Parent::private_call","base_size":22488,"alt_size":146005,"ratio":6.492573817146923} +{"name":"parent_contract-Parent::private_nested_static_call","base_size":22472,"alt_size":145493,"ratio":6.474412602349591} +{"name":"parent_contract-Parent::private_static_call","base_size":22390,"alt_size":145873,"ratio":6.515096025011165} +{"name":"parent_contract-Parent::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"parent_contract-Parent::pub_entry_point","base_size":747,"alt_size":3534,"ratio":4.730923694779117} +{"name":"parent_contract-Parent::pub_entry_point_twice","base_size":1033,"alt_size":5329,"ratio":5.158760890609874} +{"name":"parent_contract-Parent::public_dispatch","base_size":4099,"alt_size":28079,"ratio":6.850207367650646} +{"name":"parent_contract-Parent::public_nested_static_call","base_size":2701,"alt_size":14582,"ratio":5.398741206960385} +{"name":"parent_contract-Parent::public_static_call","base_size":1189,"alt_size":5564,"ratio":4.679562657695542} +{"name":"parent_contract-Parent::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"pending_note_hashes_contract-PendingNoteHashes::dummy","base_size":21375,"alt_size":138808,"ratio":6.493941520467836} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_note_zero_balance","base_size":57201,"alt_size":279403,"ratio":4.884582437369976} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_then_nullify_note","base_size":40632,"alt_size":224557,"ratio":5.526604646583973} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note","base_size":70652,"alt_size":312624,"ratio":4.424842891920965} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_extra_emit","base_size":81793,"alt_size":346816,"ratio":4.240167251476287} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_static_randomness","base_size":66696,"alt_size":298592,"ratio":4.476910159529807} +{"name":"pending_note_hashes_contract-PendingNoteHashes::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"pending_note_hashes_contract-PendingNoteHashes::recursively_destroy_and_create_notes","base_size":432377,"alt_size":1513697,"ratio":3.500873080668028} +{"name":"pending_note_hashes_contract-PendingNoteHashes::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_bad_get_then_insert_flat","base_size":90538,"alt_size":426365,"ratio":4.709238109964876} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_emit_bad_note_log","base_size":81631,"alt_size":346771,"ratio":4.248030772623146} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert1_then_get2_then_nullify2_all_in_nested_calls","base_size":22403,"alt_size":145143,"ratio":6.478730527161541} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify1_all_in_nested_calls","base_size":22389,"alt_size":144996,"ratio":6.476215998928045} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify2_all_in_nested_calls","base_size":22602,"alt_size":145318,"ratio":6.429431023803203} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_all_in_nested_calls","base_size":22406,"alt_size":144801,"ratio":6.462599303757922} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_flat","base_size":234489,"alt_size":913218,"ratio":3.8945025139772014} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_recursively_create_notes","base_size":299554,"alt_size":1046846,"ratio":3.4946820940464822} +{"name":"price_feed_contract-PriceFeed::get_price","base_size":1236,"alt_size":6229,"ratio":5.039644012944984} +{"name":"price_feed_contract-PriceFeed::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"price_feed_contract-PriceFeed::public_dispatch","base_size":2484,"alt_size":13805,"ratio":5.55756843800322} +{"name":"price_feed_contract-PriceFeed::set_price","base_size":1151,"alt_size":5823,"ratio":5.059079061685491} +{"name":"price_feed_contract-PriceFeed::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"router_contract-Router::_check_block_number","base_size":995,"alt_size":4873,"ratio":4.89748743718593} +{"name":"router_contract-Router::_check_timestamp","base_size":1030,"alt_size":4953,"ratio":4.80873786407767} +{"name":"router_contract-Router::check_block_number","base_size":4928,"alt_size":18242,"ratio":3.7017045454545454} +{"name":"router_contract-Router::check_timestamp","base_size":4944,"alt_size":18302,"ratio":3.7018608414239482} +{"name":"router_contract-Router::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"router_contract-Router::public_dispatch","base_size":2001,"alt_size":10187,"ratio":5.090954522738631} +{"name":"router_contract-Router::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"schnorr_account_contract-SchnorrAccount::constructor","base_size":64119,"alt_size":289672,"ratio":4.517724855347089} +{"name":"schnorr_account_contract-SchnorrAccount::entrypoint","base_size":67390,"alt_size":308736,"ratio":4.581332541920166} +{"name":"schnorr_account_contract-SchnorrAccount::lookup_validity","base_size":24045,"alt_size":175192,"ratio":7.286005406529424} +{"name":"schnorr_account_contract-SchnorrAccount::process_log","base_size":15457,"alt_size":112883,"ratio":7.303034223976192} +{"name":"schnorr_account_contract-SchnorrAccount::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"schnorr_account_contract-SchnorrAccount::verify_private_authwit","base_size":41146,"alt_size":208068,"ratio":5.0568220483157535} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::entrypoint","base_size":49331,"alt_size":173401,"ratio":3.515051387565628} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::verify_private_authwit","base_size":22056,"alt_size":75900,"ratio":3.441240478781284} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::entrypoint","base_size":45825,"alt_size":160633,"ratio":3.505357337697763} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::process_log","base_size":1279,"alt_size":6085,"ratio":4.757623143080532} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::verify_private_authwit","base_size":18615,"alt_size":63474,"ratio":3.40983078162772} +{"name":"spam_contract-Spam::process_log","base_size":22044,"alt_size":164633,"ratio":7.468381418980221} +{"name":"spam_contract-Spam::public_dispatch","base_size":2421,"alt_size":13024,"ratio":5.379595208591491} +{"name":"spam_contract-Spam::public_spam","base_size":1899,"alt_size":10133,"ratio":5.3359662980516065} +{"name":"spam_contract-Spam::spam","base_size":96835,"alt_size":594958,"ratio":6.144038828935819} +{"name":"spam_contract-Spam::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"stateful_test_contract-StatefulTest::constructor","base_size":24200,"alt_size":149601,"ratio":6.181859504132231} +{"name":"stateful_test_contract-StatefulTest::create_note","base_size":72583,"alt_size":319048,"ratio":4.395629830676604} +{"name":"stateful_test_contract-StatefulTest::create_note_no_init_check","base_size":72641,"alt_size":318720,"ratio":4.38760479618948} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create","base_size":452799,"alt_size":1563638,"ratio":3.453271760759189} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create_no_init_check","base_size":452957,"alt_size":1563070,"ratio":3.4508132118501313} +{"name":"stateful_test_contract-StatefulTest::get_public_value","base_size":1166,"alt_size":5833,"ratio":5.002572898799314} +{"name":"stateful_test_contract-StatefulTest::increment_public_value","base_size":1203,"alt_size":6005,"ratio":4.991687448046551} +{"name":"stateful_test_contract-StatefulTest::increment_public_value_no_init_check","base_size":1112,"alt_size":5740,"ratio":5.161870503597123} +{"name":"stateful_test_contract-StatefulTest::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"stateful_test_contract-StatefulTest::public_constructor","base_size":3363,"alt_size":17892,"ratio":5.320249776984835} +{"name":"stateful_test_contract-StatefulTest::public_dispatch","base_size":5887,"alt_size":36058,"ratio":6.125021233225752} +{"name":"stateful_test_contract-StatefulTest::summed_values","base_size":19173,"alt_size":145806,"ratio":7.604756689094039} +{"name":"stateful_test_contract-StatefulTest::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"stateful_test_contract-StatefulTest::wrong_constructor","base_size":24134,"alt_size":148945,"ratio":6.171583657910002} +{"name":"static_child_contract-StaticChild::private_get_value","base_size":51394,"alt_size":254991,"ratio":4.961493559559481} +{"name":"static_child_contract-StaticChild::private_illegal_set_value","base_size":66648,"alt_size":299512,"ratio":4.493938302724763} +{"name":"static_child_contract-StaticChild::private_set_value","base_size":66805,"alt_size":299889,"ratio":4.489020282912955} +{"name":"static_child_contract-StaticChild::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"static_child_contract-StaticChild::pub_get_value","base_size":368,"alt_size":1657,"ratio":4.502717391304348} +{"name":"static_child_contract-StaticChild::pub_illegal_inc_value","base_size":452,"alt_size":2096,"ratio":4.6371681415929205} +{"name":"static_child_contract-StaticChild::pub_inc_value","base_size":398,"alt_size":1919,"ratio":4.821608040201005} +{"name":"static_child_contract-StaticChild::pub_set_value","base_size":381,"alt_size":1814,"ratio":4.761154855643045} +{"name":"static_child_contract-StaticChild::public_dispatch","base_size":1389,"alt_size":8568,"ratio":6.168466522678186} +{"name":"static_child_contract-StaticChild::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"static_parent_contract-StaticParent::enqueue_call","base_size":22046,"alt_size":142214,"ratio":6.450784722852218} +{"name":"static_parent_contract-StaticParent::enqueue_public_get_value_from_child","base_size":22073,"alt_size":141962,"ratio":6.431477370543198} +{"name":"static_parent_contract-StaticParent::enqueue_static_call_to_pub_function","base_size":22152,"alt_size":141995,"ratio":6.410030697002528} +{"name":"static_parent_contract-StaticParent::enqueue_static_nested_call_to_pub_function","base_size":22057,"alt_size":141937,"ratio":6.435009294101646} +{"name":"static_parent_contract-StaticParent::private_call","base_size":22488,"alt_size":146005,"ratio":6.492573817146923} +{"name":"static_parent_contract-StaticParent::private_call_3_args","base_size":22508,"alt_size":145933,"ratio":6.483605829038564} +{"name":"static_parent_contract-StaticParent::private_get_value_from_child","base_size":22453,"alt_size":145423,"ratio":6.4767737050728185} +{"name":"static_parent_contract-StaticParent::private_nested_static_call","base_size":22442,"alt_size":145662,"ratio":6.490597985919258} +{"name":"static_parent_contract-StaticParent::private_nested_static_call_3_args","base_size":22492,"alt_size":145369,"ratio":6.463142450649119} +{"name":"static_parent_contract-StaticParent::private_static_call","base_size":22390,"alt_size":145873,"ratio":6.515096025011165} +{"name":"static_parent_contract-StaticParent::private_static_call_3_args","base_size":22512,"alt_size":145605,"ratio":6.467883795309168} +{"name":"static_parent_contract-StaticParent::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"static_parent_contract-StaticParent::public_call","base_size":747,"alt_size":3534,"ratio":4.730923694779117} +{"name":"static_parent_contract-StaticParent::public_dispatch","base_size":2221,"alt_size":15313,"ratio":6.894642053129221} +{"name":"static_parent_contract-StaticParent::public_get_value_from_child","base_size":729,"alt_size":3466,"ratio":4.7544581618655695} +{"name":"static_parent_contract-StaticParent::public_nested_static_call","base_size":947,"alt_size":4303,"ratio":4.543822597676875} +{"name":"static_parent_contract-StaticParent::public_static_call","base_size":1189,"alt_size":5564,"ratio":4.679562657695542} +{"name":"static_parent_contract-StaticParent::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"test_contract-Test::assert_header_private","base_size":29354,"alt_size":192143,"ratio":6.545717789739047} +{"name":"test_contract-Test::assert_private_global_vars","base_size":28839,"alt_size":190958,"ratio":6.6215194701619335} +{"name":"test_contract-Test::assert_public_global_vars","base_size":529,"alt_size":2334,"ratio":4.4120982986767485} +{"name":"test_contract-Test::call_create_note","base_size":78135,"alt_size":366702,"ratio":4.6931848723363405} +{"name":"test_contract-Test::call_destroy_note","base_size":71911,"alt_size":368526,"ratio":5.12475142884955} +{"name":"test_contract-Test::call_get_notes","base_size":64935,"alt_size":335103,"ratio":5.1605913605913605} +{"name":"test_contract-Test::call_get_notes_many","base_size":64853,"alt_size":335103,"ratio":5.167116401708479} +{"name":"test_contract-Test::call_view_notes","base_size":25750,"alt_size":191461,"ratio":7.435378640776699} +{"name":"test_contract-Test::call_view_notes_many","base_size":25844,"alt_size":191930,"ratio":7.42648196873549} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_private","base_size":77083,"alt_size":362459,"ratio":4.702191144610355} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_public","base_size":5303,"alt_size":33165,"ratio":6.254007165755233} +{"name":"test_contract-Test::consume_mint_to_private_message","base_size":84273,"alt_size":390879,"ratio":4.638247125413834} +{"name":"test_contract-Test::consume_mint_to_public_message","base_size":7825,"alt_size":51409,"ratio":6.569840255591054} +{"name":"test_contract-Test::consume_note_from_secret","base_size":49918,"alt_size":278442,"ratio":5.5779879001562565} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_private","base_size":29025,"alt_size":191117,"ratio":6.584565030146425} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_public","base_size":244,"alt_size":1180,"ratio":4.836065573770492} +{"name":"test_contract-Test::create_l2_to_l1_message_public","base_size":1850,"alt_size":8320,"ratio":4.4972972972972975} +{"name":"test_contract-Test::deliver_note","base_size":43379,"alt_size":323762,"ratio":7.463565319624704} +{"name":"test_contract-Test::deploy_contract","base_size":31740,"alt_size":203146,"ratio":6.400315059861374} +{"name":"test_contract-Test::dummy_public_call","base_size":251,"alt_size":1172,"ratio":4.669322709163347} +{"name":"test_contract-Test::emit_array_as_encrypted_log","base_size":51594,"alt_size":353051,"ratio":6.842869325890607} +{"name":"test_contract-Test::emit_encrypted_logs_nested","base_size":74678,"alt_size":356060,"ratio":4.767937009561049} +{"name":"test_contract-Test::emit_nullifier","base_size":29025,"alt_size":191829,"ratio":6.609095607235142} +{"name":"test_contract-Test::emit_nullifier_public","base_size":216,"alt_size":1107,"ratio":5.125} +{"name":"test_contract-Test::emit_public","base_size":1104,"alt_size":5895,"ratio":5.3396739130434785} +{"name":"test_contract-Test::get_constant","base_size":25065,"alt_size":186667,"ratio":7.447316975862757} +{"name":"test_contract-Test::get_master_incoming_viewing_public_key","base_size":30981,"alt_size":201550,"ratio":6.505600206578225} +{"name":"test_contract-Test::get_ovsk_app","base_size":29812,"alt_size":195888,"ratio":6.570776868375151} +{"name":"test_contract-Test::get_this_address","base_size":29123,"alt_size":193161,"ratio":6.632592796071833} +{"name":"test_contract-Test::is_time_equal","base_size":263,"alt_size":1291,"ratio":4.908745247148289} +{"name":"test_contract-Test::process_log","base_size":22905,"alt_size":165244,"ratio":7.214320017463436} +{"name":"test_contract-Test::public_dispatch","base_size":15580,"alt_size":102750,"ratio":6.594993581514762} +{"name":"test_contract-Test::set_constant","base_size":30295,"alt_size":198574,"ratio":6.554678989932332} +{"name":"test_contract-Test::set_tx_max_block_number","base_size":29406,"alt_size":194509,"ratio":6.614602462082568} +{"name":"test_contract-Test::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"test_contract-Test::test_code_gen","base_size":29600,"alt_size":194071,"ratio":6.556452702702702} +{"name":"test_contract-Test::test_nullifier_key_freshness","base_size":30878,"alt_size":200155,"ratio":6.482123194507416} +{"name":"test_contract-Test::test_setting_fee_payer","base_size":29431,"alt_size":194473,"ratio":6.607760524616901} +{"name":"test_contract-Test::test_setting_teardown","base_size":29376,"alt_size":193868,"ratio":6.599537037037037} +{"name":"test_log_contract-TestLog::emit_encrypted_events","base_size":100662,"alt_size":399523,"ratio":3.9689555144940494} +{"name":"test_log_contract-TestLog::emit_unencrypted_events","base_size":663,"alt_size":3515,"ratio":5.301659125188537} +{"name":"test_log_contract-TestLog::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"test_log_contract-TestLog::public_dispatch","base_size":1499,"alt_size":7931,"ratio":5.29086057371581} +{"name":"test_log_contract-TestLog::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"token_blacklist_contract-TokenBlacklist::_increase_public_balance","base_size":2037,"alt_size":10679,"ratio":5.242513500245459} +{"name":"token_blacklist_contract-TokenBlacklist::_reduce_total_supply","base_size":590,"alt_size":2767,"ratio":4.689830508474576} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_private","base_size":24248,"alt_size":187785,"ratio":7.7443500494886175} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_public","base_size":1312,"alt_size":6481,"ratio":4.939786585365853} +{"name":"token_blacklist_contract-TokenBlacklist::burn","base_size":252437,"alt_size":949051,"ratio":3.7595558495783106} +{"name":"token_blacklist_contract-TokenBlacklist::burn_public","base_size":5624,"alt_size":34065,"ratio":6.057076813655761} +{"name":"token_blacklist_contract-TokenBlacklist::constructor","base_size":5720,"alt_size":41403,"ratio":7.238286713286714} +{"name":"token_blacklist_contract-TokenBlacklist::deliver_transparent_note","base_size":37047,"alt_size":288538,"ratio":7.7884309120846495} +{"name":"token_blacklist_contract-TokenBlacklist::get_roles","base_size":1691,"alt_size":8564,"ratio":5.064458900059137} +{"name":"token_blacklist_contract-TokenBlacklist::mint_private","base_size":2880,"alt_size":15268,"ratio":5.301388888888889} +{"name":"token_blacklist_contract-TokenBlacklist::mint_public","base_size":3750,"alt_size":22810,"ratio":6.082666666666666} +{"name":"token_blacklist_contract-TokenBlacklist::process_log","base_size":18615,"alt_size":141221,"ratio":7.586408810099382} +{"name":"token_blacklist_contract-TokenBlacklist::public_dispatch","base_size":48080,"alt_size":421824,"ratio":8.773377703826956} +{"name":"token_blacklist_contract-TokenBlacklist::redeem_shield","base_size":112463,"alt_size":482139,"ratio":4.287089976258859} +{"name":"token_blacklist_contract-TokenBlacklist::shield","base_size":6609,"alt_size":39974,"ratio":6.0484188228173705} +{"name":"token_blacklist_contract-TokenBlacklist::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"token_blacklist_contract-TokenBlacklist::total_supply","base_size":451,"alt_size":2044,"ratio":4.532150776053215} +{"name":"token_blacklist_contract-TokenBlacklist::transfer","base_size":241705,"alt_size":1012275,"ratio":4.188059824993277} +{"name":"token_blacklist_contract-TokenBlacklist::transfer_public","base_size":7362,"alt_size":48020,"ratio":6.5226840532464} +{"name":"token_blacklist_contract-TokenBlacklist::unshield","base_size":260032,"alt_size":971997,"ratio":3.7379899396997294} +{"name":"token_blacklist_contract-TokenBlacklist::update_roles","base_size":5230,"alt_size":36899,"ratio":7.055258126195029} +{"name":"token_bridge_contract-TokenBridge::claim_private","base_size":83713,"alt_size":359546,"ratio":4.2949840526560985} +{"name":"token_bridge_contract-TokenBridge::claim_public","base_size":8518,"alt_size":54296,"ratio":6.374266259685372} +{"name":"token_bridge_contract-TokenBridge::constructor","base_size":3483,"alt_size":19863,"ratio":5.702842377260982} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_private","base_size":49544,"alt_size":237567,"ratio":4.7950710479573715} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_public","base_size":3948,"alt_size":26307,"ratio":6.663373860182371} +{"name":"token_bridge_contract-TokenBridge::get_config","base_size":28402,"alt_size":160264,"ratio":5.642701218224069} +{"name":"token_bridge_contract-TokenBridge::get_config_public","base_size":428,"alt_size":1907,"ratio":4.455607476635514} +{"name":"token_bridge_contract-TokenBridge::process_log","base_size":15154,"alt_size":107077,"ratio":7.06592318859707} +{"name":"token_bridge_contract-TokenBridge::public_dispatch","base_size":15017,"alt_size":103345,"ratio":6.881867217153892} +{"name":"token_bridge_contract-TokenBridge::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"token_contract-Token::_finalize_mint_to_private_unsafe","base_size":3726,"alt_size":20687,"ratio":5.552066559312936} +{"name":"token_contract-Token::_finalize_transfer_to_private_unsafe","base_size":4227,"alt_size":24076,"ratio":5.695765318192572} +{"name":"token_contract-Token::_increase_public_balance","base_size":2009,"alt_size":10470,"ratio":5.211548033847685} +{"name":"token_contract-Token::_recurse_subtract_balance","base_size":110226,"alt_size":492342,"ratio":4.466659408850906} +{"name":"token_contract-Token::_reduce_total_supply","base_size":559,"alt_size":2623,"ratio":4.6923076923076925} +{"name":"token_contract-Token::_store_payload_in_transient_storage_unsafe","base_size":1225,"alt_size":5871,"ratio":4.79265306122449} +{"name":"token_contract-Token::balance_of_private","base_size":19316,"alt_size":143147,"ratio":7.410799337336923} +{"name":"token_contract-Token::balance_of_public","base_size":1320,"alt_size":6438,"ratio":4.877272727272727} +{"name":"token_contract-Token::burn_private","base_size":232328,"alt_size":895936,"ratio":3.8563410350883234} +{"name":"token_contract-Token::burn_public","base_size":4353,"alt_size":26807,"ratio":6.158281644842638} +{"name":"token_contract-Token::cancel_authwit","base_size":21426,"alt_size":133832,"ratio":6.246242882479231} +{"name":"token_contract-Token::constructor","base_size":6193,"alt_size":36883,"ratio":5.9555950266429845} +{"name":"token_contract-Token::finalize_mint_to_private","base_size":3676,"alt_size":20552,"ratio":5.590859630032644} +{"name":"token_contract-Token::finalize_transfer_to_private","base_size":4168,"alt_size":23904,"ratio":5.735124760076776} +{"name":"token_contract-Token::get_admin","base_size":357,"alt_size":1592,"ratio":4.459383753501401} +{"name":"token_contract-Token::is_minter","base_size":1245,"alt_size":6194,"ratio":4.975100401606426} +{"name":"token_contract-Token::mint_to_private","base_size":67137,"alt_size":293348,"ratio":4.369393925853107} +{"name":"token_contract-Token::mint_to_public","base_size":2621,"alt_size":14580,"ratio":5.562762304463945} +{"name":"token_contract-Token::prepare_private_balance_increase","base_size":66967,"alt_size":292346,"ratio":4.3655233174548655} +{"name":"token_contract-Token::private_get_decimals","base_size":28406,"alt_size":159961,"ratio":5.631239878898824} +{"name":"token_contract-Token::private_get_name","base_size":28380,"alt_size":159773,"ratio":5.629774489076815} +{"name":"token_contract-Token::private_get_symbol","base_size":28357,"alt_size":160008,"ratio":5.642627922558804} +{"name":"token_contract-Token::process_log","base_size":15154,"alt_size":107077,"ratio":7.06592318859707} +{"name":"token_contract-Token::public_dispatch","base_size":32221,"alt_size":241835,"ratio":7.505508829645263} +{"name":"token_contract-Token::public_get_decimals","base_size":384,"alt_size":1712,"ratio":4.458333333333333} +{"name":"token_contract-Token::public_get_name","base_size":374,"alt_size":1634,"ratio":4.3689839572192515} +{"name":"token_contract-Token::public_get_symbol","base_size":361,"alt_size":1650,"ratio":4.570637119113574} +{"name":"token_contract-Token::set_admin","base_size":386,"alt_size":1702,"ratio":4.409326424870466} +{"name":"token_contract-Token::set_minter","base_size":1255,"alt_size":6237,"ratio":4.9697211155378485} +{"name":"token_contract-Token::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"token_contract-Token::total_supply","base_size":455,"alt_size":2001,"ratio":4.397802197802198} +{"name":"token_contract-Token::transfer","base_size":116065,"alt_size":713305,"ratio":6.14573730237367} +{"name":"token_contract-Token::transfer_in_private","base_size":288372,"alt_size":1087851,"ratio":3.7723877491573385} +{"name":"token_contract-Token::transfer_in_public","base_size":5501,"alt_size":35240,"ratio":6.406107980367206} +{"name":"token_contract-Token::transfer_to_private","base_size":67108,"alt_size":293213,"ratio":4.369270429755022} +{"name":"token_contract-Token::transfer_to_public","base_size":232245,"alt_size":897229,"ratio":3.8632866154276733} +{"name":"uniswap_contract-Uniswap::_approve_bridge_and_exit_input_asset_to_L1","base_size":5800,"alt_size":35065,"ratio":6.0456896551724135} +{"name":"uniswap_contract-Uniswap::constructor","base_size":2954,"alt_size":16495,"ratio":5.583953960731212} +{"name":"uniswap_contract-Uniswap::process_log","base_size":15154,"alt_size":107077,"ratio":7.06592318859707} +{"name":"uniswap_contract-Uniswap::public_dispatch","base_size":16599,"alt_size":115643,"ratio":6.966865473823725} +{"name":"uniswap_contract-Uniswap::swap_private","base_size":73247,"alt_size":325309,"ratio":4.441260392917116} +{"name":"uniswap_contract-Uniswap::swap_public","base_size":8226,"alt_size":61125,"ratio":7.430707512764405} +{"name":"uniswap_contract-Uniswap::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"updatable_contract-Updatable::get_private_value","base_size":18282,"alt_size":138313,"ratio":7.565528935565037} +{"name":"updatable_contract-Updatable::get_public_value","base_size":16531,"alt_size":124093,"ratio":7.506684411106406} +{"name":"updatable_contract-Updatable::get_update_delay","base_size":791,"alt_size":3656,"ratio":4.621997471554994} +{"name":"updatable_contract-Updatable::initialize","base_size":68664,"alt_size":306461,"ratio":4.463197599906793} +{"name":"updatable_contract-Updatable::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"updatable_contract-Updatable::public_dispatch","base_size":1384,"alt_size":7281,"ratio":5.260838150289017} +{"name":"updatable_contract-Updatable::set_public_value","base_size":327,"alt_size":1459,"ratio":4.461773700305811} +{"name":"updatable_contract-Updatable::set_update_delay","base_size":21906,"alt_size":141940,"ratio":6.479503332420341} +{"name":"updatable_contract-Updatable::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} +{"name":"updatable_contract-Updatable::update_to","base_size":21930,"alt_size":141900,"ratio":6.470588235294118} +{"name":"updated_contract-Updated::get_private_value","base_size":18282,"alt_size":138313,"ratio":7.565528935565037} +{"name":"updated_contract-Updated::get_public_value","base_size":16531,"alt_size":124093,"ratio":7.506684411106406} +{"name":"updated_contract-Updated::get_update_delay","base_size":702,"alt_size":3370,"ratio":4.800569800569801} +{"name":"updated_contract-Updated::process_log","base_size":15373,"alt_size":112936,"ratio":7.346386521823977} +{"name":"updated_contract-Updated::public_dispatch","base_size":1255,"alt_size":6571,"ratio":5.235856573705179} +{"name":"updated_contract-Updated::set_private_value","base_size":65966,"alt_size":301812,"ratio":4.575266046144984} +{"name":"updated_contract-Updated::set_public_value","base_size":231,"alt_size":1071,"ratio":4.636363636363637} +{"name":"updated_contract-Updated::sync_notes","base_size":194,"alt_size":965,"ratio":4.974226804123711} diff --git a/scripts/bytecode-sizes/bincode-vs-flexbuffers.png b/scripts/bytecode-sizes/bincode-vs-flexbuffers.png new file mode 100644 index 00000000000..e538ddce454 Binary files /dev/null and b/scripts/bytecode-sizes/bincode-vs-flexbuffers.png differ diff --git a/scripts/bytecode-sizes/bincode-vs-protobuf.jsonl b/scripts/bytecode-sizes/bincode-vs-protobuf.jsonl new file mode 100644 index 00000000000..f2bed3e08f5 --- /dev/null +++ b/scripts/bytecode-sizes/bincode-vs-protobuf.jsonl @@ -0,0 +1,645 @@ +{"name":"parity_base","base_size":38512,"alt_size":35233,"ratio":0.9148577066888243} +{"name":"parity_root","base_size":56652,"alt_size":53444,"ratio":0.9433735790439879} +{"name":"private_kernel_init","base_size":220749,"alt_size":202567,"ratio":0.9176349609737756} +{"name":"private_kernel_init_simulated","base_size":58621,"alt_size":57905,"ratio":0.9877859470155747} +{"name":"private_kernel_inner","base_size":359771,"alt_size":332017,"ratio":0.9228564837076918} +{"name":"private_kernel_inner_simulated","base_size":85524,"alt_size":82266,"ratio":0.9619054300547215} +{"name":"private_kernel_reset","base_size":900112,"alt_size":842107,"ratio":0.9355580194464689} +{"name":"private_kernel_reset_simulated","base_size":109029,"alt_size":96108,"ratio":0.8814902457144429} +{"name":"private_kernel_tail","base_size":119498,"alt_size":110310,"ratio":0.9231116838775545} +{"name":"private_kernel_tail_simulated","base_size":47093,"alt_size":43124,"ratio":0.9157199583802264} +{"name":"private_kernel_tail_to_public","base_size":213327,"alt_size":198582,"ratio":0.9308807605225781} +{"name":"private_kernel_tail_to_public_simulated","base_size":68973,"alt_size":64261,"ratio":0.93168341234976} +{"name":"rollup_base_private","base_size":1357393,"alt_size":1257801,"ratio":0.9266299443123693} +{"name":"rollup_base_private_simulated","base_size":81131,"alt_size":72339,"ratio":0.891632051866734} +{"name":"rollup_base_public","base_size":679496,"alt_size":626991,"ratio":0.9227294936246865} +{"name":"rollup_base_public_simulated","base_size":76651,"alt_size":67776,"ratio":0.8842154701178067} +{"name":"rollup_block_merge","base_size":109324,"alt_size":99872,"ratio":0.9135413998755991} +{"name":"rollup_block_root","base_size":15014428,"alt_size":12803649,"ratio":0.8527563620805269} +{"name":"rollup_block_root_empty","base_size":20689,"alt_size":20129,"ratio":0.9729324761950795} +{"name":"rollup_block_root_simulated","base_size":80510,"alt_size":72709,"ratio":0.9031052043224445} +{"name":"rollup_block_root_single_tx","base_size":14998279,"alt_size":12778106,"ratio":0.851971482861467} +{"name":"rollup_block_root_single_tx_simulated","base_size":75036,"alt_size":67606,"ratio":0.9009808625193241} +{"name":"rollup_merge","base_size":29269,"alt_size":27780,"ratio":0.9491270627626499} +{"name":"rollup_root","base_size":109168,"alt_size":99621,"ratio":0.912547633006009} +{"name":"amm_contract-AMM::_add_liquidity","base_size":7625,"alt_size":6831,"ratio":0.8958688524590164} +{"name":"amm_contract-AMM::_remove_liquidity","base_size":4889,"alt_size":4342,"ratio":0.888116179177746} +{"name":"amm_contract-AMM::_swap_exact_tokens_for_tokens","base_size":3868,"alt_size":3499,"ratio":0.9046018614270941} +{"name":"amm_contract-AMM::_swap_tokens_for_exact_tokens","base_size":4286,"alt_size":3855,"ratio":0.8994400373308447} +{"name":"amm_contract-AMM::add_liquidity","base_size":31680,"alt_size":28782,"ratio":0.9085227272727273} +{"name":"amm_contract-AMM::constructor","base_size":3706,"alt_size":3180,"ratio":0.8580679978413384} +{"name":"amm_contract-AMM::get_amount_in_for_exact_out","base_size":18139,"alt_size":15641,"ratio":0.8622856827829538} +{"name":"amm_contract-AMM::get_amount_out_for_exact_in","base_size":18109,"alt_size":15625,"ratio":0.8628306366999834} +{"name":"amm_contract-AMM::process_log","base_size":14990,"alt_size":12646,"ratio":0.8436290860573716} +{"name":"amm_contract-AMM::public_dispatch","base_size":20783,"alt_size":17230,"ratio":0.8290429678102296} +{"name":"amm_contract-AMM::remove_liquidity","base_size":29548,"alt_size":26900,"ratio":0.91038310545553} +{"name":"amm_contract-AMM::swap_exact_tokens_for_tokens","base_size":29442,"alt_size":26805,"ratio":0.9104340737721622} +{"name":"amm_contract-AMM::swap_tokens_for_exact_tokens","base_size":29711,"alt_size":27068,"ratio":0.9110430480293494} +{"name":"amm_contract-AMM::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"app_subscription_contract-AppSubscription::constructor","base_size":4391,"alt_size":3803,"ratio":0.8660897289911182} +{"name":"app_subscription_contract-AppSubscription::entrypoint","base_size":97890,"alt_size":89119,"ratio":0.9103994279293084} +{"name":"app_subscription_contract-AppSubscription::is_initialized","base_size":23855,"alt_size":19950,"ratio":0.836302661915741} +{"name":"app_subscription_contract-AppSubscription::process_log","base_size":21713,"alt_size":17982,"ratio":0.8281674572836549} +{"name":"app_subscription_contract-AppSubscription::public_dispatch","base_size":4867,"alt_size":4193,"ratio":0.8615163344976371} +{"name":"app_subscription_contract-AppSubscription::subscribe","base_size":94665,"alt_size":85415,"ratio":0.9022870120952834} +{"name":"app_subscription_contract-AppSubscription::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"auth_contract-Auth::constructor","base_size":2999,"alt_size":2606,"ratio":0.8689563187729243} +{"name":"auth_contract-Auth::do_private_authorized_thing","base_size":12981,"alt_size":12711,"ratio":0.9792003697712041} +{"name":"auth_contract-Auth::get_authorized","base_size":809,"alt_size":865,"ratio":1.069221260815822} +{"name":"auth_contract-Auth::get_authorized_delay","base_size":663,"alt_size":685,"ratio":1.0331825037707392} +{"name":"auth_contract-Auth::get_authorized_in_private","base_size":13312,"alt_size":13048,"ratio":0.9801682692307693} +{"name":"auth_contract-Auth::get_scheduled_authorized","base_size":728,"alt_size":767,"ratio":1.0535714285714286} +{"name":"auth_contract-Auth::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"auth_contract-Auth::public_dispatch","base_size":9711,"alt_size":8086,"ratio":0.8326639892904953} +{"name":"auth_contract-Auth::set_authorized","base_size":3456,"alt_size":3069,"ratio":0.8880208333333334} +{"name":"auth_contract-Auth::set_authorized_delay","base_size":3474,"alt_size":3040,"ratio":0.8750719631548647} +{"name":"auth_contract-Auth::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"auth_registry_contract-AuthRegistry::_set_authorized","base_size":1765,"alt_size":1629,"ratio":0.9229461756373938} +{"name":"auth_registry_contract-AuthRegistry::consume","base_size":3880,"alt_size":3308,"ratio":0.8525773195876288} +{"name":"auth_registry_contract-AuthRegistry::is_consumable","base_size":1755,"alt_size":1639,"ratio":0.933903133903134} +{"name":"auth_registry_contract-AuthRegistry::is_reject_all","base_size":1175,"alt_size":1141,"ratio":0.971063829787234} +{"name":"auth_registry_contract-AuthRegistry::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"auth_registry_contract-AuthRegistry::public_dispatch","base_size":7739,"alt_size":5978,"ratio":0.7724512210879959} +{"name":"auth_registry_contract-AuthRegistry::set_authorized","base_size":1700,"alt_size":1605,"ratio":0.9441176470588235} +{"name":"auth_registry_contract-AuthRegistry::set_authorized_private","base_size":5829,"alt_size":5918,"ratio":1.0152684851604048} +{"name":"auth_registry_contract-AuthRegistry::set_reject_all","base_size":1116,"alt_size":1113,"ratio":0.9973118279569892} +{"name":"auth_registry_contract-AuthRegistry::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"auth_registry_contract-AuthRegistry::unconstrained_is_consumable","base_size":1740,"alt_size":1656,"ratio":0.9517241379310345} +{"name":"auth_wit_test_contract-AuthWitTest::consume","base_size":5402,"alt_size":5406,"ratio":1.0007404664938913} +{"name":"auth_wit_test_contract-AuthWitTest::consume_public","base_size":750,"alt_size":765,"ratio":1.02} +{"name":"auth_wit_test_contract-AuthWitTest::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"auth_wit_test_contract-AuthWitTest::public_dispatch","base_size":1306,"alt_size":1266,"ratio":0.9693721286370597} +{"name":"auth_wit_test_contract-AuthWitTest::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_f1600","base_size":712,"alt_size":756,"ratio":1.0617977528089888} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_hash","base_size":2062,"alt_size":2008,"ratio":0.973811833171678} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash","base_size":2741,"alt_size":2474,"ratio":0.9025902955125866} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash_with_index","base_size":2716,"alt_size":2484,"ratio":0.914580265095729} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::poseidon2_hash","base_size":1631,"alt_size":1495,"ratio":0.9166155732679337} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::public_dispatch","base_size":38983,"alt_size":29848,"ratio":0.7656670856527205} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_10","base_size":2490,"alt_size":2340,"ratio":0.9397590361445783} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_100","base_size":3910,"alt_size":3592,"ratio":0.9186700767263427} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_20","base_size":2503,"alt_size":2388,"ratio":0.9540551338393928} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_2048","base_size":22473,"alt_size":20853,"ratio":0.9279134961954345} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_255","base_size":5854,"alt_size":5538,"ratio":0.9460198155107619} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_256","base_size":5530,"alt_size":5234,"ratio":0.9464737793851717} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_30","base_size":2673,"alt_size":2565,"ratio":0.9595959595959596} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_40","base_size":2761,"alt_size":2635,"ratio":0.9543643607388628} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_50","base_size":2931,"alt_size":2781,"ratio":0.9488229273285568} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_511","base_size":8537,"alt_size":8238,"ratio":0.9649759868806372} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_512","base_size":8154,"alt_size":7910,"ratio":0.9700760363012019} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_60","base_size":2998,"alt_size":2851,"ratio":0.9509673115410273} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_70","base_size":3666,"alt_size":3355,"ratio":0.9151663938897981} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_80","base_size":3610,"alt_size":3357,"ratio":0.9299168975069252} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_90","base_size":3789,"alt_size":3483,"ratio":0.9192399049881235} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"avm_initializer_test_contract-AvmInitializerTest::constructor","base_size":2460,"alt_size":2233,"ratio":0.9077235772357723} +{"name":"avm_initializer_test_contract-AvmInitializerTest::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"avm_initializer_test_contract-AvmInitializerTest::public_dispatch","base_size":3088,"alt_size":2829,"ratio":0.9161269430051814} +{"name":"avm_initializer_test_contract-AvmInitializerTest::read_storage_immutable","base_size":321,"alt_size":339,"ratio":1.0560747663551402} +{"name":"avm_initializer_test_contract-AvmInitializerTest::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"avm_test_contract-AvmTest::add_args_return","base_size":228,"alt_size":280,"ratio":1.2280701754385965} +{"name":"avm_test_contract-AvmTest::add_storage_map","base_size":2301,"alt_size":2053,"ratio":0.8922207735767058} +{"name":"avm_test_contract-AvmTest::add_u128","base_size":345,"alt_size":412,"ratio":1.1942028985507247} +{"name":"avm_test_contract-AvmTest::assert_calldata_copy","base_size":615,"alt_size":682,"ratio":1.1089430894308943} +{"name":"avm_test_contract-AvmTest::assert_nullifier_exists","base_size":286,"alt_size":323,"ratio":1.1293706293706294} +{"name":"avm_test_contract-AvmTest::assert_same","base_size":254,"alt_size":313,"ratio":1.2322834645669292} +{"name":"avm_test_contract-AvmTest::assertion_failure","base_size":213,"alt_size":242,"ratio":1.136150234741784} +{"name":"avm_test_contract-AvmTest::bulk_testing","base_size":18275,"alt_size":14924,"ratio":0.8166347469220246} +{"name":"avm_test_contract-AvmTest::create_different_nullifier_in_nested_call","base_size":737,"alt_size":743,"ratio":1.0081411126187245} +{"name":"avm_test_contract-AvmTest::create_same_nullifier_in_nested_call","base_size":706,"alt_size":724,"ratio":1.0254957507082152} +{"name":"avm_test_contract-AvmTest::debug_logging","base_size":1075,"alt_size":996,"ratio":0.9265116279069767} +{"name":"avm_test_contract-AvmTest::divide_by_zero","base_size":209,"alt_size":225,"ratio":1.076555023923445} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add","base_size":646,"alt_size":685,"ratio":1.0603715170278638} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add_and_double","base_size":323,"alt_size":350,"ratio":1.08359133126935} +{"name":"avm_test_contract-AvmTest::emit_nullifier_and_check","base_size":310,"alt_size":319,"ratio":1.0290322580645161} +{"name":"avm_test_contract-AvmTest::emit_public_log","base_size":2015,"alt_size":1873,"ratio":0.9295285359801488} +{"name":"avm_test_contract-AvmTest::enqueue_public_from_private","base_size":5008,"alt_size":5022,"ratio":1.0027955271565496} +{"name":"avm_test_contract-AvmTest::external_call_to_assertion_failure","base_size":663,"alt_size":660,"ratio":0.995475113122172} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero","base_size":673,"alt_size":673,"ratio":1} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero_recovers","base_size":2199,"alt_size":2003,"ratio":0.910868576625739} +{"name":"avm_test_contract-AvmTest::get_address","base_size":212,"alt_size":240,"ratio":1.1320754716981132} +{"name":"avm_test_contract-AvmTest::get_args_hash","base_size":1754,"alt_size":1633,"ratio":0.9310148232611174} +{"name":"avm_test_contract-AvmTest::get_block_number","base_size":216,"alt_size":248,"ratio":1.1481481481481481} +{"name":"avm_test_contract-AvmTest::get_chain_id","base_size":210,"alt_size":246,"ratio":1.1714285714285715} +{"name":"avm_test_contract-AvmTest::get_da_gas_left","base_size":216,"alt_size":248,"ratio":1.1481481481481481} +{"name":"avm_test_contract-AvmTest::get_fee_per_da_gas","base_size":218,"alt_size":248,"ratio":1.1376146788990826} +{"name":"avm_test_contract-AvmTest::get_fee_per_l2_gas","base_size":216,"alt_size":250,"ratio":1.1574074074074074} +{"name":"avm_test_contract-AvmTest::get_l2_gas_left","base_size":215,"alt_size":243,"ratio":1.130232558139535} +{"name":"avm_test_contract-AvmTest::get_sender","base_size":214,"alt_size":241,"ratio":1.1261682242990654} +{"name":"avm_test_contract-AvmTest::get_timestamp","base_size":220,"alt_size":244,"ratio":1.1090909090909091} +{"name":"avm_test_contract-AvmTest::get_transaction_fee","base_size":219,"alt_size":251,"ratio":1.1461187214611872} +{"name":"avm_test_contract-AvmTest::get_version","base_size":216,"alt_size":241,"ratio":1.1157407407407407} +{"name":"avm_test_contract-AvmTest::helper_with_failed_assertion","base_size":111,"alt_size":87,"ratio":0.7837837837837838} +{"name":"avm_test_contract-AvmTest::inner_helper_with_failed_assertion","base_size":111,"alt_size":87,"ratio":0.7837837837837838} +{"name":"avm_test_contract-AvmTest::l1_to_l2_msg_exists","base_size":266,"alt_size":316,"ratio":1.1879699248120301} +{"name":"avm_test_contract-AvmTest::modulo2","base_size":216,"alt_size":270,"ratio":1.25} +{"name":"avm_test_contract-AvmTest::n_new_l2_to_l1_msgs","base_size":279,"alt_size":314,"ratio":1.125448028673835} +{"name":"avm_test_contract-AvmTest::n_new_note_hashes","base_size":280,"alt_size":320,"ratio":1.1428571428571428} +{"name":"avm_test_contract-AvmTest::n_new_nullifiers","base_size":279,"alt_size":306,"ratio":1.096774193548387} +{"name":"avm_test_contract-AvmTest::n_new_public_logs","base_size":386,"alt_size":424,"ratio":1.0984455958549222} +{"name":"avm_test_contract-AvmTest::n_storage_writes","base_size":1170,"alt_size":1128,"ratio":0.9641025641025641} +{"name":"avm_test_contract-AvmTest::nested_call_to_add","base_size":731,"alt_size":759,"ratio":1.0383036935704515} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_n_times_different_addresses","base_size":1092,"alt_size":1098,"ratio":1.0054945054945055} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_with_gas","base_size":690,"alt_size":748,"ratio":1.0840579710144929} +{"name":"avm_test_contract-AvmTest::nested_call_to_assert_same","base_size":734,"alt_size":761,"ratio":1.0367847411444142} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing","base_size":667,"alt_size":658,"ratio":0.9865067466266867} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing_recovers","base_size":414,"alt_size":438,"ratio":1.0579710144927537} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_add","base_size":751,"alt_size":763,"ratio":1.0159786950732357} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_set_storage","base_size":698,"alt_size":691,"ratio":0.9899713467048711} +{"name":"avm_test_contract-AvmTest::new_note_hash","base_size":224,"alt_size":264,"ratio":1.1785714285714286} +{"name":"avm_test_contract-AvmTest::new_nullifier","base_size":216,"alt_size":265,"ratio":1.2268518518518519} +{"name":"avm_test_contract-AvmTest::note_hash_exists","base_size":266,"alt_size":318,"ratio":1.1954887218045114} +{"name":"avm_test_contract-AvmTest::nullifier_collision","base_size":230,"alt_size":266,"ratio":1.1565217391304348} +{"name":"avm_test_contract-AvmTest::nullifier_exists","base_size":265,"alt_size":313,"ratio":1.181132075471698} +{"name":"avm_test_contract-AvmTest::pedersen_commit","base_size":1176,"alt_size":1177,"ratio":1.0008503401360545} +{"name":"avm_test_contract-AvmTest::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"avm_test_contract-AvmTest::public_dispatch","base_size":39496,"alt_size":31688,"ratio":0.8023090945918574} +{"name":"avm_test_contract-AvmTest::read_assert_storage_single","base_size":266,"alt_size":296,"ratio":1.112781954887218} +{"name":"avm_test_contract-AvmTest::read_storage_list","base_size":392,"alt_size":431,"ratio":1.0994897959183674} +{"name":"avm_test_contract-AvmTest::read_storage_map","base_size":1126,"alt_size":1103,"ratio":0.9795737122557726} +{"name":"avm_test_contract-AvmTest::read_storage_single","base_size":231,"alt_size":258,"ratio":1.1168831168831168} +{"name":"avm_test_contract-AvmTest::return_oracle","base_size":510,"alt_size":540,"ratio":1.0588235294117647} +{"name":"avm_test_contract-AvmTest::returndata_copy_oracle","base_size":1359,"alt_size":1300,"ratio":0.9565857247976454} +{"name":"avm_test_contract-AvmTest::revert_oracle","base_size":496,"alt_size":541,"ratio":1.090725806451613} +{"name":"avm_test_contract-AvmTest::send_l2_to_l1_msg","base_size":244,"alt_size":287,"ratio":1.1762295081967213} +{"name":"avm_test_contract-AvmTest::set_opcode_big_field","base_size":214,"alt_size":235,"ratio":1.0981308411214954} +{"name":"avm_test_contract-AvmTest::set_opcode_really_big_field","base_size":211,"alt_size":231,"ratio":1.09478672985782} +{"name":"avm_test_contract-AvmTest::set_opcode_small_field","base_size":211,"alt_size":234,"ratio":1.1090047393364928} +{"name":"avm_test_contract-AvmTest::set_opcode_u32","base_size":196,"alt_size":216,"ratio":1.1020408163265305} +{"name":"avm_test_contract-AvmTest::set_opcode_u64","base_size":195,"alt_size":215,"ratio":1.1025641025641026} +{"name":"avm_test_contract-AvmTest::set_opcode_u8","base_size":187,"alt_size":220,"ratio":1.1764705882352942} +{"name":"avm_test_contract-AvmTest::set_read_storage_single","base_size":262,"alt_size":306,"ratio":1.16793893129771} +{"name":"avm_test_contract-AvmTest::set_storage_list","base_size":264,"alt_size":309,"ratio":1.1704545454545454} +{"name":"avm_test_contract-AvmTest::set_storage_map","base_size":1641,"alt_size":1558,"ratio":0.9494210847044485} +{"name":"avm_test_contract-AvmTest::set_storage_single","base_size":230,"alt_size":278,"ratio":1.208695652173913} +{"name":"avm_test_contract-AvmTest::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance","base_size":540,"alt_size":536,"ratio":0.9925925925925926} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance_matches","base_size":564,"alt_size":574,"ratio":1.0177304964539007} +{"name":"avm_test_contract-AvmTest::to_radix_le","base_size":472,"alt_size":554,"ratio":1.173728813559322} +{"name":"avm_test_contract-AvmTest::u128_addition_overflow","base_size":1031,"alt_size":999,"ratio":0.9689621726479146} +{"name":"avm_test_contract-AvmTest::u128_from_integer_overflow","base_size":606,"alt_size":625,"ratio":1.0313531353135315} +{"name":"avm_test_contract-AvmTest::variable_base_msm","base_size":552,"alt_size":590,"ratio":1.068840579710145} +{"name":"benchmarking_contract-Benchmarking::broadcast","base_size":1220,"alt_size":1181,"ratio":0.9680327868852459} +{"name":"benchmarking_contract-Benchmarking::create_note","base_size":70351,"alt_size":64442,"ratio":0.9160068797884892} +{"name":"benchmarking_contract-Benchmarking::increment_balance","base_size":2192,"alt_size":2007,"ratio":0.9156021897810219} +{"name":"benchmarking_contract-Benchmarking::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"benchmarking_contract-Benchmarking::public_dispatch","base_size":6088,"alt_size":5225,"ratio":0.8582457293035479} +{"name":"benchmarking_contract-Benchmarking::recreate_note","base_size":88826,"alt_size":80522,"ratio":0.9065138585549276} +{"name":"benchmarking_contract-Benchmarking::sha256_hash_2048","base_size":22473,"alt_size":20853,"ratio":0.9279134961954345} +{"name":"benchmarking_contract-Benchmarking::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"card_game_contract-CardGame::buy_pack","base_size":120474,"alt_size":109819,"ratio":0.9115576804953766} +{"name":"card_game_contract-CardGame::claim_cards","base_size":149592,"alt_size":137580,"ratio":0.9197015883202311} +{"name":"card_game_contract-CardGame::join_game","base_size":320433,"alt_size":294119,"ratio":0.9178798688025266} +{"name":"card_game_contract-CardGame::on_card_played","base_size":3419,"alt_size":3122,"ratio":0.9131324948815444} +{"name":"card_game_contract-CardGame::on_cards_claimed","base_size":4303,"alt_size":3864,"ratio":0.8979781547757378} +{"name":"card_game_contract-CardGame::on_game_joined","base_size":2520,"alt_size":2353,"ratio":0.9337301587301587} +{"name":"card_game_contract-CardGame::play_card","base_size":231201,"alt_size":210097,"ratio":0.9087201179925692} +{"name":"card_game_contract-CardGame::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"card_game_contract-CardGame::public_dispatch","base_size":12329,"alt_size":9744,"ratio":0.7903317381782788} +{"name":"card_game_contract-CardGame::start_game","base_size":3695,"alt_size":3299,"ratio":0.8928281461434371} +{"name":"card_game_contract-CardGame::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"card_game_contract-CardGame::view_collection_cards","base_size":19089,"alt_size":16166,"ratio":0.8468751637068469} +{"name":"card_game_contract-CardGame::view_game","base_size":17867,"alt_size":15144,"ratio":0.8475961269379303} +{"name":"card_game_contract-CardGame::view_game_cards","base_size":19604,"alt_size":16601,"ratio":0.846816976127321} +{"name":"child_contract-Child::private_get_value","base_size":44558,"alt_size":40012,"ratio":0.8979756721576372} +{"name":"child_contract-Child::private_set_value","base_size":70478,"alt_size":64666,"ratio":0.9175345497885865} +{"name":"child_contract-Child::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"child_contract-Child::pub_get_value","base_size":304,"alt_size":345,"ratio":1.1348684210526316} +{"name":"child_contract-Child::pub_inc_value","base_size":398,"alt_size":448,"ratio":1.1256281407035176} +{"name":"child_contract-Child::pub_inc_value_internal","base_size":457,"alt_size":510,"ratio":1.1159737417943107} +{"name":"child_contract-Child::pub_set_value","base_size":381,"alt_size":425,"ratio":1.1154855643044619} +{"name":"child_contract-Child::public_dispatch","base_size":2840,"alt_size":2480,"ratio":0.8732394366197183} +{"name":"child_contract-Child::set_value_twice_with_nested_first","base_size":838,"alt_size":811,"ratio":0.9677804295942721} +{"name":"child_contract-Child::set_value_twice_with_nested_last","base_size":847,"alt_size":811,"ratio":0.9574970484061394} +{"name":"child_contract-Child::set_value_with_two_nested_calls","base_size":1091,"alt_size":1033,"ratio":0.9468377635197067} +{"name":"child_contract-Child::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"child_contract-Child::value","base_size":21446,"alt_size":18902,"ratio":0.8813764804625571} +{"name":"child_contract-Child::value_internal","base_size":21571,"alt_size":18937,"ratio":0.8778916137406704} +{"name":"claim_contract-Claim::claim","base_size":40340,"alt_size":37161,"ratio":0.9211948438274665} +{"name":"claim_contract-Claim::constructor","base_size":3758,"alt_size":3255,"ratio":0.8661522086216072} +{"name":"claim_contract-Claim::process_log","base_size":14990,"alt_size":12646,"ratio":0.8436290860573716} +{"name":"claim_contract-Claim::public_dispatch","base_size":4157,"alt_size":3595,"ratio":0.8648063507337022} +{"name":"claim_contract-Claim::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::assert_class_id_is_registered","base_size":4047,"alt_size":4119,"ratio":1.0177909562638991} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_private_function","base_size":20389,"alt_size":19446,"ratio":0.9537495708470254} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_unconstrained_function","base_size":20346,"alt_size":19264,"ratio":0.9468200137619188} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::register","base_size":221551,"alt_size":202335,"ratio":0.9132660200134506} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::deploy","base_size":7639,"alt_size":7661,"ratio":1.0028799581097003} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::get_update_delay","base_size":1468,"alt_size":1395,"ratio":0.9502724795640327} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::public_dispatch","base_size":8605,"alt_size":7120,"ratio":0.8274259151656014} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::set_update_delay","base_size":4056,"alt_size":3510,"ratio":0.8653846153846154} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::update","base_size":4242,"alt_size":3684,"ratio":0.8684582743988685} +{"name":"counter_contract-Counter::decrement","base_size":225585,"alt_size":202694,"ratio":0.8985260544805728} +{"name":"counter_contract-Counter::get_counter","base_size":18915,"alt_size":15975,"ratio":0.8445678033306899} +{"name":"counter_contract-Counter::increment","base_size":66762,"alt_size":60801,"ratio":0.9107126808663611} +{"name":"counter_contract-Counter::increment_and_decrement","base_size":240819,"alt_size":216483,"ratio":0.8989448506969965} +{"name":"counter_contract-Counter::increment_twice","base_size":81927,"alt_size":74934,"ratio":0.9146435241129298} +{"name":"counter_contract-Counter::initialize","base_size":71829,"alt_size":65930,"ratio":0.9178743961352657} +{"name":"counter_contract-Counter::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"counter_contract-Counter::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"crowdfunding_contract-Crowdfunding::_publish_donation_receipts","base_size":532,"alt_size":563,"ratio":1.0582706766917294} +{"name":"crowdfunding_contract-Crowdfunding::donate","base_size":72839,"alt_size":67027,"ratio":0.9202075811035297} +{"name":"crowdfunding_contract-Crowdfunding::init","base_size":3739,"alt_size":3213,"ratio":0.8593206739769992} +{"name":"crowdfunding_contract-Crowdfunding::process_log","base_size":14990,"alt_size":12646,"ratio":0.8436290860573716} +{"name":"crowdfunding_contract-Crowdfunding::public_dispatch","base_size":4552,"alt_size":3976,"ratio":0.8734622144112478} +{"name":"crowdfunding_contract-Crowdfunding::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"crowdfunding_contract-Crowdfunding::withdraw","base_size":28753,"alt_size":26149,"ratio":0.9094355371613397} +{"name":"docs_example_contract-DocsExample::get_imm_card","base_size":23052,"alt_size":20391,"ratio":0.8845653305570016} +{"name":"docs_example_contract-DocsExample::get_leader","base_size":16334,"alt_size":13808,"ratio":0.8453532508877188} +{"name":"docs_example_contract-DocsExample::get_legendary_card","base_size":18029,"alt_size":15102,"ratio":0.8376504520494759} +{"name":"docs_example_contract-DocsExample::get_public_immutable","base_size":16281,"alt_size":13892,"ratio":0.8532645414900805} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private","base_size":28315,"alt_size":25527,"ratio":0.9015362881864736} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private_indirect","base_size":22294,"alt_size":19685,"ratio":0.8829729972189827} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public","base_size":345,"alt_size":377,"ratio":1.0927536231884059} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_indirect","base_size":796,"alt_size":810,"ratio":1.0175879396984924} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_multiple","base_size":425,"alt_size":501,"ratio":1.1788235294117646} +{"name":"docs_example_contract-DocsExample::increase_legendary_points","base_size":73255,"alt_size":67029,"ratio":0.9150092143880963} +{"name":"docs_example_contract-DocsExample::initialize_private","base_size":66305,"alt_size":60777,"ratio":0.9166277053012594} +{"name":"docs_example_contract-DocsExample::initialize_private_immutable","base_size":66365,"alt_size":60739,"ratio":0.9152263994575454} +{"name":"docs_example_contract-DocsExample::initialize_public_immutable","base_size":1234,"alt_size":1220,"ratio":0.9886547811993517} +{"name":"docs_example_contract-DocsExample::insert_note","base_size":66297,"alt_size":60570,"ratio":0.9136160007240146} +{"name":"docs_example_contract-DocsExample::insert_notes","base_size":93012,"alt_size":85663,"ratio":0.9209886896314454} +{"name":"docs_example_contract-DocsExample::is_legendary_initialized","base_size":16998,"alt_size":14267,"ratio":0.8393340392987411} +{"name":"docs_example_contract-DocsExample::is_priv_imm_initialized","base_size":16949,"alt_size":14278,"ratio":0.8424095816862351} +{"name":"docs_example_contract-DocsExample::match_public_immutable","base_size":28092,"alt_size":25389,"ratio":0.9037804357112346} +{"name":"docs_example_contract-DocsExample::process_log","base_size":15194,"alt_size":12736,"ratio":0.8382256153744899} +{"name":"docs_example_contract-DocsExample::public_dispatch","base_size":3396,"alt_size":3009,"ratio":0.8860424028268551} +{"name":"docs_example_contract-DocsExample::read_note","base_size":18339,"alt_size":15572,"ratio":0.849119363105949} +{"name":"docs_example_contract-DocsExample::simple_macro_example","base_size":21432,"alt_size":18911,"ratio":0.8823721537887271} +{"name":"docs_example_contract-DocsExample::simple_macro_example_expanded","base_size":4637,"alt_size":4756,"ratio":1.0256631442743154} +{"name":"docs_example_contract-DocsExample::spend_public_authwit","base_size":197,"alt_size":255,"ratio":1.2944162436548223} +{"name":"docs_example_contract-DocsExample::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"docs_example_contract-DocsExample::update_leader","base_size":347,"alt_size":391,"ratio":1.1268011527377522} +{"name":"docs_example_contract-DocsExample::update_legendary_card","base_size":69920,"alt_size":63815,"ratio":0.9126859267734554} +{"name":"docs_example_contract-DocsExample::verify_private_authwit","base_size":21543,"alt_size":18922,"ratio":0.8783363505547045} +{"name":"docs_example_contract-DocsExample::view_imm_card","base_size":17928,"alt_size":15186,"ratio":0.8470548862115127} +{"name":"easy_private_token_contract-EasyPrivateToken::constructor","base_size":71829,"alt_size":65930,"ratio":0.9178743961352657} +{"name":"easy_private_token_contract-EasyPrivateToken::get_balance","base_size":18915,"alt_size":15975,"ratio":0.8445678033306899} +{"name":"easy_private_token_contract-EasyPrivateToken::mint","base_size":70288,"alt_size":64459,"ratio":0.9170697700887775} +{"name":"easy_private_token_contract-EasyPrivateToken::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"easy_private_token_contract-EasyPrivateToken::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"easy_private_token_contract-EasyPrivateToken::transfer","base_size":266118,"alt_size":240279,"ratio":0.9029039749284152} +{"name":"easy_private_voting_contract-EasyPrivateVoting::add_to_tally_public","base_size":1874,"alt_size":1760,"ratio":0.9391675560298826} +{"name":"easy_private_voting_contract-EasyPrivateVoting::cast_vote","base_size":7724,"alt_size":7706,"ratio":0.9976696012428793} +{"name":"easy_private_voting_contract-EasyPrivateVoting::constructor","base_size":3010,"alt_size":2647,"ratio":0.8794019933554817} +{"name":"easy_private_voting_contract-EasyPrivateVoting::end_vote","base_size":380,"alt_size":389,"ratio":1.0236842105263158} +{"name":"easy_private_voting_contract-EasyPrivateVoting::get_vote","base_size":1250,"alt_size":1213,"ratio":0.9704} +{"name":"easy_private_voting_contract-EasyPrivateVoting::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"easy_private_voting_contract-EasyPrivateVoting::public_dispatch","base_size":4819,"alt_size":4178,"ratio":0.8669848516289687} +{"name":"easy_private_voting_contract-EasyPrivateVoting::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::constructor","base_size":76386,"alt_size":69911,"ratio":0.9152331579085172} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::entrypoint","base_size":65077,"alt_size":58985,"ratio":0.90638781750849} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::process_log","base_size":16856,"alt_size":14178,"ratio":0.841124822021832} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::verify_private_authwit","base_size":41083,"alt_size":36913,"ratio":0.8984981622568946} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::constructor","base_size":76386,"alt_size":69911,"ratio":0.9152331579085172} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::entrypoint","base_size":65012,"alt_size":59063,"ratio":0.9084938165261798} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::process_log","base_size":16856,"alt_size":14178,"ratio":0.841124822021832} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::verify_private_authwit","base_size":41159,"alt_size":36799,"ratio":0.894069340848903} +{"name":"escrow_contract-Escrow::constructor","base_size":70295,"alt_size":63487,"ratio":0.9031510064727221} +{"name":"escrow_contract-Escrow::process_log","base_size":21724,"alt_size":17773,"ratio":0.8181274166820107} +{"name":"escrow_contract-Escrow::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"escrow_contract-Escrow::withdraw","base_size":29895,"alt_size":25928,"ratio":0.8673022244522496} +{"name":"fee_juice_contract-FeeJuice::_increase_public_balance","base_size":1971,"alt_size":1826,"ratio":0.9264332825976661} +{"name":"fee_juice_contract-FeeJuice::balance_of_public","base_size":1256,"alt_size":1224,"ratio":0.9745222929936306} +{"name":"fee_juice_contract-FeeJuice::check_balance","base_size":1470,"alt_size":1417,"ratio":0.9639455782312926} +{"name":"fee_juice_contract-FeeJuice::claim","base_size":73213,"alt_size":66784,"ratio":0.9121877262234849} +{"name":"fee_juice_contract-FeeJuice::initialize","base_size":5884,"alt_size":5914,"ratio":1.005098572399728} +{"name":"fee_juice_contract-FeeJuice::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"fee_juice_contract-FeeJuice::public_dispatch","base_size":4470,"alt_size":3917,"ratio":0.8762863534675616} +{"name":"fee_juice_contract-FeeJuice::set_portal","base_size":1132,"alt_size":1150,"ratio":1.0159010600706713} +{"name":"fee_juice_contract-FeeJuice::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"fpc_contract-FPC::complete_refund","base_size":1253,"alt_size":1248,"ratio":0.9960095770151636} +{"name":"fpc_contract-FPC::constructor","base_size":3470,"alt_size":3070,"ratio":0.8847262247838616} +{"name":"fpc_contract-FPC::fee_entrypoint_private","base_size":29614,"alt_size":26921,"ratio":0.9090632808806646} +{"name":"fpc_contract-FPC::fee_entrypoint_public","base_size":29279,"alt_size":26469,"ratio":0.9040267768707948} +{"name":"fpc_contract-FPC::get_accepted_asset","base_size":27995,"alt_size":25423,"ratio":0.9081264511519914} +{"name":"fpc_contract-FPC::pay_refund","base_size":1258,"alt_size":1263,"ratio":1.0039745627980923} +{"name":"fpc_contract-FPC::process_log","base_size":14990,"alt_size":12646,"ratio":0.8436290860573716} +{"name":"fpc_contract-FPC::public_dispatch","base_size":6698,"alt_size":5729,"ratio":0.8553299492385786} +{"name":"fpc_contract-FPC::pull_funds","base_size":1274,"alt_size":1220,"ratio":0.957613814756672} +{"name":"fpc_contract-FPC::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"import_test_contract-ImportTest::call_no_args","base_size":29353,"alt_size":25289,"ratio":0.8615473716485538} +{"name":"import_test_contract-ImportTest::call_public_fn","base_size":29081,"alt_size":24953,"ratio":0.8580516488428871} +{"name":"import_test_contract-ImportTest::main_contract","base_size":29560,"alt_size":25430,"ratio":0.8602841677943166} +{"name":"import_test_contract-ImportTest::process_log","base_size":22624,"alt_size":18652,"ratio":0.8244342291371994} +{"name":"import_test_contract-ImportTest::pub_call_public_fn","base_size":676,"alt_size":689,"ratio":1.0192307692307692} +{"name":"import_test_contract-ImportTest::public_dispatch","base_size":1193,"alt_size":1177,"ratio":0.9865884325230512} +{"name":"import_test_contract-ImportTest::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"inclusion_proofs_contract-InclusionProofs::constructor","base_size":2438,"alt_size":2226,"ratio":0.9130434782608695} +{"name":"inclusion_proofs_contract-InclusionProofs::create_note","base_size":70288,"alt_size":64477,"ratio":0.9173258593216481} +{"name":"inclusion_proofs_contract-InclusionProofs::nullify_note","base_size":40221,"alt_size":35932,"ratio":0.8933641629994281} +{"name":"inclusion_proofs_contract-InclusionProofs::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"inclusion_proofs_contract-InclusionProofs::public_dispatch","base_size":3191,"alt_size":2842,"ratio":0.8906298965841429} +{"name":"inclusion_proofs_contract-InclusionProofs::push_nullifier_public","base_size":309,"alt_size":340,"ratio":1.1003236245954693} +{"name":"inclusion_proofs_contract-InclusionProofs::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_inclusion","base_size":34455,"alt_size":31376,"ratio":0.9106370628355827} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_non_inclusion","base_size":38255,"alt_size":34877,"ratio":0.9116978172787871} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion","base_size":46528,"alt_size":42012,"ratio":0.9029401650618982} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion_fail_case","base_size":30784,"alt_size":27936,"ratio":0.9074844074844075} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_not_nullified","base_size":51153,"alt_size":46088,"ratio":0.9009833245361953} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_validity","base_size":54502,"alt_size":49261,"ratio":0.9038383912516972} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion","base_size":31090,"alt_size":28147,"ratio":0.9053393374075266} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion_from_public","base_size":313,"alt_size":335,"ratio":1.0702875399361023} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read","base_size":33182,"alt_size":30282,"ratio":0.9126032186125007} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read_unset_slot","base_size":33284,"alt_size":30401,"ratio":0.9133818050715058} +{"name":"lending_contract-Lending::_borrow","base_size":7859,"alt_size":6911,"ratio":0.8793739661534546} +{"name":"lending_contract-Lending::_deposit","base_size":2099,"alt_size":2003,"ratio":0.9542639352072415} +{"name":"lending_contract-Lending::_repay","base_size":5363,"alt_size":4904,"ratio":0.9144135744918889} +{"name":"lending_contract-Lending::_withdraw","base_size":7231,"alt_size":6338,"ratio":0.8765039413635735} +{"name":"lending_contract-Lending::borrow_private","base_size":22405,"alt_size":19737,"ratio":0.88091943762553} +{"name":"lending_contract-Lending::borrow_public","base_size":803,"alt_size":822,"ratio":1.0236612702366128} +{"name":"lending_contract-Lending::constructor","base_size":23175,"alt_size":20537,"ratio":0.8861704422869472} +{"name":"lending_contract-Lending::deposit_private","base_size":22852,"alt_size":20284,"ratio":0.8876247155610012} +{"name":"lending_contract-Lending::deposit_public","base_size":1111,"alt_size":1087,"ratio":0.9783978397839784} +{"name":"lending_contract-Lending::get_asset","base_size":1626,"alt_size":1580,"ratio":0.971709717097171} +{"name":"lending_contract-Lending::get_assets","base_size":522,"alt_size":569,"ratio":1.0900383141762453} +{"name":"lending_contract-Lending::get_position","base_size":4377,"alt_size":3942,"ratio":0.9006168608636053} +{"name":"lending_contract-Lending::init","base_size":1953,"alt_size":1891,"ratio":0.9682539682539683} +{"name":"lending_contract-Lending::process_log","base_size":14990,"alt_size":12646,"ratio":0.8436290860573716} +{"name":"lending_contract-Lending::public_dispatch","base_size":30559,"alt_size":24879,"ratio":0.8141300435223666} +{"name":"lending_contract-Lending::repay_private","base_size":22836,"alt_size":20168,"ratio":0.883166929409704} +{"name":"lending_contract-Lending::repay_public","base_size":1161,"alt_size":1134,"ratio":0.9767441860465116} +{"name":"lending_contract-Lending::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"lending_contract-Lending::update_accumulator","base_size":6414,"alt_size":5805,"ratio":0.9050514499532273} +{"name":"lending_contract-Lending::withdraw_private","base_size":22427,"alt_size":19653,"ratio":0.8763098051455834} +{"name":"lending_contract-Lending::withdraw_public","base_size":799,"alt_size":823,"ratio":1.0300375469336671} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::entrypoint","base_size":18038,"alt_size":17304,"ratio":0.9593081272868389} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"nft_contract-NFT::_finalize_transfer_to_private_unsafe","base_size":3569,"alt_size":3220,"ratio":0.9022135051835248} +{"name":"nft_contract-NFT::_finish_transfer_to_public","base_size":1257,"alt_size":1248,"ratio":0.9928400954653938} +{"name":"nft_contract-NFT::_store_payload_in_transient_storage_unsafe","base_size":1225,"alt_size":1239,"ratio":1.0114285714285713} +{"name":"nft_contract-NFT::cancel_authwit","base_size":21085,"alt_size":18532,"ratio":0.8789186625563197} +{"name":"nft_contract-NFT::constructor","base_size":5748,"alt_size":5046,"ratio":0.8778705636743215} +{"name":"nft_contract-NFT::finalize_transfer_to_private","base_size":3528,"alt_size":3184,"ratio":0.9024943310657596} +{"name":"nft_contract-NFT::get_admin","base_size":367,"alt_size":400,"ratio":1.0899182561307903} +{"name":"nft_contract-NFT::get_private_nfts","base_size":20050,"alt_size":16803,"ratio":0.8380548628428928} +{"name":"nft_contract-NFT::is_minter","base_size":1258,"alt_size":1250,"ratio":0.9936406995230525} +{"name":"nft_contract-NFT::mint","base_size":2560,"alt_size":2286,"ratio":0.89296875} +{"name":"nft_contract-NFT::owner_of","base_size":1822,"alt_size":1704,"ratio":0.9352360043907794} +{"name":"nft_contract-NFT::prepare_private_balance_increase","base_size":66456,"alt_size":60927,"ratio":0.916802094618996} +{"name":"nft_contract-NFT::private_get_name","base_size":27793,"alt_size":25377,"ratio":0.9130716367430648} +{"name":"nft_contract-NFT::private_get_symbol","base_size":27949,"alt_size":25440,"ratio":0.9102293463093492} +{"name":"nft_contract-NFT::process_log","base_size":14925,"alt_size":12592,"ratio":0.8436850921273031} +{"name":"nft_contract-NFT::public_dispatch","base_size":20493,"alt_size":16192,"ratio":0.7901234567901234} +{"name":"nft_contract-NFT::public_get_name","base_size":375,"alt_size":388,"ratio":1.0346666666666666} +{"name":"nft_contract-NFT::public_get_symbol","base_size":347,"alt_size":388,"ratio":1.1181556195965419} +{"name":"nft_contract-NFT::set_admin","base_size":376,"alt_size":423,"ratio":1.125} +{"name":"nft_contract-NFT::set_minter","base_size":1277,"alt_size":1275,"ratio":0.9984338292873923} +{"name":"nft_contract-NFT::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"nft_contract-NFT::transfer_in_private","base_size":98892,"alt_size":89597,"ratio":0.9060085750111232} +{"name":"nft_contract-NFT::transfer_in_public","base_size":3751,"alt_size":3300,"ratio":0.8797653958944281} +{"name":"nft_contract-NFT::transfer_to_private","base_size":66845,"alt_size":61062,"ratio":0.9134864238162914} +{"name":"nft_contract-NFT::transfer_to_public","base_size":50192,"alt_size":45141,"ratio":0.8993664328976729} +{"name":"parent_contract-Parent::enqueue_call_to_child","base_size":21821,"alt_size":19248,"ratio":0.882086063883415} +{"name":"parent_contract-Parent::enqueue_call_to_child_twice","base_size":21917,"alt_size":19369,"ratio":0.8837432130309805} +{"name":"parent_contract-Parent::enqueue_call_to_pub_entry_point","base_size":21770,"alt_size":19166,"ratio":0.8803858520900322} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_first","base_size":22238,"alt_size":19585,"ratio":0.8806997032107204} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_last","base_size":22298,"alt_size":19537,"ratio":0.8761772356265136} +{"name":"parent_contract-Parent::enqueue_calls_to_pub_entry_point","base_size":21848,"alt_size":19269,"ratio":0.8819571585499817} +{"name":"parent_contract-Parent::enqueue_static_call_to_pub_function","base_size":21816,"alt_size":19211,"ratio":0.8805922258892556} +{"name":"parent_contract-Parent::enqueue_static_nested_call_to_pub_function","base_size":21801,"alt_size":19204,"ratio":0.8808770239897252} +{"name":"parent_contract-Parent::entry_point","base_size":22184,"alt_size":19480,"ratio":0.8781103498016588} +{"name":"parent_contract-Parent::private_call","base_size":22203,"alt_size":19540,"ratio":0.880061252983831} +{"name":"parent_contract-Parent::private_nested_static_call","base_size":22182,"alt_size":19539,"ratio":0.880849337300514} +{"name":"parent_contract-Parent::private_static_call","base_size":22212,"alt_size":19558,"ratio":0.8805150369169819} +{"name":"parent_contract-Parent::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"parent_contract-Parent::pub_entry_point","base_size":764,"alt_size":788,"ratio":1.031413612565445} +{"name":"parent_contract-Parent::pub_entry_point_twice","base_size":1045,"alt_size":1011,"ratio":0.9674641148325359} +{"name":"parent_contract-Parent::public_dispatch","base_size":4044,"alt_size":3546,"ratio":0.8768545994065282} +{"name":"parent_contract-Parent::public_nested_static_call","base_size":2669,"alt_size":2476,"ratio":0.9276882727613338} +{"name":"parent_contract-Parent::public_static_call","base_size":1203,"alt_size":1208,"ratio":1.0041562759767249} +{"name":"parent_contract-Parent::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"pending_note_hashes_contract-PendingNoteHashes::dummy","base_size":21162,"alt_size":18561,"ratio":0.8770910121916643} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_note_zero_balance","base_size":55883,"alt_size":49602,"ratio":0.8876044593167869} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_then_nullify_note","base_size":40328,"alt_size":36188,"ratio":0.8973417972624479} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note","base_size":70375,"alt_size":64408,"ratio":0.9152113676731793} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_extra_emit","base_size":81538,"alt_size":74657,"ratio":0.9156098996786775} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_static_randomness","base_size":66298,"alt_size":60746,"ratio":0.9162569006606535} +{"name":"pending_note_hashes_contract-PendingNoteHashes::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"pending_note_hashes_contract-PendingNoteHashes::recursively_destroy_and_create_notes","base_size":422819,"alt_size":389816,"ratio":0.9219453241221421} +{"name":"pending_note_hashes_contract-PendingNoteHashes::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_bad_get_then_insert_flat","base_size":87596,"alt_size":74795,"ratio":0.8538631901000046} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_emit_bad_note_log","base_size":81383,"alt_size":74497,"ratio":0.9153877345391543} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert1_then_get2_then_nullify2_all_in_nested_calls","base_size":22210,"alt_size":19505,"ratio":0.8782080144079244} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify1_all_in_nested_calls","base_size":22217,"alt_size":19480,"ratio":0.8768060494216141} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify2_all_in_nested_calls","base_size":22276,"alt_size":19728,"ratio":0.8856168073262705} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_all_in_nested_calls","base_size":22085,"alt_size":19553,"ratio":0.8853520489019696} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_flat","base_size":224467,"alt_size":201481,"ratio":0.8975974196652514} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_recursively_create_notes","base_size":299229,"alt_size":277805,"ratio":0.928402661506739} +{"name":"price_feed_contract-PriceFeed::get_price","base_size":1230,"alt_size":1224,"ratio":0.9951219512195122} +{"name":"price_feed_contract-PriceFeed::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"price_feed_contract-PriceFeed::public_dispatch","base_size":2473,"alt_size":2288,"ratio":0.9251920744035584} +{"name":"price_feed_contract-PriceFeed::set_price","base_size":1137,"alt_size":1122,"ratio":0.9868073878627969} +{"name":"price_feed_contract-PriceFeed::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"router_contract-Router::_check_block_number","base_size":995,"alt_size":1043,"ratio":1.0482412060301507} +{"name":"router_contract-Router::_check_timestamp","base_size":1030,"alt_size":1069,"ratio":1.0378640776699029} +{"name":"router_contract-Router::check_block_number","base_size":4928,"alt_size":4912,"ratio":0.9967532467532467} +{"name":"router_contract-Router::check_timestamp","base_size":4944,"alt_size":4975,"ratio":1.0062702265372168} +{"name":"router_contract-Router::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"router_contract-Router::public_dispatch","base_size":1975,"alt_size":1895,"ratio":0.959493670886076} +{"name":"router_contract-Router::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"schnorr_account_contract-SchnorrAccount::constructor","base_size":63825,"alt_size":58436,"ratio":0.9155660007833921} +{"name":"schnorr_account_contract-SchnorrAccount::entrypoint","base_size":64808,"alt_size":59230,"ratio":0.9139303789655598} +{"name":"schnorr_account_contract-SchnorrAccount::lookup_validity","base_size":23596,"alt_size":19846,"ratio":0.8410747584336328} +{"name":"schnorr_account_contract-SchnorrAccount::process_log","base_size":15185,"alt_size":12741,"ratio":0.8390516957523872} +{"name":"schnorr_account_contract-SchnorrAccount::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"schnorr_account_contract-SchnorrAccount::verify_private_authwit","base_size":40735,"alt_size":37275,"ratio":0.9150607585614337} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::entrypoint","base_size":46838,"alt_size":43869,"ratio":0.9366112985182972} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::verify_private_authwit","base_size":22056,"alt_size":21162,"ratio":0.9594668117519043} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::entrypoint","base_size":43214,"alt_size":40261,"ratio":0.9316656639052159} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::process_log","base_size":1279,"alt_size":1232,"ratio":0.9632525410476935} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::verify_private_authwit","base_size":18539,"alt_size":17960,"ratio":0.9687685419925562} +{"name":"spam_contract-Spam::process_log","base_size":21685,"alt_size":18058,"ratio":0.8327415264007378} +{"name":"spam_contract-Spam::public_dispatch","base_size":2383,"alt_size":2238,"ratio":0.9391523289970626} +{"name":"spam_contract-Spam::public_spam","base_size":1891,"alt_size":1756,"ratio":0.928609201480698} +{"name":"spam_contract-Spam::spam","base_size":93562,"alt_size":80116,"ratio":0.8562878091532887} +{"name":"spam_contract-Spam::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"stateful_test_contract-StatefulTest::constructor","base_size":23974,"alt_size":21468,"ratio":0.895470092600317} +{"name":"stateful_test_contract-StatefulTest::create_note","base_size":72352,"alt_size":66229,"ratio":0.9153720698805838} +{"name":"stateful_test_contract-StatefulTest::create_note_no_init_check","base_size":72428,"alt_size":66294,"ratio":0.9153089965206826} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create","base_size":442159,"alt_size":408106,"ratio":0.9229847181669942} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create_no_init_check","base_size":442509,"alt_size":408312,"ratio":0.9227202158600164} +{"name":"stateful_test_contract-StatefulTest::get_public_value","base_size":1168,"alt_size":1155,"ratio":0.9888698630136986} +{"name":"stateful_test_contract-StatefulTest::increment_public_value","base_size":1210,"alt_size":1214,"ratio":1.0033057851239668} +{"name":"stateful_test_contract-StatefulTest::increment_public_value_no_init_check","base_size":1124,"alt_size":1123,"ratio":0.9991103202846975} +{"name":"stateful_test_contract-StatefulTest::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"stateful_test_contract-StatefulTest::public_constructor","base_size":3302,"alt_size":2939,"ratio":0.8900666262870988} +{"name":"stateful_test_contract-StatefulTest::public_dispatch","base_size":5855,"alt_size":5030,"ratio":0.8590947907771136} +{"name":"stateful_test_contract-StatefulTest::summed_values","base_size":18915,"alt_size":15975,"ratio":0.8445678033306899} +{"name":"stateful_test_contract-StatefulTest::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"stateful_test_contract-StatefulTest::wrong_constructor","base_size":23814,"alt_size":21239,"ratio":0.8918703283782649} +{"name":"static_child_contract-StaticChild::private_get_value","base_size":51205,"alt_size":46225,"ratio":0.9027438726686847} +{"name":"static_child_contract-StaticChild::private_illegal_set_value","base_size":66528,"alt_size":60801,"ratio":0.9139159451659452} +{"name":"static_child_contract-StaticChild::private_set_value","base_size":66531,"alt_size":60856,"ratio":0.9147014173843772} +{"name":"static_child_contract-StaticChild::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"static_child_contract-StaticChild::pub_get_value","base_size":368,"alt_size":411,"ratio":1.1168478260869565} +{"name":"static_child_contract-StaticChild::pub_illegal_inc_value","base_size":452,"alt_size":506,"ratio":1.1194690265486726} +{"name":"static_child_contract-StaticChild::pub_inc_value","base_size":398,"alt_size":448,"ratio":1.1256281407035176} +{"name":"static_child_contract-StaticChild::pub_set_value","base_size":381,"alt_size":425,"ratio":1.1154855643044619} +{"name":"static_child_contract-StaticChild::public_dispatch","base_size":1380,"alt_size":1323,"ratio":0.9586956521739131} +{"name":"static_child_contract-StaticChild::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"static_parent_contract-StaticParent::enqueue_call","base_size":21794,"alt_size":19213,"ratio":0.8815729099752225} +{"name":"static_parent_contract-StaticParent::enqueue_public_get_value_from_child","base_size":21791,"alt_size":19129,"ratio":0.8778394750126199} +{"name":"static_parent_contract-StaticParent::enqueue_static_call_to_pub_function","base_size":21816,"alt_size":19211,"ratio":0.8805922258892556} +{"name":"static_parent_contract-StaticParent::enqueue_static_nested_call_to_pub_function","base_size":21761,"alt_size":19194,"ratio":0.8820366711088645} +{"name":"static_parent_contract-StaticParent::private_call","base_size":22203,"alt_size":19540,"ratio":0.880061252983831} +{"name":"static_parent_contract-StaticParent::private_call_3_args","base_size":22233,"alt_size":19699,"ratio":0.8860252777402959} +{"name":"static_parent_contract-StaticParent::private_get_value_from_child","base_size":22262,"alt_size":19575,"ratio":0.8793010511184979} +{"name":"static_parent_contract-StaticParent::private_nested_static_call","base_size":22196,"alt_size":19513,"ratio":0.8791223643899801} +{"name":"static_parent_contract-StaticParent::private_nested_static_call_3_args","base_size":22239,"alt_size":19594,"ratio":0.8810647960789604} +{"name":"static_parent_contract-StaticParent::private_static_call","base_size":22212,"alt_size":19558,"ratio":0.8805150369169819} +{"name":"static_parent_contract-StaticParent::private_static_call_3_args","base_size":22221,"alt_size":19656,"ratio":0.8845686512758202} +{"name":"static_parent_contract-StaticParent::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"static_parent_contract-StaticParent::public_call","base_size":764,"alt_size":788,"ratio":1.031413612565445} +{"name":"static_parent_contract-StaticParent::public_dispatch","base_size":2169,"alt_size":1900,"ratio":0.875979714153988} +{"name":"static_parent_contract-StaticParent::public_get_value_from_child","base_size":739,"alt_size":747,"ratio":1.0108254397834913} +{"name":"static_parent_contract-StaticParent::public_nested_static_call","base_size":907,"alt_size":941,"ratio":1.0374862183020948} +{"name":"static_parent_contract-StaticParent::public_static_call","base_size":1203,"alt_size":1208,"ratio":1.0041562759767249} +{"name":"static_parent_contract-StaticParent::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"test_contract-Test::assert_header_private","base_size":29006,"alt_size":25017,"ratio":0.8624767289526305} +{"name":"test_contract-Test::assert_private_global_vars","base_size":28622,"alt_size":24428,"ratio":0.8534693592341556} +{"name":"test_contract-Test::assert_public_global_vars","base_size":529,"alt_size":566,"ratio":1.0699432892249527} +{"name":"test_contract-Test::call_create_note","base_size":77804,"alt_size":70480,"ratio":0.9058660223124775} +{"name":"test_contract-Test::call_destroy_note","base_size":70138,"alt_size":62597,"ratio":0.8924833898885055} +{"name":"test_contract-Test::call_get_notes","base_size":63151,"alt_size":55740,"ratio":0.882646355560482} +{"name":"test_contract-Test::call_get_notes_many","base_size":63327,"alt_size":55662,"ratio":0.8789615803685632} +{"name":"test_contract-Test::call_view_notes","base_size":25455,"alt_size":21163,"ratio":0.8313887252013357} +{"name":"test_contract-Test::call_view_notes_many","base_size":25545,"alt_size":21273,"ratio":0.8327657075748679} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_private","base_size":76738,"alt_size":68935,"ratio":0.8983163491360213} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_public","base_size":5295,"alt_size":4594,"ratio":0.8676109537299339} +{"name":"test_contract-Test::consume_mint_to_private_message","base_size":83889,"alt_size":74977,"ratio":0.8937643791200277} +{"name":"test_contract-Test::consume_mint_to_public_message","base_size":7798,"alt_size":6634,"ratio":0.8507309566555527} +{"name":"test_contract-Test::consume_note_from_secret","base_size":49622,"alt_size":44218,"ratio":0.8910966909838378} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_private","base_size":28597,"alt_size":24520,"ratio":0.8574325978249466} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_public","base_size":244,"alt_size":287,"ratio":1.1762295081967213} +{"name":"test_contract-Test::create_l2_to_l1_message_public","base_size":1739,"alt_size":1597,"ratio":0.9183438757906843} +{"name":"test_contract-Test::deliver_note","base_size":42940,"alt_size":35213,"ratio":0.8200512342803913} +{"name":"test_contract-Test::deploy_contract","base_size":31511,"alt_size":27416,"ratio":0.8700453809780712} +{"name":"test_contract-Test::dummy_public_call","base_size":251,"alt_size":277,"ratio":1.1035856573705178} +{"name":"test_contract-Test::emit_array_as_encrypted_log","base_size":51242,"alt_size":44331,"ratio":0.8651301666601616} +{"name":"test_contract-Test::emit_encrypted_logs_nested","base_size":74253,"alt_size":67298,"ratio":0.9063337508248825} +{"name":"test_contract-Test::emit_nullifier","base_size":28690,"alt_size":24616,"ratio":0.8579993028929941} +{"name":"test_contract-Test::emit_nullifier_public","base_size":216,"alt_size":265,"ratio":1.2268518518518519} +{"name":"test_contract-Test::emit_public","base_size":1104,"alt_size":1097,"ratio":0.9936594202898551} +{"name":"test_contract-Test::get_constant","base_size":24841,"alt_size":20815,"ratio":0.8379292299021779} +{"name":"test_contract-Test::get_master_incoming_viewing_public_key","base_size":30637,"alt_size":26767,"ratio":0.87368214903548} +{"name":"test_contract-Test::get_ovsk_app","base_size":29335,"alt_size":25455,"ratio":0.867734787796148} +{"name":"test_contract-Test::get_this_address","base_size":28810,"alt_size":24849,"ratio":0.86251301631378} +{"name":"test_contract-Test::is_time_equal","base_size":263,"alt_size":308,"ratio":1.1711026615969582} +{"name":"test_contract-Test::process_log","base_size":22628,"alt_size":18662,"ratio":0.8247304224854163} +{"name":"test_contract-Test::public_dispatch","base_size":15395,"alt_size":12722,"ratio":0.826372198765833} +{"name":"test_contract-Test::set_constant","base_size":29956,"alt_size":25838,"ratio":0.8625317131793296} +{"name":"test_contract-Test::set_tx_max_block_number","base_size":29137,"alt_size":25141,"ratio":0.8628547894429763} +{"name":"test_contract-Test::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"test_contract-Test::test_code_gen","base_size":29130,"alt_size":25216,"ratio":0.865636800549262} +{"name":"test_contract-Test::test_nullifier_key_freshness","base_size":30545,"alt_size":26674,"ratio":0.8732689474545752} +{"name":"test_contract-Test::test_setting_fee_payer","base_size":29018,"alt_size":24972,"ratio":0.860569301812668} +{"name":"test_contract-Test::test_setting_teardown","base_size":28984,"alt_size":25007,"ratio":0.8627863648909744} +{"name":"test_log_contract-TestLog::emit_encrypted_events","base_size":100451,"alt_size":92770,"ratio":0.9235348577913609} +{"name":"test_log_contract-TestLog::emit_unencrypted_events","base_size":660,"alt_size":692,"ratio":1.0484848484848486} +{"name":"test_log_contract-TestLog::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"test_log_contract-TestLog::public_dispatch","base_size":1486,"alt_size":1465,"ratio":0.9858681022880216} +{"name":"test_log_contract-TestLog::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"token_blacklist_contract-TokenBlacklist::_increase_public_balance","base_size":2053,"alt_size":1910,"ratio":0.9303458353628836} +{"name":"token_blacklist_contract-TokenBlacklist::_reduce_total_supply","base_size":590,"alt_size":604,"ratio":1.023728813559322} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_private","base_size":23972,"alt_size":20185,"ratio":0.8420240280327048} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_public","base_size":1331,"alt_size":1336,"ratio":1.0037565740045078} +{"name":"token_blacklist_contract-TokenBlacklist::burn","base_size":242678,"alt_size":217041,"ratio":0.8943579558097562} +{"name":"token_blacklist_contract-TokenBlacklist::burn_public","base_size":5682,"alt_size":4849,"ratio":0.8533966913058783} +{"name":"token_blacklist_contract-TokenBlacklist::constructor","base_size":5728,"alt_size":4857,"ratio":0.8479399441340782} +{"name":"token_blacklist_contract-TokenBlacklist::deliver_transparent_note","base_size":36728,"alt_size":30492,"ratio":0.8302112829448922} +{"name":"token_blacklist_contract-TokenBlacklist::get_roles","base_size":1651,"alt_size":1609,"ratio":0.9745608721986675} +{"name":"token_blacklist_contract-TokenBlacklist::mint_private","base_size":2825,"alt_size":2531,"ratio":0.895929203539823} +{"name":"token_blacklist_contract-TokenBlacklist::mint_public","base_size":3773,"alt_size":3293,"ratio":0.8727802809435462} +{"name":"token_blacklist_contract-TokenBlacklist::process_log","base_size":18415,"alt_size":15328,"ratio":0.8323649199022536} +{"name":"token_blacklist_contract-TokenBlacklist::public_dispatch","base_size":47443,"alt_size":36679,"ratio":0.7731172143414202} +{"name":"token_blacklist_contract-TokenBlacklist::redeem_shield","base_size":111972,"alt_size":102713,"ratio":0.9173096845639982} +{"name":"token_blacklist_contract-TokenBlacklist::shield","base_size":6521,"alt_size":5532,"ratio":0.8483361447630732} +{"name":"token_blacklist_contract-TokenBlacklist::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"token_blacklist_contract-TokenBlacklist::total_supply","base_size":451,"alt_size":475,"ratio":1.0532150776053215} +{"name":"token_blacklist_contract-TokenBlacklist::transfer","base_size":232254,"alt_size":206522,"ratio":0.889207505575792} +{"name":"token_blacklist_contract-TokenBlacklist::transfer_public","base_size":7256,"alt_size":6120,"ratio":0.8434399117971334} +{"name":"token_blacklist_contract-TokenBlacklist::unshield","base_size":250684,"alt_size":223341,"ratio":0.8909264253003781} +{"name":"token_blacklist_contract-TokenBlacklist::update_roles","base_size":5149,"alt_size":4392,"ratio":0.8529811613905612} +{"name":"token_bridge_contract-TokenBridge::claim_private","base_size":83472,"alt_size":75695,"ratio":0.9068310331608204} +{"name":"token_bridge_contract-TokenBridge::claim_public","base_size":8503,"alt_size":7210,"ratio":0.8479360225802658} +{"name":"token_bridge_contract-TokenBridge::constructor","base_size":3470,"alt_size":3070,"ratio":0.8847262247838616} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_private","base_size":49518,"alt_size":44831,"ratio":0.9053475503857183} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_public","base_size":3936,"alt_size":3551,"ratio":0.9021849593495935} +{"name":"token_bridge_contract-TokenBridge::get_config","base_size":28069,"alt_size":25554,"ratio":0.9103993729737433} +{"name":"token_bridge_contract-TokenBridge::get_config_public","base_size":428,"alt_size":457,"ratio":1.0677570093457944} +{"name":"token_bridge_contract-TokenBridge::process_log","base_size":14990,"alt_size":12646,"ratio":0.8436290860573716} +{"name":"token_bridge_contract-TokenBridge::public_dispatch","base_size":14968,"alt_size":12379,"ratio":0.8270309994655265} +{"name":"token_bridge_contract-TokenBridge::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"token_contract-Token::_finalize_mint_to_private_unsafe","base_size":3657,"alt_size":3290,"ratio":0.8996445173639596} +{"name":"token_contract-Token::_finalize_transfer_to_private_unsafe","base_size":4160,"alt_size":3660,"ratio":0.8798076923076923} +{"name":"token_contract-Token::_increase_public_balance","base_size":1981,"alt_size":1852,"ratio":0.9348813730439172} +{"name":"token_contract-Token::_recurse_subtract_balance","base_size":104385,"alt_size":90525,"ratio":0.8672223020548929} +{"name":"token_contract-Token::_reduce_total_supply","base_size":559,"alt_size":598,"ratio":1.069767441860465} +{"name":"token_contract-Token::_store_payload_in_transient_storage_unsafe","base_size":1225,"alt_size":1239,"ratio":1.0114285714285713} +{"name":"token_contract-Token::balance_of_private","base_size":19090,"alt_size":16238,"ratio":0.8506024096385543} +{"name":"token_contract-Token::balance_of_public","base_size":1325,"alt_size":1309,"ratio":0.9879245283018868} +{"name":"token_contract-Token::burn_private","base_size":221529,"alt_size":193985,"ratio":0.8756641342668454} +{"name":"token_contract-Token::burn_public","base_size":4361,"alt_size":3810,"ratio":0.8736528319192846} +{"name":"token_contract-Token::cancel_authwit","base_size":21178,"alt_size":18608,"ratio":0.8786476532250449} +{"name":"token_contract-Token::constructor","base_size":6179,"alt_size":5329,"ratio":0.8624372875869882} +{"name":"token_contract-Token::finalize_mint_to_private","base_size":3663,"alt_size":3283,"ratio":0.8962598962598962} +{"name":"token_contract-Token::finalize_transfer_to_private","base_size":4149,"alt_size":3634,"ratio":0.8758737045071101} +{"name":"token_contract-Token::get_admin","base_size":357,"alt_size":385,"ratio":1.0784313725490196} +{"name":"token_contract-Token::is_minter","base_size":1250,"alt_size":1250,"ratio":1} +{"name":"token_contract-Token::mint_to_private","base_size":66807,"alt_size":61019,"ratio":0.9133623722065053} +{"name":"token_contract-Token::mint_to_public","base_size":2601,"alt_size":2338,"ratio":0.8988850442137639} +{"name":"token_contract-Token::prepare_private_balance_increase","base_size":66730,"alt_size":60897,"ratio":0.9125880413607074} +{"name":"token_contract-Token::private_get_decimals","base_size":28018,"alt_size":25380,"ratio":0.9058462417017632} +{"name":"token_contract-Token::private_get_name","base_size":28008,"alt_size":25425,"ratio":0.9077763496143959} +{"name":"token_contract-Token::private_get_symbol","base_size":28000,"alt_size":25493,"ratio":0.9104642857142857} +{"name":"token_contract-Token::process_log","base_size":14990,"alt_size":12646,"ratio":0.8436290860573716} +{"name":"token_contract-Token::public_dispatch","base_size":31918,"alt_size":23909,"ratio":0.7490757566263551} +{"name":"token_contract-Token::public_get_decimals","base_size":384,"alt_size":415,"ratio":1.0807291666666667} +{"name":"token_contract-Token::public_get_name","base_size":374,"alt_size":395,"ratio":1.0561497326203209} +{"name":"token_contract-Token::public_get_symbol","base_size":361,"alt_size":400,"ratio":1.10803324099723} +{"name":"token_contract-Token::set_admin","base_size":386,"alt_size":413,"ratio":1.0699481865284974} +{"name":"token_contract-Token::set_minter","base_size":1278,"alt_size":1266,"ratio":0.9906103286384976} +{"name":"token_contract-Token::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"token_contract-Token::total_supply","base_size":455,"alt_size":494,"ratio":1.0857142857142856} +{"name":"token_contract-Token::transfer","base_size":112636,"alt_size":99747,"ratio":0.8855694449376753} +{"name":"token_contract-Token::transfer_in_private","base_size":277827,"alt_size":248026,"ratio":0.8927354072858289} +{"name":"token_contract-Token::transfer_in_public","base_size":5481,"alt_size":4659,"ratio":0.8500273672687466} +{"name":"token_contract-Token::transfer_to_private","base_size":66934,"alt_size":61241,"ratio":0.9149460662742402} +{"name":"token_contract-Token::transfer_to_public","base_size":221536,"alt_size":194255,"ratio":0.8768552289469883} +{"name":"uniswap_contract-Uniswap::_approve_bridge_and_exit_input_asset_to_L1","base_size":5754,"alt_size":4983,"ratio":0.8660062565172054} +{"name":"uniswap_contract-Uniswap::constructor","base_size":2951,"alt_size":2602,"ratio":0.8817350050830227} +{"name":"uniswap_contract-Uniswap::process_log","base_size":14990,"alt_size":12646,"ratio":0.8436290860573716} +{"name":"uniswap_contract-Uniswap::public_dispatch","base_size":16402,"alt_size":13550,"ratio":0.8261187660041458} +{"name":"uniswap_contract-Uniswap::swap_private","base_size":73024,"alt_size":66303,"ratio":0.9079617659947414} +{"name":"uniswap_contract-Uniswap::swap_public","base_size":8205,"alt_size":6981,"ratio":0.8508226691042048} +{"name":"uniswap_contract-Uniswap::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"updatable_contract-Updatable::get_private_value","base_size":17948,"alt_size":15069,"ratio":0.839592155114776} +{"name":"updatable_contract-Updatable::get_public_value","base_size":16277,"alt_size":13802,"ratio":0.8479449530011673} +{"name":"updatable_contract-Updatable::get_update_delay","base_size":795,"alt_size":817,"ratio":1.0276729559748428} +{"name":"updatable_contract-Updatable::initialize","base_size":68404,"alt_size":62562,"ratio":0.9145956376820069} +{"name":"updatable_contract-Updatable::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"updatable_contract-Updatable::public_dispatch","base_size":1382,"alt_size":1341,"ratio":0.9703328509406657} +{"name":"updatable_contract-Updatable::set_public_value","base_size":327,"alt_size":353,"ratio":1.0795107033639144} +{"name":"updatable_contract-Updatable::set_update_delay","base_size":21724,"alt_size":18958,"ratio":0.8726753820659179} +{"name":"updatable_contract-Updatable::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} +{"name":"updatable_contract-Updatable::update_to","base_size":21742,"alt_size":19217,"ratio":0.8838653297764695} +{"name":"updated_contract-Updated::get_private_value","base_size":17948,"alt_size":15069,"ratio":0.839592155114776} +{"name":"updated_contract-Updated::get_public_value","base_size":16277,"alt_size":13802,"ratio":0.8479449530011673} +{"name":"updated_contract-Updated::get_update_delay","base_size":721,"alt_size":715,"ratio":0.9916782246879334} +{"name":"updated_contract-Updated::process_log","base_size":15217,"alt_size":12719,"ratio":0.8358414930669645} +{"name":"updated_contract-Updated::public_dispatch","base_size":1251,"alt_size":1233,"ratio":0.9856115107913669} +{"name":"updated_contract-Updated::set_private_value","base_size":65472,"alt_size":59871,"ratio":0.9144519794721407} +{"name":"updated_contract-Updated::set_public_value","base_size":231,"alt_size":258,"ratio":1.1168831168831168} +{"name":"updated_contract-Updated::sync_notes","base_size":194,"alt_size":214,"ratio":1.1030927835051547} diff --git a/scripts/bytecode-sizes/bincode-vs-protobuf.png b/scripts/bytecode-sizes/bincode-vs-protobuf.png new file mode 100644 index 00000000000..3af70eb04f2 Binary files /dev/null and b/scripts/bytecode-sizes/bincode-vs-protobuf.png differ diff --git a/scripts/bytecode-sizes/bincode.jsonl b/scripts/bytecode-sizes/bincode.jsonl new file mode 100644 index 00000000000..a282a80873f --- /dev/null +++ b/scripts/bytecode-sizes/bincode.jsonl @@ -0,0 +1,645 @@ +{"name":"parity_base","bytecode_size":38512} +{"name":"parity_root","bytecode_size":56652} +{"name":"private_kernel_init","bytecode_size":220749} +{"name":"private_kernel_init_simulated","bytecode_size":58621} +{"name":"private_kernel_inner","bytecode_size":359771} +{"name":"private_kernel_inner_simulated","bytecode_size":85524} +{"name":"private_kernel_reset","bytecode_size":900112} +{"name":"private_kernel_reset_simulated","bytecode_size":109029} +{"name":"private_kernel_tail","bytecode_size":119498} +{"name":"private_kernel_tail_simulated","bytecode_size":47093} +{"name":"private_kernel_tail_to_public","bytecode_size":213327} +{"name":"private_kernel_tail_to_public_simulated","bytecode_size":68973} +{"name":"rollup_base_private","bytecode_size":1357393} +{"name":"rollup_base_private_simulated","bytecode_size":81131} +{"name":"rollup_base_public","bytecode_size":679496} +{"name":"rollup_base_public_simulated","bytecode_size":76651} +{"name":"rollup_block_merge","bytecode_size":109324} +{"name":"rollup_block_root","bytecode_size":15014428} +{"name":"rollup_block_root_empty","bytecode_size":20689} +{"name":"rollup_block_root_simulated","bytecode_size":80510} +{"name":"rollup_block_root_single_tx","bytecode_size":14998279} +{"name":"rollup_block_root_single_tx_simulated","bytecode_size":75036} +{"name":"rollup_merge","bytecode_size":29269} +{"name":"rollup_root","bytecode_size":109168} +{"name":"amm_contract-AMM::_add_liquidity","bytecode_size":7625} +{"name":"amm_contract-AMM::_remove_liquidity","bytecode_size":4889} +{"name":"amm_contract-AMM::_swap_exact_tokens_for_tokens","bytecode_size":3868} +{"name":"amm_contract-AMM::_swap_tokens_for_exact_tokens","bytecode_size":4286} +{"name":"amm_contract-AMM::add_liquidity","bytecode_size":31680} +{"name":"amm_contract-AMM::constructor","bytecode_size":3706} +{"name":"amm_contract-AMM::get_amount_in_for_exact_out","bytecode_size":18139} +{"name":"amm_contract-AMM::get_amount_out_for_exact_in","bytecode_size":18109} +{"name":"amm_contract-AMM::process_log","bytecode_size":14990} +{"name":"amm_contract-AMM::public_dispatch","bytecode_size":20783} +{"name":"amm_contract-AMM::remove_liquidity","bytecode_size":29548} +{"name":"amm_contract-AMM::swap_exact_tokens_for_tokens","bytecode_size":29442} +{"name":"amm_contract-AMM::swap_tokens_for_exact_tokens","bytecode_size":29711} +{"name":"amm_contract-AMM::sync_notes","bytecode_size":194} +{"name":"app_subscription_contract-AppSubscription::constructor","bytecode_size":4391} +{"name":"app_subscription_contract-AppSubscription::entrypoint","bytecode_size":97890} +{"name":"app_subscription_contract-AppSubscription::is_initialized","bytecode_size":23855} +{"name":"app_subscription_contract-AppSubscription::process_log","bytecode_size":21713} +{"name":"app_subscription_contract-AppSubscription::public_dispatch","bytecode_size":4867} +{"name":"app_subscription_contract-AppSubscription::subscribe","bytecode_size":94665} +{"name":"app_subscription_contract-AppSubscription::sync_notes","bytecode_size":194} +{"name":"auth_contract-Auth::constructor","bytecode_size":2999} +{"name":"auth_contract-Auth::do_private_authorized_thing","bytecode_size":12981} +{"name":"auth_contract-Auth::get_authorized","bytecode_size":809} +{"name":"auth_contract-Auth::get_authorized_delay","bytecode_size":663} +{"name":"auth_contract-Auth::get_authorized_in_private","bytecode_size":13312} +{"name":"auth_contract-Auth::get_scheduled_authorized","bytecode_size":728} +{"name":"auth_contract-Auth::process_log","bytecode_size":1279} +{"name":"auth_contract-Auth::public_dispatch","bytecode_size":9711} +{"name":"auth_contract-Auth::set_authorized","bytecode_size":3456} +{"name":"auth_contract-Auth::set_authorized_delay","bytecode_size":3474} +{"name":"auth_contract-Auth::sync_notes","bytecode_size":194} +{"name":"auth_registry_contract-AuthRegistry::_set_authorized","bytecode_size":1765} +{"name":"auth_registry_contract-AuthRegistry::consume","bytecode_size":3880} +{"name":"auth_registry_contract-AuthRegistry::is_consumable","bytecode_size":1755} +{"name":"auth_registry_contract-AuthRegistry::is_reject_all","bytecode_size":1175} +{"name":"auth_registry_contract-AuthRegistry::process_log","bytecode_size":1279} +{"name":"auth_registry_contract-AuthRegistry::public_dispatch","bytecode_size":7739} +{"name":"auth_registry_contract-AuthRegistry::set_authorized","bytecode_size":1700} +{"name":"auth_registry_contract-AuthRegistry::set_authorized_private","bytecode_size":5829} +{"name":"auth_registry_contract-AuthRegistry::set_reject_all","bytecode_size":1116} +{"name":"auth_registry_contract-AuthRegistry::sync_notes","bytecode_size":194} +{"name":"auth_registry_contract-AuthRegistry::unconstrained_is_consumable","bytecode_size":1740} +{"name":"auth_wit_test_contract-AuthWitTest::consume","bytecode_size":5402} +{"name":"auth_wit_test_contract-AuthWitTest::consume_public","bytecode_size":750} +{"name":"auth_wit_test_contract-AuthWitTest::process_log","bytecode_size":1279} +{"name":"auth_wit_test_contract-AuthWitTest::public_dispatch","bytecode_size":1306} +{"name":"auth_wit_test_contract-AuthWitTest::sync_notes","bytecode_size":194} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_f1600","bytecode_size":712} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_hash","bytecode_size":2062} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash","bytecode_size":2741} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash_with_index","bytecode_size":2716} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::poseidon2_hash","bytecode_size":1631} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::process_log","bytecode_size":1279} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::public_dispatch","bytecode_size":38983} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_10","bytecode_size":2490} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_100","bytecode_size":3910} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_20","bytecode_size":2503} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_2048","bytecode_size":22473} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_255","bytecode_size":5854} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_256","bytecode_size":5530} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_30","bytecode_size":2673} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_40","bytecode_size":2761} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_50","bytecode_size":2931} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_511","bytecode_size":8537} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_512","bytecode_size":8154} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_60","bytecode_size":2998} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_70","bytecode_size":3666} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_80","bytecode_size":3610} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_90","bytecode_size":3789} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sync_notes","bytecode_size":194} +{"name":"avm_initializer_test_contract-AvmInitializerTest::constructor","bytecode_size":2460} +{"name":"avm_initializer_test_contract-AvmInitializerTest::process_log","bytecode_size":1279} +{"name":"avm_initializer_test_contract-AvmInitializerTest::public_dispatch","bytecode_size":3088} +{"name":"avm_initializer_test_contract-AvmInitializerTest::read_storage_immutable","bytecode_size":321} +{"name":"avm_initializer_test_contract-AvmInitializerTest::sync_notes","bytecode_size":194} +{"name":"avm_test_contract-AvmTest::add_args_return","bytecode_size":228} +{"name":"avm_test_contract-AvmTest::add_storage_map","bytecode_size":2301} +{"name":"avm_test_contract-AvmTest::add_u128","bytecode_size":345} +{"name":"avm_test_contract-AvmTest::assert_calldata_copy","bytecode_size":615} +{"name":"avm_test_contract-AvmTest::assert_nullifier_exists","bytecode_size":286} +{"name":"avm_test_contract-AvmTest::assert_same","bytecode_size":254} +{"name":"avm_test_contract-AvmTest::assertion_failure","bytecode_size":213} +{"name":"avm_test_contract-AvmTest::bulk_testing","bytecode_size":18275} +{"name":"avm_test_contract-AvmTest::create_different_nullifier_in_nested_call","bytecode_size":737} +{"name":"avm_test_contract-AvmTest::create_same_nullifier_in_nested_call","bytecode_size":706} +{"name":"avm_test_contract-AvmTest::debug_logging","bytecode_size":1075} +{"name":"avm_test_contract-AvmTest::divide_by_zero","bytecode_size":209} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add","bytecode_size":646} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add_and_double","bytecode_size":323} +{"name":"avm_test_contract-AvmTest::emit_nullifier_and_check","bytecode_size":310} +{"name":"avm_test_contract-AvmTest::emit_public_log","bytecode_size":2015} +{"name":"avm_test_contract-AvmTest::enqueue_public_from_private","bytecode_size":5008} +{"name":"avm_test_contract-AvmTest::external_call_to_assertion_failure","bytecode_size":663} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero","bytecode_size":673} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero_recovers","bytecode_size":2199} +{"name":"avm_test_contract-AvmTest::get_address","bytecode_size":212} +{"name":"avm_test_contract-AvmTest::get_args_hash","bytecode_size":1754} +{"name":"avm_test_contract-AvmTest::get_block_number","bytecode_size":216} +{"name":"avm_test_contract-AvmTest::get_chain_id","bytecode_size":210} +{"name":"avm_test_contract-AvmTest::get_da_gas_left","bytecode_size":216} +{"name":"avm_test_contract-AvmTest::get_fee_per_da_gas","bytecode_size":218} +{"name":"avm_test_contract-AvmTest::get_fee_per_l2_gas","bytecode_size":216} +{"name":"avm_test_contract-AvmTest::get_l2_gas_left","bytecode_size":215} +{"name":"avm_test_contract-AvmTest::get_sender","bytecode_size":214} +{"name":"avm_test_contract-AvmTest::get_timestamp","bytecode_size":220} +{"name":"avm_test_contract-AvmTest::get_transaction_fee","bytecode_size":219} +{"name":"avm_test_contract-AvmTest::get_version","bytecode_size":216} +{"name":"avm_test_contract-AvmTest::helper_with_failed_assertion","bytecode_size":111} +{"name":"avm_test_contract-AvmTest::inner_helper_with_failed_assertion","bytecode_size":111} +{"name":"avm_test_contract-AvmTest::l1_to_l2_msg_exists","bytecode_size":266} +{"name":"avm_test_contract-AvmTest::modulo2","bytecode_size":216} +{"name":"avm_test_contract-AvmTest::n_new_l2_to_l1_msgs","bytecode_size":279} +{"name":"avm_test_contract-AvmTest::n_new_note_hashes","bytecode_size":280} +{"name":"avm_test_contract-AvmTest::n_new_nullifiers","bytecode_size":279} +{"name":"avm_test_contract-AvmTest::n_new_public_logs","bytecode_size":386} +{"name":"avm_test_contract-AvmTest::n_storage_writes","bytecode_size":1170} +{"name":"avm_test_contract-AvmTest::nested_call_to_add","bytecode_size":731} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_n_times_different_addresses","bytecode_size":1092} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_with_gas","bytecode_size":690} +{"name":"avm_test_contract-AvmTest::nested_call_to_assert_same","bytecode_size":734} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing","bytecode_size":667} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing_recovers","bytecode_size":414} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_add","bytecode_size":751} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_set_storage","bytecode_size":698} +{"name":"avm_test_contract-AvmTest::new_note_hash","bytecode_size":224} +{"name":"avm_test_contract-AvmTest::new_nullifier","bytecode_size":216} +{"name":"avm_test_contract-AvmTest::note_hash_exists","bytecode_size":266} +{"name":"avm_test_contract-AvmTest::nullifier_collision","bytecode_size":230} +{"name":"avm_test_contract-AvmTest::nullifier_exists","bytecode_size":265} +{"name":"avm_test_contract-AvmTest::pedersen_commit","bytecode_size":1176} +{"name":"avm_test_contract-AvmTest::process_log","bytecode_size":1279} +{"name":"avm_test_contract-AvmTest::public_dispatch","bytecode_size":39496} +{"name":"avm_test_contract-AvmTest::read_assert_storage_single","bytecode_size":266} +{"name":"avm_test_contract-AvmTest::read_storage_list","bytecode_size":392} +{"name":"avm_test_contract-AvmTest::read_storage_map","bytecode_size":1126} +{"name":"avm_test_contract-AvmTest::read_storage_single","bytecode_size":231} +{"name":"avm_test_contract-AvmTest::return_oracle","bytecode_size":510} +{"name":"avm_test_contract-AvmTest::returndata_copy_oracle","bytecode_size":1359} +{"name":"avm_test_contract-AvmTest::revert_oracle","bytecode_size":496} +{"name":"avm_test_contract-AvmTest::send_l2_to_l1_msg","bytecode_size":244} +{"name":"avm_test_contract-AvmTest::set_opcode_big_field","bytecode_size":214} +{"name":"avm_test_contract-AvmTest::set_opcode_really_big_field","bytecode_size":211} +{"name":"avm_test_contract-AvmTest::set_opcode_small_field","bytecode_size":211} +{"name":"avm_test_contract-AvmTest::set_opcode_u32","bytecode_size":196} +{"name":"avm_test_contract-AvmTest::set_opcode_u64","bytecode_size":195} +{"name":"avm_test_contract-AvmTest::set_opcode_u8","bytecode_size":187} +{"name":"avm_test_contract-AvmTest::set_read_storage_single","bytecode_size":262} +{"name":"avm_test_contract-AvmTest::set_storage_list","bytecode_size":264} +{"name":"avm_test_contract-AvmTest::set_storage_map","bytecode_size":1641} +{"name":"avm_test_contract-AvmTest::set_storage_single","bytecode_size":230} +{"name":"avm_test_contract-AvmTest::sync_notes","bytecode_size":194} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance","bytecode_size":540} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance_matches","bytecode_size":564} +{"name":"avm_test_contract-AvmTest::to_radix_le","bytecode_size":472} +{"name":"avm_test_contract-AvmTest::u128_addition_overflow","bytecode_size":1031} +{"name":"avm_test_contract-AvmTest::u128_from_integer_overflow","bytecode_size":606} +{"name":"avm_test_contract-AvmTest::variable_base_msm","bytecode_size":552} +{"name":"benchmarking_contract-Benchmarking::broadcast","bytecode_size":1220} +{"name":"benchmarking_contract-Benchmarking::create_note","bytecode_size":70351} +{"name":"benchmarking_contract-Benchmarking::increment_balance","bytecode_size":2192} +{"name":"benchmarking_contract-Benchmarking::process_log","bytecode_size":15217} +{"name":"benchmarking_contract-Benchmarking::public_dispatch","bytecode_size":6088} +{"name":"benchmarking_contract-Benchmarking::recreate_note","bytecode_size":88826} +{"name":"benchmarking_contract-Benchmarking::sha256_hash_2048","bytecode_size":22473} +{"name":"benchmarking_contract-Benchmarking::sync_notes","bytecode_size":194} +{"name":"card_game_contract-CardGame::buy_pack","bytecode_size":120474} +{"name":"card_game_contract-CardGame::claim_cards","bytecode_size":149592} +{"name":"card_game_contract-CardGame::join_game","bytecode_size":320433} +{"name":"card_game_contract-CardGame::on_card_played","bytecode_size":3419} +{"name":"card_game_contract-CardGame::on_cards_claimed","bytecode_size":4303} +{"name":"card_game_contract-CardGame::on_game_joined","bytecode_size":2520} +{"name":"card_game_contract-CardGame::play_card","bytecode_size":231201} +{"name":"card_game_contract-CardGame::process_log","bytecode_size":15217} +{"name":"card_game_contract-CardGame::public_dispatch","bytecode_size":12329} +{"name":"card_game_contract-CardGame::start_game","bytecode_size":3695} +{"name":"card_game_contract-CardGame::sync_notes","bytecode_size":194} +{"name":"card_game_contract-CardGame::view_collection_cards","bytecode_size":19089} +{"name":"card_game_contract-CardGame::view_game","bytecode_size":17867} +{"name":"card_game_contract-CardGame::view_game_cards","bytecode_size":19604} +{"name":"child_contract-Child::private_get_value","bytecode_size":44558} +{"name":"child_contract-Child::private_set_value","bytecode_size":70478} +{"name":"child_contract-Child::process_log","bytecode_size":15217} +{"name":"child_contract-Child::pub_get_value","bytecode_size":304} +{"name":"child_contract-Child::pub_inc_value","bytecode_size":398} +{"name":"child_contract-Child::pub_inc_value_internal","bytecode_size":457} +{"name":"child_contract-Child::pub_set_value","bytecode_size":381} +{"name":"child_contract-Child::public_dispatch","bytecode_size":2840} +{"name":"child_contract-Child::set_value_twice_with_nested_first","bytecode_size":838} +{"name":"child_contract-Child::set_value_twice_with_nested_last","bytecode_size":847} +{"name":"child_contract-Child::set_value_with_two_nested_calls","bytecode_size":1091} +{"name":"child_contract-Child::sync_notes","bytecode_size":194} +{"name":"child_contract-Child::value","bytecode_size":21446} +{"name":"child_contract-Child::value_internal","bytecode_size":21571} +{"name":"claim_contract-Claim::claim","bytecode_size":40340} +{"name":"claim_contract-Claim::constructor","bytecode_size":3758} +{"name":"claim_contract-Claim::process_log","bytecode_size":14990} +{"name":"claim_contract-Claim::public_dispatch","bytecode_size":4157} +{"name":"claim_contract-Claim::sync_notes","bytecode_size":194} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::assert_class_id_is_registered","bytecode_size":4047} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_private_function","bytecode_size":20389} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_unconstrained_function","bytecode_size":20346} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::process_log","bytecode_size":1279} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::register","bytecode_size":221551} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::sync_notes","bytecode_size":194} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::deploy","bytecode_size":7639} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::get_update_delay","bytecode_size":1468} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::process_log","bytecode_size":1279} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::public_dispatch","bytecode_size":8605} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::set_update_delay","bytecode_size":4056} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::sync_notes","bytecode_size":194} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::update","bytecode_size":4242} +{"name":"counter_contract-Counter::decrement","bytecode_size":225585} +{"name":"counter_contract-Counter::get_counter","bytecode_size":18915} +{"name":"counter_contract-Counter::increment","bytecode_size":66762} +{"name":"counter_contract-Counter::increment_and_decrement","bytecode_size":240819} +{"name":"counter_contract-Counter::increment_twice","bytecode_size":81927} +{"name":"counter_contract-Counter::initialize","bytecode_size":71829} +{"name":"counter_contract-Counter::process_log","bytecode_size":15217} +{"name":"counter_contract-Counter::sync_notes","bytecode_size":194} +{"name":"crowdfunding_contract-Crowdfunding::_publish_donation_receipts","bytecode_size":532} +{"name":"crowdfunding_contract-Crowdfunding::donate","bytecode_size":72839} +{"name":"crowdfunding_contract-Crowdfunding::init","bytecode_size":3739} +{"name":"crowdfunding_contract-Crowdfunding::process_log","bytecode_size":14990} +{"name":"crowdfunding_contract-Crowdfunding::public_dispatch","bytecode_size":4552} +{"name":"crowdfunding_contract-Crowdfunding::sync_notes","bytecode_size":194} +{"name":"crowdfunding_contract-Crowdfunding::withdraw","bytecode_size":28753} +{"name":"docs_example_contract-DocsExample::get_imm_card","bytecode_size":23052} +{"name":"docs_example_contract-DocsExample::get_leader","bytecode_size":16334} +{"name":"docs_example_contract-DocsExample::get_legendary_card","bytecode_size":18029} +{"name":"docs_example_contract-DocsExample::get_public_immutable","bytecode_size":16281} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private","bytecode_size":28315} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private_indirect","bytecode_size":22294} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public","bytecode_size":345} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_indirect","bytecode_size":796} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_multiple","bytecode_size":425} +{"name":"docs_example_contract-DocsExample::increase_legendary_points","bytecode_size":73255} +{"name":"docs_example_contract-DocsExample::initialize_private","bytecode_size":66305} +{"name":"docs_example_contract-DocsExample::initialize_private_immutable","bytecode_size":66365} +{"name":"docs_example_contract-DocsExample::initialize_public_immutable","bytecode_size":1234} +{"name":"docs_example_contract-DocsExample::insert_note","bytecode_size":66297} +{"name":"docs_example_contract-DocsExample::insert_notes","bytecode_size":93012} +{"name":"docs_example_contract-DocsExample::is_legendary_initialized","bytecode_size":16998} +{"name":"docs_example_contract-DocsExample::is_priv_imm_initialized","bytecode_size":16949} +{"name":"docs_example_contract-DocsExample::match_public_immutable","bytecode_size":28092} +{"name":"docs_example_contract-DocsExample::process_log","bytecode_size":15194} +{"name":"docs_example_contract-DocsExample::public_dispatch","bytecode_size":3396} +{"name":"docs_example_contract-DocsExample::read_note","bytecode_size":18339} +{"name":"docs_example_contract-DocsExample::simple_macro_example","bytecode_size":21432} +{"name":"docs_example_contract-DocsExample::simple_macro_example_expanded","bytecode_size":4637} +{"name":"docs_example_contract-DocsExample::spend_public_authwit","bytecode_size":197} +{"name":"docs_example_contract-DocsExample::sync_notes","bytecode_size":194} +{"name":"docs_example_contract-DocsExample::update_leader","bytecode_size":347} +{"name":"docs_example_contract-DocsExample::update_legendary_card","bytecode_size":69920} +{"name":"docs_example_contract-DocsExample::verify_private_authwit","bytecode_size":21543} +{"name":"docs_example_contract-DocsExample::view_imm_card","bytecode_size":17928} +{"name":"easy_private_token_contract-EasyPrivateToken::constructor","bytecode_size":71829} +{"name":"easy_private_token_contract-EasyPrivateToken::get_balance","bytecode_size":18915} +{"name":"easy_private_token_contract-EasyPrivateToken::mint","bytecode_size":70288} +{"name":"easy_private_token_contract-EasyPrivateToken::process_log","bytecode_size":15217} +{"name":"easy_private_token_contract-EasyPrivateToken::sync_notes","bytecode_size":194} +{"name":"easy_private_token_contract-EasyPrivateToken::transfer","bytecode_size":266118} +{"name":"easy_private_voting_contract-EasyPrivateVoting::add_to_tally_public","bytecode_size":1874} +{"name":"easy_private_voting_contract-EasyPrivateVoting::cast_vote","bytecode_size":7724} +{"name":"easy_private_voting_contract-EasyPrivateVoting::constructor","bytecode_size":3010} +{"name":"easy_private_voting_contract-EasyPrivateVoting::end_vote","bytecode_size":380} +{"name":"easy_private_voting_contract-EasyPrivateVoting::get_vote","bytecode_size":1250} +{"name":"easy_private_voting_contract-EasyPrivateVoting::process_log","bytecode_size":1279} +{"name":"easy_private_voting_contract-EasyPrivateVoting::public_dispatch","bytecode_size":4819} +{"name":"easy_private_voting_contract-EasyPrivateVoting::sync_notes","bytecode_size":194} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::constructor","bytecode_size":76386} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::entrypoint","bytecode_size":65077} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::process_log","bytecode_size":16856} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::sync_notes","bytecode_size":194} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::verify_private_authwit","bytecode_size":41083} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::constructor","bytecode_size":76386} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::entrypoint","bytecode_size":65012} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::process_log","bytecode_size":16856} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::sync_notes","bytecode_size":194} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::verify_private_authwit","bytecode_size":41159} +{"name":"escrow_contract-Escrow::constructor","bytecode_size":70295} +{"name":"escrow_contract-Escrow::process_log","bytecode_size":21724} +{"name":"escrow_contract-Escrow::sync_notes","bytecode_size":194} +{"name":"escrow_contract-Escrow::withdraw","bytecode_size":29895} +{"name":"fee_juice_contract-FeeJuice::_increase_public_balance","bytecode_size":1971} +{"name":"fee_juice_contract-FeeJuice::balance_of_public","bytecode_size":1256} +{"name":"fee_juice_contract-FeeJuice::check_balance","bytecode_size":1470} +{"name":"fee_juice_contract-FeeJuice::claim","bytecode_size":73213} +{"name":"fee_juice_contract-FeeJuice::initialize","bytecode_size":5884} +{"name":"fee_juice_contract-FeeJuice::process_log","bytecode_size":1279} +{"name":"fee_juice_contract-FeeJuice::public_dispatch","bytecode_size":4470} +{"name":"fee_juice_contract-FeeJuice::set_portal","bytecode_size":1132} +{"name":"fee_juice_contract-FeeJuice::sync_notes","bytecode_size":194} +{"name":"fpc_contract-FPC::complete_refund","bytecode_size":1253} +{"name":"fpc_contract-FPC::constructor","bytecode_size":3470} +{"name":"fpc_contract-FPC::fee_entrypoint_private","bytecode_size":29614} +{"name":"fpc_contract-FPC::fee_entrypoint_public","bytecode_size":29279} +{"name":"fpc_contract-FPC::get_accepted_asset","bytecode_size":27995} +{"name":"fpc_contract-FPC::pay_refund","bytecode_size":1258} +{"name":"fpc_contract-FPC::process_log","bytecode_size":14990} +{"name":"fpc_contract-FPC::public_dispatch","bytecode_size":6698} +{"name":"fpc_contract-FPC::pull_funds","bytecode_size":1274} +{"name":"fpc_contract-FPC::sync_notes","bytecode_size":194} +{"name":"import_test_contract-ImportTest::call_no_args","bytecode_size":29353} +{"name":"import_test_contract-ImportTest::call_public_fn","bytecode_size":29081} +{"name":"import_test_contract-ImportTest::main_contract","bytecode_size":29560} +{"name":"import_test_contract-ImportTest::process_log","bytecode_size":22624} +{"name":"import_test_contract-ImportTest::pub_call_public_fn","bytecode_size":676} +{"name":"import_test_contract-ImportTest::public_dispatch","bytecode_size":1193} +{"name":"import_test_contract-ImportTest::sync_notes","bytecode_size":194} +{"name":"inclusion_proofs_contract-InclusionProofs::constructor","bytecode_size":2438} +{"name":"inclusion_proofs_contract-InclusionProofs::create_note","bytecode_size":70288} +{"name":"inclusion_proofs_contract-InclusionProofs::nullify_note","bytecode_size":40221} +{"name":"inclusion_proofs_contract-InclusionProofs::process_log","bytecode_size":15217} +{"name":"inclusion_proofs_contract-InclusionProofs::public_dispatch","bytecode_size":3191} +{"name":"inclusion_proofs_contract-InclusionProofs::push_nullifier_public","bytecode_size":309} +{"name":"inclusion_proofs_contract-InclusionProofs::sync_notes","bytecode_size":194} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_inclusion","bytecode_size":34455} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_non_inclusion","bytecode_size":38255} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion","bytecode_size":46528} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion_fail_case","bytecode_size":30784} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_not_nullified","bytecode_size":51153} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_validity","bytecode_size":54502} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion","bytecode_size":31090} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion_from_public","bytecode_size":313} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read","bytecode_size":33182} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read_unset_slot","bytecode_size":33284} +{"name":"lending_contract-Lending::_borrow","bytecode_size":7859} +{"name":"lending_contract-Lending::_deposit","bytecode_size":2099} +{"name":"lending_contract-Lending::_repay","bytecode_size":5363} +{"name":"lending_contract-Lending::_withdraw","bytecode_size":7231} +{"name":"lending_contract-Lending::borrow_private","bytecode_size":22405} +{"name":"lending_contract-Lending::borrow_public","bytecode_size":803} +{"name":"lending_contract-Lending::constructor","bytecode_size":23175} +{"name":"lending_contract-Lending::deposit_private","bytecode_size":22852} +{"name":"lending_contract-Lending::deposit_public","bytecode_size":1111} +{"name":"lending_contract-Lending::get_asset","bytecode_size":1626} +{"name":"lending_contract-Lending::get_assets","bytecode_size":522} +{"name":"lending_contract-Lending::get_position","bytecode_size":4377} +{"name":"lending_contract-Lending::init","bytecode_size":1953} +{"name":"lending_contract-Lending::process_log","bytecode_size":14990} +{"name":"lending_contract-Lending::public_dispatch","bytecode_size":30559} +{"name":"lending_contract-Lending::repay_private","bytecode_size":22836} +{"name":"lending_contract-Lending::repay_public","bytecode_size":1161} +{"name":"lending_contract-Lending::sync_notes","bytecode_size":194} +{"name":"lending_contract-Lending::update_accumulator","bytecode_size":6414} +{"name":"lending_contract-Lending::withdraw_private","bytecode_size":22427} +{"name":"lending_contract-Lending::withdraw_public","bytecode_size":799} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::entrypoint","bytecode_size":18038} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::process_log","bytecode_size":1279} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::sync_notes","bytecode_size":194} +{"name":"nft_contract-NFT::_finalize_transfer_to_private_unsafe","bytecode_size":3569} +{"name":"nft_contract-NFT::_finish_transfer_to_public","bytecode_size":1257} +{"name":"nft_contract-NFT::_store_payload_in_transient_storage_unsafe","bytecode_size":1225} +{"name":"nft_contract-NFT::cancel_authwit","bytecode_size":21085} +{"name":"nft_contract-NFT::constructor","bytecode_size":5748} +{"name":"nft_contract-NFT::finalize_transfer_to_private","bytecode_size":3528} +{"name":"nft_contract-NFT::get_admin","bytecode_size":367} +{"name":"nft_contract-NFT::get_private_nfts","bytecode_size":20050} +{"name":"nft_contract-NFT::is_minter","bytecode_size":1258} +{"name":"nft_contract-NFT::mint","bytecode_size":2560} +{"name":"nft_contract-NFT::owner_of","bytecode_size":1822} +{"name":"nft_contract-NFT::prepare_private_balance_increase","bytecode_size":66456} +{"name":"nft_contract-NFT::private_get_name","bytecode_size":27793} +{"name":"nft_contract-NFT::private_get_symbol","bytecode_size":27949} +{"name":"nft_contract-NFT::process_log","bytecode_size":14925} +{"name":"nft_contract-NFT::public_dispatch","bytecode_size":20493} +{"name":"nft_contract-NFT::public_get_name","bytecode_size":375} +{"name":"nft_contract-NFT::public_get_symbol","bytecode_size":347} +{"name":"nft_contract-NFT::set_admin","bytecode_size":376} +{"name":"nft_contract-NFT::set_minter","bytecode_size":1277} +{"name":"nft_contract-NFT::sync_notes","bytecode_size":194} +{"name":"nft_contract-NFT::transfer_in_private","bytecode_size":98892} +{"name":"nft_contract-NFT::transfer_in_public","bytecode_size":3751} +{"name":"nft_contract-NFT::transfer_to_private","bytecode_size":66845} +{"name":"nft_contract-NFT::transfer_to_public","bytecode_size":50192} +{"name":"parent_contract-Parent::enqueue_call_to_child","bytecode_size":21821} +{"name":"parent_contract-Parent::enqueue_call_to_child_twice","bytecode_size":21917} +{"name":"parent_contract-Parent::enqueue_call_to_pub_entry_point","bytecode_size":21770} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_first","bytecode_size":22238} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_last","bytecode_size":22298} +{"name":"parent_contract-Parent::enqueue_calls_to_pub_entry_point","bytecode_size":21848} +{"name":"parent_contract-Parent::enqueue_static_call_to_pub_function","bytecode_size":21816} +{"name":"parent_contract-Parent::enqueue_static_nested_call_to_pub_function","bytecode_size":21801} +{"name":"parent_contract-Parent::entry_point","bytecode_size":22184} +{"name":"parent_contract-Parent::private_call","bytecode_size":22203} +{"name":"parent_contract-Parent::private_nested_static_call","bytecode_size":22182} +{"name":"parent_contract-Parent::private_static_call","bytecode_size":22212} +{"name":"parent_contract-Parent::process_log","bytecode_size":15217} +{"name":"parent_contract-Parent::pub_entry_point","bytecode_size":764} +{"name":"parent_contract-Parent::pub_entry_point_twice","bytecode_size":1045} +{"name":"parent_contract-Parent::public_dispatch","bytecode_size":4044} +{"name":"parent_contract-Parent::public_nested_static_call","bytecode_size":2669} +{"name":"parent_contract-Parent::public_static_call","bytecode_size":1203} +{"name":"parent_contract-Parent::sync_notes","bytecode_size":194} +{"name":"pending_note_hashes_contract-PendingNoteHashes::dummy","bytecode_size":21162} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_note_zero_balance","bytecode_size":55883} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_then_nullify_note","bytecode_size":40328} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note","bytecode_size":70375} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_extra_emit","bytecode_size":81538} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_static_randomness","bytecode_size":66298} +{"name":"pending_note_hashes_contract-PendingNoteHashes::process_log","bytecode_size":15217} +{"name":"pending_note_hashes_contract-PendingNoteHashes::recursively_destroy_and_create_notes","bytecode_size":422819} +{"name":"pending_note_hashes_contract-PendingNoteHashes::sync_notes","bytecode_size":194} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_bad_get_then_insert_flat","bytecode_size":87596} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_emit_bad_note_log","bytecode_size":81383} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert1_then_get2_then_nullify2_all_in_nested_calls","bytecode_size":22210} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify1_all_in_nested_calls","bytecode_size":22217} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify2_all_in_nested_calls","bytecode_size":22276} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_all_in_nested_calls","bytecode_size":22085} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_flat","bytecode_size":224467} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_recursively_create_notes","bytecode_size":299229} +{"name":"price_feed_contract-PriceFeed::get_price","bytecode_size":1230} +{"name":"price_feed_contract-PriceFeed::process_log","bytecode_size":1279} +{"name":"price_feed_contract-PriceFeed::public_dispatch","bytecode_size":2473} +{"name":"price_feed_contract-PriceFeed::set_price","bytecode_size":1137} +{"name":"price_feed_contract-PriceFeed::sync_notes","bytecode_size":194} +{"name":"router_contract-Router::_check_block_number","bytecode_size":995} +{"name":"router_contract-Router::_check_timestamp","bytecode_size":1030} +{"name":"router_contract-Router::check_block_number","bytecode_size":4928} +{"name":"router_contract-Router::check_timestamp","bytecode_size":4944} +{"name":"router_contract-Router::process_log","bytecode_size":1279} +{"name":"router_contract-Router::public_dispatch","bytecode_size":1975} +{"name":"router_contract-Router::sync_notes","bytecode_size":194} +{"name":"schnorr_account_contract-SchnorrAccount::constructor","bytecode_size":63825} +{"name":"schnorr_account_contract-SchnorrAccount::entrypoint","bytecode_size":64808} +{"name":"schnorr_account_contract-SchnorrAccount::lookup_validity","bytecode_size":23596} +{"name":"schnorr_account_contract-SchnorrAccount::process_log","bytecode_size":15185} +{"name":"schnorr_account_contract-SchnorrAccount::sync_notes","bytecode_size":194} +{"name":"schnorr_account_contract-SchnorrAccount::verify_private_authwit","bytecode_size":40735} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::entrypoint","bytecode_size":46838} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::process_log","bytecode_size":1279} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::sync_notes","bytecode_size":194} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::verify_private_authwit","bytecode_size":22056} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::entrypoint","bytecode_size":43214} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::process_log","bytecode_size":1279} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::sync_notes","bytecode_size":194} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::verify_private_authwit","bytecode_size":18539} +{"name":"spam_contract-Spam::process_log","bytecode_size":21685} +{"name":"spam_contract-Spam::public_dispatch","bytecode_size":2383} +{"name":"spam_contract-Spam::public_spam","bytecode_size":1891} +{"name":"spam_contract-Spam::spam","bytecode_size":93562} +{"name":"spam_contract-Spam::sync_notes","bytecode_size":194} +{"name":"stateful_test_contract-StatefulTest::constructor","bytecode_size":23974} +{"name":"stateful_test_contract-StatefulTest::create_note","bytecode_size":72352} +{"name":"stateful_test_contract-StatefulTest::create_note_no_init_check","bytecode_size":72428} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create","bytecode_size":442159} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create_no_init_check","bytecode_size":442509} +{"name":"stateful_test_contract-StatefulTest::get_public_value","bytecode_size":1168} +{"name":"stateful_test_contract-StatefulTest::increment_public_value","bytecode_size":1210} +{"name":"stateful_test_contract-StatefulTest::increment_public_value_no_init_check","bytecode_size":1124} +{"name":"stateful_test_contract-StatefulTest::process_log","bytecode_size":15217} +{"name":"stateful_test_contract-StatefulTest::public_constructor","bytecode_size":3302} +{"name":"stateful_test_contract-StatefulTest::public_dispatch","bytecode_size":5855} +{"name":"stateful_test_contract-StatefulTest::summed_values","bytecode_size":18915} +{"name":"stateful_test_contract-StatefulTest::sync_notes","bytecode_size":194} +{"name":"stateful_test_contract-StatefulTest::wrong_constructor","bytecode_size":23814} +{"name":"static_child_contract-StaticChild::private_get_value","bytecode_size":51205} +{"name":"static_child_contract-StaticChild::private_illegal_set_value","bytecode_size":66528} +{"name":"static_child_contract-StaticChild::private_set_value","bytecode_size":66531} +{"name":"static_child_contract-StaticChild::process_log","bytecode_size":15217} +{"name":"static_child_contract-StaticChild::pub_get_value","bytecode_size":368} +{"name":"static_child_contract-StaticChild::pub_illegal_inc_value","bytecode_size":452} +{"name":"static_child_contract-StaticChild::pub_inc_value","bytecode_size":398} +{"name":"static_child_contract-StaticChild::pub_set_value","bytecode_size":381} +{"name":"static_child_contract-StaticChild::public_dispatch","bytecode_size":1380} +{"name":"static_child_contract-StaticChild::sync_notes","bytecode_size":194} +{"name":"static_parent_contract-StaticParent::enqueue_call","bytecode_size":21794} +{"name":"static_parent_contract-StaticParent::enqueue_public_get_value_from_child","bytecode_size":21791} +{"name":"static_parent_contract-StaticParent::enqueue_static_call_to_pub_function","bytecode_size":21816} +{"name":"static_parent_contract-StaticParent::enqueue_static_nested_call_to_pub_function","bytecode_size":21761} +{"name":"static_parent_contract-StaticParent::private_call","bytecode_size":22203} +{"name":"static_parent_contract-StaticParent::private_call_3_args","bytecode_size":22233} +{"name":"static_parent_contract-StaticParent::private_get_value_from_child","bytecode_size":22262} +{"name":"static_parent_contract-StaticParent::private_nested_static_call","bytecode_size":22196} +{"name":"static_parent_contract-StaticParent::private_nested_static_call_3_args","bytecode_size":22239} +{"name":"static_parent_contract-StaticParent::private_static_call","bytecode_size":22212} +{"name":"static_parent_contract-StaticParent::private_static_call_3_args","bytecode_size":22221} +{"name":"static_parent_contract-StaticParent::process_log","bytecode_size":15217} +{"name":"static_parent_contract-StaticParent::public_call","bytecode_size":764} +{"name":"static_parent_contract-StaticParent::public_dispatch","bytecode_size":2169} +{"name":"static_parent_contract-StaticParent::public_get_value_from_child","bytecode_size":739} +{"name":"static_parent_contract-StaticParent::public_nested_static_call","bytecode_size":907} +{"name":"static_parent_contract-StaticParent::public_static_call","bytecode_size":1203} +{"name":"static_parent_contract-StaticParent::sync_notes","bytecode_size":194} +{"name":"test_contract-Test::assert_header_private","bytecode_size":29006} +{"name":"test_contract-Test::assert_private_global_vars","bytecode_size":28622} +{"name":"test_contract-Test::assert_public_global_vars","bytecode_size":529} +{"name":"test_contract-Test::call_create_note","bytecode_size":77804} +{"name":"test_contract-Test::call_destroy_note","bytecode_size":70138} +{"name":"test_contract-Test::call_get_notes","bytecode_size":63151} +{"name":"test_contract-Test::call_get_notes_many","bytecode_size":63327} +{"name":"test_contract-Test::call_view_notes","bytecode_size":25455} +{"name":"test_contract-Test::call_view_notes_many","bytecode_size":25545} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_private","bytecode_size":76738} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_public","bytecode_size":5295} +{"name":"test_contract-Test::consume_mint_to_private_message","bytecode_size":83889} +{"name":"test_contract-Test::consume_mint_to_public_message","bytecode_size":7798} +{"name":"test_contract-Test::consume_note_from_secret","bytecode_size":49622} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_private","bytecode_size":28597} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_public","bytecode_size":244} +{"name":"test_contract-Test::create_l2_to_l1_message_public","bytecode_size":1739} +{"name":"test_contract-Test::deliver_note","bytecode_size":42940} +{"name":"test_contract-Test::deploy_contract","bytecode_size":31511} +{"name":"test_contract-Test::dummy_public_call","bytecode_size":251} +{"name":"test_contract-Test::emit_array_as_encrypted_log","bytecode_size":51242} +{"name":"test_contract-Test::emit_encrypted_logs_nested","bytecode_size":74253} +{"name":"test_contract-Test::emit_nullifier","bytecode_size":28690} +{"name":"test_contract-Test::emit_nullifier_public","bytecode_size":216} +{"name":"test_contract-Test::emit_public","bytecode_size":1104} +{"name":"test_contract-Test::get_constant","bytecode_size":24841} +{"name":"test_contract-Test::get_master_incoming_viewing_public_key","bytecode_size":30637} +{"name":"test_contract-Test::get_ovsk_app","bytecode_size":29335} +{"name":"test_contract-Test::get_this_address","bytecode_size":28810} +{"name":"test_contract-Test::is_time_equal","bytecode_size":263} +{"name":"test_contract-Test::process_log","bytecode_size":22628} +{"name":"test_contract-Test::public_dispatch","bytecode_size":15395} +{"name":"test_contract-Test::set_constant","bytecode_size":29956} +{"name":"test_contract-Test::set_tx_max_block_number","bytecode_size":29137} +{"name":"test_contract-Test::sync_notes","bytecode_size":194} +{"name":"test_contract-Test::test_code_gen","bytecode_size":29130} +{"name":"test_contract-Test::test_nullifier_key_freshness","bytecode_size":30545} +{"name":"test_contract-Test::test_setting_fee_payer","bytecode_size":29018} +{"name":"test_contract-Test::test_setting_teardown","bytecode_size":28984} +{"name":"test_log_contract-TestLog::emit_encrypted_events","bytecode_size":100451} +{"name":"test_log_contract-TestLog::emit_unencrypted_events","bytecode_size":660} +{"name":"test_log_contract-TestLog::process_log","bytecode_size":15217} +{"name":"test_log_contract-TestLog::public_dispatch","bytecode_size":1486} +{"name":"test_log_contract-TestLog::sync_notes","bytecode_size":194} +{"name":"token_blacklist_contract-TokenBlacklist::_increase_public_balance","bytecode_size":2053} +{"name":"token_blacklist_contract-TokenBlacklist::_reduce_total_supply","bytecode_size":590} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_private","bytecode_size":23972} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_public","bytecode_size":1331} +{"name":"token_blacklist_contract-TokenBlacklist::burn","bytecode_size":242678} +{"name":"token_blacklist_contract-TokenBlacklist::burn_public","bytecode_size":5682} +{"name":"token_blacklist_contract-TokenBlacklist::constructor","bytecode_size":5728} +{"name":"token_blacklist_contract-TokenBlacklist::deliver_transparent_note","bytecode_size":36728} +{"name":"token_blacklist_contract-TokenBlacklist::get_roles","bytecode_size":1651} +{"name":"token_blacklist_contract-TokenBlacklist::mint_private","bytecode_size":2825} +{"name":"token_blacklist_contract-TokenBlacklist::mint_public","bytecode_size":3773} +{"name":"token_blacklist_contract-TokenBlacklist::process_log","bytecode_size":18415} +{"name":"token_blacklist_contract-TokenBlacklist::public_dispatch","bytecode_size":47443} +{"name":"token_blacklist_contract-TokenBlacklist::redeem_shield","bytecode_size":111972} +{"name":"token_blacklist_contract-TokenBlacklist::shield","bytecode_size":6521} +{"name":"token_blacklist_contract-TokenBlacklist::sync_notes","bytecode_size":194} +{"name":"token_blacklist_contract-TokenBlacklist::total_supply","bytecode_size":451} +{"name":"token_blacklist_contract-TokenBlacklist::transfer","bytecode_size":232254} +{"name":"token_blacklist_contract-TokenBlacklist::transfer_public","bytecode_size":7256} +{"name":"token_blacklist_contract-TokenBlacklist::unshield","bytecode_size":250684} +{"name":"token_blacklist_contract-TokenBlacklist::update_roles","bytecode_size":5149} +{"name":"token_bridge_contract-TokenBridge::claim_private","bytecode_size":83472} +{"name":"token_bridge_contract-TokenBridge::claim_public","bytecode_size":8503} +{"name":"token_bridge_contract-TokenBridge::constructor","bytecode_size":3470} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_private","bytecode_size":49518} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_public","bytecode_size":3936} +{"name":"token_bridge_contract-TokenBridge::get_config","bytecode_size":28069} +{"name":"token_bridge_contract-TokenBridge::get_config_public","bytecode_size":428} +{"name":"token_bridge_contract-TokenBridge::process_log","bytecode_size":14990} +{"name":"token_bridge_contract-TokenBridge::public_dispatch","bytecode_size":14968} +{"name":"token_bridge_contract-TokenBridge::sync_notes","bytecode_size":194} +{"name":"token_contract-Token::_finalize_mint_to_private_unsafe","bytecode_size":3657} +{"name":"token_contract-Token::_finalize_transfer_to_private_unsafe","bytecode_size":4160} +{"name":"token_contract-Token::_increase_public_balance","bytecode_size":1981} +{"name":"token_contract-Token::_recurse_subtract_balance","bytecode_size":104385} +{"name":"token_contract-Token::_reduce_total_supply","bytecode_size":559} +{"name":"token_contract-Token::_store_payload_in_transient_storage_unsafe","bytecode_size":1225} +{"name":"token_contract-Token::balance_of_private","bytecode_size":19090} +{"name":"token_contract-Token::balance_of_public","bytecode_size":1325} +{"name":"token_contract-Token::burn_private","bytecode_size":221529} +{"name":"token_contract-Token::burn_public","bytecode_size":4361} +{"name":"token_contract-Token::cancel_authwit","bytecode_size":21178} +{"name":"token_contract-Token::constructor","bytecode_size":6179} +{"name":"token_contract-Token::finalize_mint_to_private","bytecode_size":3663} +{"name":"token_contract-Token::finalize_transfer_to_private","bytecode_size":4149} +{"name":"token_contract-Token::get_admin","bytecode_size":357} +{"name":"token_contract-Token::is_minter","bytecode_size":1250} +{"name":"token_contract-Token::mint_to_private","bytecode_size":66807} +{"name":"token_contract-Token::mint_to_public","bytecode_size":2601} +{"name":"token_contract-Token::prepare_private_balance_increase","bytecode_size":66730} +{"name":"token_contract-Token::private_get_decimals","bytecode_size":28018} +{"name":"token_contract-Token::private_get_name","bytecode_size":28008} +{"name":"token_contract-Token::private_get_symbol","bytecode_size":28000} +{"name":"token_contract-Token::process_log","bytecode_size":14990} +{"name":"token_contract-Token::public_dispatch","bytecode_size":31918} +{"name":"token_contract-Token::public_get_decimals","bytecode_size":384} +{"name":"token_contract-Token::public_get_name","bytecode_size":374} +{"name":"token_contract-Token::public_get_symbol","bytecode_size":361} +{"name":"token_contract-Token::set_admin","bytecode_size":386} +{"name":"token_contract-Token::set_minter","bytecode_size":1278} +{"name":"token_contract-Token::sync_notes","bytecode_size":194} +{"name":"token_contract-Token::total_supply","bytecode_size":455} +{"name":"token_contract-Token::transfer","bytecode_size":112636} +{"name":"token_contract-Token::transfer_in_private","bytecode_size":277827} +{"name":"token_contract-Token::transfer_in_public","bytecode_size":5481} +{"name":"token_contract-Token::transfer_to_private","bytecode_size":66934} +{"name":"token_contract-Token::transfer_to_public","bytecode_size":221536} +{"name":"uniswap_contract-Uniswap::_approve_bridge_and_exit_input_asset_to_L1","bytecode_size":5754} +{"name":"uniswap_contract-Uniswap::constructor","bytecode_size":2951} +{"name":"uniswap_contract-Uniswap::process_log","bytecode_size":14990} +{"name":"uniswap_contract-Uniswap::public_dispatch","bytecode_size":16402} +{"name":"uniswap_contract-Uniswap::swap_private","bytecode_size":73024} +{"name":"uniswap_contract-Uniswap::swap_public","bytecode_size":8205} +{"name":"uniswap_contract-Uniswap::sync_notes","bytecode_size":194} +{"name":"updatable_contract-Updatable::get_private_value","bytecode_size":17948} +{"name":"updatable_contract-Updatable::get_public_value","bytecode_size":16277} +{"name":"updatable_contract-Updatable::get_update_delay","bytecode_size":795} +{"name":"updatable_contract-Updatable::initialize","bytecode_size":68404} +{"name":"updatable_contract-Updatable::process_log","bytecode_size":15217} +{"name":"updatable_contract-Updatable::public_dispatch","bytecode_size":1382} +{"name":"updatable_contract-Updatable::set_public_value","bytecode_size":327} +{"name":"updatable_contract-Updatable::set_update_delay","bytecode_size":21724} +{"name":"updatable_contract-Updatable::sync_notes","bytecode_size":194} +{"name":"updatable_contract-Updatable::update_to","bytecode_size":21742} +{"name":"updated_contract-Updated::get_private_value","bytecode_size":17948} +{"name":"updated_contract-Updated::get_public_value","bytecode_size":16277} +{"name":"updated_contract-Updated::get_update_delay","bytecode_size":721} +{"name":"updated_contract-Updated::process_log","bytecode_size":15217} +{"name":"updated_contract-Updated::public_dispatch","bytecode_size":1251} +{"name":"updated_contract-Updated::set_private_value","bytecode_size":65472} +{"name":"updated_contract-Updated::set_public_value","bytecode_size":231} +{"name":"updated_contract-Updated::sync_notes","bytecode_size":194} diff --git a/scripts/bytecode-sizes/bytecode-size-scatter.plt b/scripts/bytecode-sizes/bytecode-size-scatter.plt new file mode 100644 index 00000000000..713d66db8b8 --- /dev/null +++ b/scripts/bytecode-sizes/bytecode-size-scatter.plt @@ -0,0 +1,9 @@ +set term png size 1200,800; +set output FILEOUT; +unset key; +set title NAME; +set logscale x; +set xlabel "Base Bytecode Size (Log)"; +set ylabel "Alt Bytecode Ratio"; + +plot FILEIN using 2:4 with points; diff --git a/scripts/bytecode-sizes/cbor.jsonl b/scripts/bytecode-sizes/cbor.jsonl new file mode 100644 index 00000000000..174d4d3790d --- /dev/null +++ b/scripts/bytecode-sizes/cbor.jsonl @@ -0,0 +1,727 @@ +{"name":"parity_base","bytecode_size":39479} +{"name":"parity_root","bytecode_size":62457} +{"name":"private_kernel_init","bytecode_size":239509} +{"name":"private_kernel_init_simulated","bytecode_size":62602} +{"name":"private_kernel_inner","bytecode_size":386852} +{"name":"private_kernel_inner_simulated","bytecode_size":92241} +{"name":"private_kernel_reset","bytecode_size":968420} +{"name":"private_kernel_reset_0_0_0_0_0_64_0_0_0","bytecode_size":258991} +{"name":"private_kernel_reset_0_0_0_0_64_0_0_0_0","bytecode_size":210412} +{"name":"private_kernel_reset_0_0_0_64_0_0_0_0_0","bytecode_size":414154} +{"name":"private_kernel_reset_0_0_64_0_0_0_0_0_0","bytecode_size":185042} +{"name":"private_kernel_reset_0_64_0_0_0_0_0_0_0","bytecode_size":415357} +{"name":"private_kernel_reset_16_16_16_16_16_16_16_16_16","bytecode_size":461786} +{"name":"private_kernel_reset_32_16_32_16_4_4_4_4_32","bytecode_size":462320} +{"name":"private_kernel_reset_32_16_32_16_4_4_4_4_4","bytecode_size":438602} +{"name":"private_kernel_reset_32_16_32_16_4_4_4_64_32","bytecode_size":480119} +{"name":"private_kernel_reset_32_16_32_16_4_4_4_64_4","bytecode_size":456265} +{"name":"private_kernel_reset_32_16_32_16_4_4_64_4_32","bytecode_size":485632} +{"name":"private_kernel_reset_32_16_32_16_4_4_64_4_4","bytecode_size":460924} +{"name":"private_kernel_reset_32_16_32_16_4_4_64_64_32","bytecode_size":502304} +{"name":"private_kernel_reset_32_16_32_16_4_4_64_64_4","bytecode_size":479096} +{"name":"private_kernel_reset_32_16_32_4_4_4_4_4_32","bytecode_size":416649} +{"name":"private_kernel_reset_32_16_32_4_4_4_4_4_4","bytecode_size":391838} +{"name":"private_kernel_reset_32_16_32_4_4_4_4_64_32","bytecode_size":433778} +{"name":"private_kernel_reset_32_16_32_4_4_4_4_64_4","bytecode_size":408600} +{"name":"private_kernel_reset_32_16_32_4_4_4_64_4_32","bytecode_size":439832} +{"name":"private_kernel_reset_32_16_32_4_4_4_64_4_4","bytecode_size":414951} +{"name":"private_kernel_reset_32_16_32_4_4_4_64_64_32","bytecode_size":456344} +{"name":"private_kernel_reset_32_16_32_4_4_4_64_64_4","bytecode_size":433137} +{"name":"private_kernel_reset_32_32_32_32_32_32_32_32_32","bytecode_size":641384} +{"name":"private_kernel_reset_32_4_32_16_4_4_4_4_32","bytecode_size":415549} +{"name":"private_kernel_reset_32_4_32_16_4_4_4_4_4","bytecode_size":390665} +{"name":"private_kernel_reset_32_4_32_16_4_4_4_64_32","bytecode_size":432862} +{"name":"private_kernel_reset_32_4_32_16_4_4_4_64_4","bytecode_size":407637} +{"name":"private_kernel_reset_32_4_32_16_4_4_64_4_32","bytecode_size":438609} +{"name":"private_kernel_reset_32_4_32_16_4_4_64_4_4","bytecode_size":413777} +{"name":"private_kernel_reset_32_4_32_16_4_4_64_64_32","bytecode_size":455588} +{"name":"private_kernel_reset_32_4_32_16_4_4_64_64_4","bytecode_size":431430} +{"name":"private_kernel_reset_32_4_32_4_4_4_4_4_32","bytecode_size":368930} +{"name":"private_kernel_reset_32_4_32_4_4_4_4_4_4","bytecode_size":344321} +{"name":"private_kernel_reset_32_4_32_4_4_4_4_64_32","bytecode_size":385798} +{"name":"private_kernel_reset_32_4_32_4_4_4_4_64_4","bytecode_size":360381} +{"name":"private_kernel_reset_32_4_32_4_4_4_64_4_32","bytecode_size":390717} +{"name":"private_kernel_reset_32_4_32_4_4_4_64_4_4","bytecode_size":366683} +{"name":"private_kernel_reset_32_4_32_4_4_4_64_64_32","bytecode_size":407262} +{"name":"private_kernel_reset_32_4_32_4_4_4_64_64_4","bytecode_size":383955} +{"name":"private_kernel_reset_4_4_4_4_4_4_4_4_4","bytecode_size":326075} +{"name":"private_kernel_reset_64_0_0_0_0_0_0_0_0","bytecode_size":184492} +{"name":"private_kernel_reset_simulated","bytecode_size":121248} +{"name":"private_kernel_reset_simulated_0_0_0_0_0_64_0_0_0","bytecode_size":51433} +{"name":"private_kernel_reset_simulated_0_0_0_0_64_0_0_0_0","bytecode_size":51624} +{"name":"private_kernel_reset_simulated_0_0_0_64_0_0_0_0_0","bytecode_size":68755} +{"name":"private_kernel_reset_simulated_0_0_64_0_0_0_0_0_0","bytecode_size":49624} +{"name":"private_kernel_reset_simulated_0_64_0_0_0_0_0_0_0","bytecode_size":65082} +{"name":"private_kernel_reset_simulated_16_16_16_16_16_16_16_16_16","bytecode_size":85309} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_4_4_32","bytecode_size":85340} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_4_4_4","bytecode_size":85713} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_4_64_32","bytecode_size":85652} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_4_64_4","bytecode_size":85732} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_64_4_32","bytecode_size":85689} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_64_4_4","bytecode_size":85832} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_64_64_32","bytecode_size":85887} +{"name":"private_kernel_reset_simulated_32_16_32_16_4_4_64_64_4","bytecode_size":85543} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_4_4_32","bytecode_size":82571} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_4_4_4","bytecode_size":82773} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_4_64_32","bytecode_size":82873} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_4_64_4","bytecode_size":82926} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_64_4_32","bytecode_size":82598} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_64_4_4","bytecode_size":82998} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_64_64_32","bytecode_size":82666} +{"name":"private_kernel_reset_simulated_32_16_32_4_4_4_64_64_4","bytecode_size":82950} +{"name":"private_kernel_reset_simulated_32_32_32_32_32_32_32_32_32","bytecode_size":95105} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_4_4_32","bytecode_size":83144} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_4_4_4","bytecode_size":83296} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_4_64_32","bytecode_size":83077} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_4_64_4","bytecode_size":83093} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_64_4_32","bytecode_size":83164} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_64_4_4","bytecode_size":83138} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_64_64_32","bytecode_size":83139} +{"name":"private_kernel_reset_simulated_32_4_32_16_4_4_64_64_4","bytecode_size":83171} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_4_4_32","bytecode_size":79191} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_4_4_4","bytecode_size":79576} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_4_64_32","bytecode_size":79332} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_4_64_4","bytecode_size":79488} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_64_4_32","bytecode_size":79342} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_64_4_4","bytecode_size":79653} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_64_64_32","bytecode_size":79430} +{"name":"private_kernel_reset_simulated_32_4_32_4_4_4_64_64_4","bytecode_size":79617} +{"name":"private_kernel_reset_simulated_4_4_4_4_4_4_4_4_4","bytecode_size":78231} +{"name":"private_kernel_reset_simulated_64_0_0_0_0_0_0_0_0","bytecode_size":49839} +{"name":"private_kernel_tail","bytecode_size":129136} +{"name":"private_kernel_tail_simulated","bytecode_size":49102} +{"name":"private_kernel_tail_to_public","bytecode_size":225427} +{"name":"private_kernel_tail_to_public_simulated","bytecode_size":71890} +{"name":"rollup_base_private","bytecode_size":1478760} +{"name":"rollup_base_private_simulated","bytecode_size":84989} +{"name":"rollup_base_public","bytecode_size":713364} +{"name":"rollup_base_public_simulated","bytecode_size":83361} +{"name":"rollup_block_merge","bytecode_size":118996} +{"name":"rollup_block_root","bytecode_size":15306791} +{"name":"rollup_block_root_empty","bytecode_size":22707} +{"name":"rollup_block_root_simulated","bytecode_size":98188} +{"name":"rollup_block_root_single_tx","bytecode_size":15285913} +{"name":"rollup_block_root_single_tx_simulated","bytecode_size":89185} +{"name":"rollup_merge","bytecode_size":32257} +{"name":"rollup_root","bytecode_size":119467} +{"name":"amm_contract-AMM::_add_liquidity","bytecode_size":8803} +{"name":"amm_contract-AMM::_remove_liquidity","bytecode_size":5754} +{"name":"amm_contract-AMM::_swap_exact_tokens_for_tokens","bytecode_size":4578} +{"name":"amm_contract-AMM::_swap_tokens_for_exact_tokens","bytecode_size":5023} +{"name":"amm_contract-AMM::add_liquidity","bytecode_size":34383} +{"name":"amm_contract-AMM::constructor","bytecode_size":4273} +{"name":"amm_contract-AMM::get_amount_in_for_exact_out","bytecode_size":20354} +{"name":"amm_contract-AMM::get_amount_out_for_exact_in","bytecode_size":20433} +{"name":"amm_contract-AMM::process_log","bytecode_size":16635} +{"name":"amm_contract-AMM::public_dispatch","bytecode_size":22866} +{"name":"amm_contract-AMM::remove_liquidity","bytecode_size":32295} +{"name":"amm_contract-AMM::swap_exact_tokens_for_tokens","bytecode_size":32337} +{"name":"amm_contract-AMM::swap_tokens_for_exact_tokens","bytecode_size":32459} +{"name":"amm_contract-AMM::sync_notes","bytecode_size":516} +{"name":"app_subscription_contract-AppSubscription::constructor","bytecode_size":4993} +{"name":"app_subscription_contract-AppSubscription::entrypoint","bytecode_size":104762} +{"name":"app_subscription_contract-AppSubscription::is_initialized","bytecode_size":26472} +{"name":"app_subscription_contract-AppSubscription::process_log","bytecode_size":23834} +{"name":"app_subscription_contract-AppSubscription::public_dispatch","bytecode_size":5617} +{"name":"app_subscription_contract-AppSubscription::subscribe","bytecode_size":100422} +{"name":"app_subscription_contract-AppSubscription::sync_notes","bytecode_size":516} +{"name":"auth_contract-Auth::constructor","bytecode_size":3560} +{"name":"auth_contract-Auth::do_private_authorized_thing","bytecode_size":13875} +{"name":"auth_contract-Auth::get_authorized","bytecode_size":1309} +{"name":"auth_contract-Auth::get_authorized_delay","bytecode_size":1094} +{"name":"auth_contract-Auth::get_authorized_in_private","bytecode_size":14181} +{"name":"auth_contract-Auth::get_scheduled_authorized","bytecode_size":1210} +{"name":"auth_contract-Auth::process_log","bytecode_size":1655} +{"name":"auth_contract-Auth::public_dispatch","bytecode_size":11053} +{"name":"auth_contract-Auth::set_authorized","bytecode_size":4373} +{"name":"auth_contract-Auth::set_authorized_delay","bytecode_size":4322} +{"name":"auth_contract-Auth::sync_notes","bytecode_size":516} +{"name":"auth_registry_contract-AuthRegistry::_set_authorized","bytecode_size":2296} +{"name":"auth_registry_contract-AuthRegistry::consume","bytecode_size":4515} +{"name":"auth_registry_contract-AuthRegistry::is_consumable","bytecode_size":2320} +{"name":"auth_registry_contract-AuthRegistry::is_reject_all","bytecode_size":1728} +{"name":"auth_registry_contract-AuthRegistry::process_log","bytecode_size":1655} +{"name":"auth_registry_contract-AuthRegistry::public_dispatch","bytecode_size":8674} +{"name":"auth_registry_contract-AuthRegistry::set_authorized","bytecode_size":2252} +{"name":"auth_registry_contract-AuthRegistry::set_authorized_private","bytecode_size":6515} +{"name":"auth_registry_contract-AuthRegistry::set_reject_all","bytecode_size":1689} +{"name":"auth_registry_contract-AuthRegistry::sync_notes","bytecode_size":516} +{"name":"auth_registry_contract-AuthRegistry::unconstrained_is_consumable","bytecode_size":2337} +{"name":"auth_wit_test_contract-AuthWitTest::consume","bytecode_size":6118} +{"name":"auth_wit_test_contract-AuthWitTest::consume_public","bytecode_size":1271} +{"name":"auth_wit_test_contract-AuthWitTest::process_log","bytecode_size":1655} +{"name":"auth_wit_test_contract-AuthWitTest::public_dispatch","bytecode_size":1853} +{"name":"auth_wit_test_contract-AuthWitTest::sync_notes","bytecode_size":516} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_f1600","bytecode_size":1137} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_hash","bytecode_size":2587} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash","bytecode_size":3349} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash_with_index","bytecode_size":3323} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::poseidon2_hash","bytecode_size":2135} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::process_log","bytecode_size":1655} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::public_dispatch","bytecode_size":39823} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_10","bytecode_size":2993} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_100","bytecode_size":4308} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_20","bytecode_size":3020} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_2048","bytecode_size":27410} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_255","bytecode_size":6264} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_256","bytecode_size":5951} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_30","bytecode_size":3223} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_40","bytecode_size":3262} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_50","bytecode_size":3452} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_511","bytecode_size":9470} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_512","bytecode_size":9018} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_60","bytecode_size":3476} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_70","bytecode_size":4135} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_80","bytecode_size":4120} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_90","bytecode_size":4290} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sync_notes","bytecode_size":516} +{"name":"avm_initializer_test_contract-AvmInitializerTest::constructor","bytecode_size":3078} +{"name":"avm_initializer_test_contract-AvmInitializerTest::process_log","bytecode_size":1655} +{"name":"avm_initializer_test_contract-AvmInitializerTest::public_dispatch","bytecode_size":3725} +{"name":"avm_initializer_test_contract-AvmInitializerTest::read_storage_immutable","bytecode_size":671} +{"name":"avm_initializer_test_contract-AvmInitializerTest::sync_notes","bytecode_size":516} +{"name":"avm_test_contract-AvmTest::add_args_return","bytecode_size":583} +{"name":"avm_test_contract-AvmTest::add_storage_map","bytecode_size":2826} +{"name":"avm_test_contract-AvmTest::add_u128","bytecode_size":762} +{"name":"avm_test_contract-AvmTest::assert_calldata_copy","bytecode_size":1124} +{"name":"avm_test_contract-AvmTest::assert_nullifier_exists","bytecode_size":667} +{"name":"avm_test_contract-AvmTest::assert_same","bytecode_size":617} +{"name":"avm_test_contract-AvmTest::assertion_failure","bytecode_size":537} +{"name":"avm_test_contract-AvmTest::bulk_testing","bytecode_size":19541} +{"name":"avm_test_contract-AvmTest::create_different_nullifier_in_nested_call","bytecode_size":1239} +{"name":"avm_test_contract-AvmTest::create_same_nullifier_in_nested_call","bytecode_size":1221} +{"name":"avm_test_contract-AvmTest::debug_logging","bytecode_size":1585} +{"name":"avm_test_contract-AvmTest::divide_by_zero","bytecode_size":524} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add","bytecode_size":1214} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add_and_double","bytecode_size":644} +{"name":"avm_test_contract-AvmTest::emit_nullifier_and_check","bytecode_size":683} +{"name":"avm_test_contract-AvmTest::emit_public_log","bytecode_size":2538} +{"name":"avm_test_contract-AvmTest::enqueue_public_from_private","bytecode_size":5595} +{"name":"avm_test_contract-AvmTest::external_call_to_assertion_failure","bytecode_size":1141} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero","bytecode_size":1127} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero_recovers","bytecode_size":2801} +{"name":"avm_test_contract-AvmTest::get_address","bytecode_size":543} +{"name":"avm_test_contract-AvmTest::get_args_hash","bytecode_size":2369} +{"name":"avm_test_contract-AvmTest::get_block_number","bytecode_size":554} +{"name":"avm_test_contract-AvmTest::get_chain_id","bytecode_size":554} +{"name":"avm_test_contract-AvmTest::get_da_gas_left","bytecode_size":541} +{"name":"avm_test_contract-AvmTest::get_fee_per_da_gas","bytecode_size":555} +{"name":"avm_test_contract-AvmTest::get_fee_per_l2_gas","bytecode_size":554} +{"name":"avm_test_contract-AvmTest::get_l2_gas_left","bytecode_size":543} +{"name":"avm_test_contract-AvmTest::get_sender","bytecode_size":543} +{"name":"avm_test_contract-AvmTest::get_timestamp","bytecode_size":556} +{"name":"avm_test_contract-AvmTest::get_transaction_fee","bytecode_size":565} +{"name":"avm_test_contract-AvmTest::get_version","bytecode_size":553} +{"name":"avm_test_contract-AvmTest::helper_with_failed_assertion","bytecode_size":263} +{"name":"avm_test_contract-AvmTest::inner_helper_with_failed_assertion","bytecode_size":263} +{"name":"avm_test_contract-AvmTest::l1_to_l2_msg_exists","bytecode_size":637} +{"name":"avm_test_contract-AvmTest::modulo2","bytecode_size":574} +{"name":"avm_test_contract-AvmTest::n_new_l2_to_l1_msgs","bytecode_size":671} +{"name":"avm_test_contract-AvmTest::n_new_note_hashes","bytecode_size":679} +{"name":"avm_test_contract-AvmTest::n_new_nullifiers","bytecode_size":667} +{"name":"avm_test_contract-AvmTest::n_new_public_logs","bytecode_size":826} +{"name":"avm_test_contract-AvmTest::n_storage_writes","bytecode_size":1756} +{"name":"avm_test_contract-AvmTest::nested_call_to_add","bytecode_size":1244} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_n_times_different_addresses","bytecode_size":1606} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_with_gas","bytecode_size":1213} +{"name":"avm_test_contract-AvmTest::nested_call_to_assert_same","bytecode_size":1255} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing","bytecode_size":1129} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing_recovers","bytecode_size":857} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_add","bytecode_size":1256} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_set_storage","bytecode_size":1167} +{"name":"avm_test_contract-AvmTest::new_note_hash","bytecode_size":580} +{"name":"avm_test_contract-AvmTest::new_nullifier","bytecode_size":590} +{"name":"avm_test_contract-AvmTest::note_hash_exists","bytecode_size":637} +{"name":"avm_test_contract-AvmTest::nullifier_collision","bytecode_size":590} +{"name":"avm_test_contract-AvmTest::nullifier_exists","bytecode_size":635} +{"name":"avm_test_contract-AvmTest::pedersen_commit","bytecode_size":1722} +{"name":"avm_test_contract-AvmTest::process_log","bytecode_size":1655} +{"name":"avm_test_contract-AvmTest::public_dispatch","bytecode_size":42155} +{"name":"avm_test_contract-AvmTest::read_assert_storage_single","bytecode_size":658} +{"name":"avm_test_contract-AvmTest::read_storage_list","bytecode_size":791} +{"name":"avm_test_contract-AvmTest::read_storage_map","bytecode_size":1675} +{"name":"avm_test_contract-AvmTest::read_storage_single","bytecode_size":587} +{"name":"avm_test_contract-AvmTest::return_oracle","bytecode_size":941} +{"name":"avm_test_contract-AvmTest::returndata_copy_oracle","bytecode_size":1851} +{"name":"avm_test_contract-AvmTest::revert_oracle","bytecode_size":940} +{"name":"avm_test_contract-AvmTest::send_l2_to_l1_msg","bytecode_size":608} +{"name":"avm_test_contract-AvmTest::set_opcode_big_field","bytecode_size":539} +{"name":"avm_test_contract-AvmTest::set_opcode_really_big_field","bytecode_size":532} +{"name":"avm_test_contract-AvmTest::set_opcode_small_field","bytecode_size":539} +{"name":"avm_test_contract-AvmTest::set_opcode_u32","bytecode_size":508} +{"name":"avm_test_contract-AvmTest::set_opcode_u64","bytecode_size":502} +{"name":"avm_test_contract-AvmTest::set_opcode_u8","bytecode_size":506} +{"name":"avm_test_contract-AvmTest::set_read_storage_single","bytecode_size":640} +{"name":"avm_test_contract-AvmTest::set_storage_list","bytecode_size":630} +{"name":"avm_test_contract-AvmTest::set_storage_map","bytecode_size":2204} +{"name":"avm_test_contract-AvmTest::set_storage_single","bytecode_size":607} +{"name":"avm_test_contract-AvmTest::sync_notes","bytecode_size":516} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance","bytecode_size":960} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance_matches","bytecode_size":988} +{"name":"avm_test_contract-AvmTest::to_radix_le","bytecode_size":909} +{"name":"avm_test_contract-AvmTest::u128_addition_overflow","bytecode_size":1567} +{"name":"avm_test_contract-AvmTest::u128_from_integer_overflow","bytecode_size":1080} +{"name":"avm_test_contract-AvmTest::variable_base_msm","bytecode_size":1017} +{"name":"benchmarking_contract-Benchmarking::broadcast","bytecode_size":1785} +{"name":"benchmarking_contract-Benchmarking::create_note","bytecode_size":74329} +{"name":"benchmarking_contract-Benchmarking::increment_balance","bytecode_size":2790} +{"name":"benchmarking_contract-Benchmarking::process_log","bytecode_size":16700} +{"name":"benchmarking_contract-Benchmarking::public_dispatch","bytecode_size":6847} +{"name":"benchmarking_contract-Benchmarking::recreate_note","bytecode_size":93443} +{"name":"benchmarking_contract-Benchmarking::sha256_hash_2048","bytecode_size":27410} +{"name":"benchmarking_contract-Benchmarking::sync_notes","bytecode_size":516} +{"name":"card_game_contract-CardGame::buy_pack","bytecode_size":126226} +{"name":"card_game_contract-CardGame::claim_cards","bytecode_size":155529} +{"name":"card_game_contract-CardGame::join_game","bytecode_size":349588} +{"name":"card_game_contract-CardGame::on_card_played","bytecode_size":4485} +{"name":"card_game_contract-CardGame::on_cards_claimed","bytecode_size":5671} +{"name":"card_game_contract-CardGame::on_game_joined","bytecode_size":3468} +{"name":"card_game_contract-CardGame::play_card","bytecode_size":259154} +{"name":"card_game_contract-CardGame::process_log","bytecode_size":16700} +{"name":"card_game_contract-CardGame::public_dispatch","bytecode_size":15608} +{"name":"card_game_contract-CardGame::start_game","bytecode_size":4620} +{"name":"card_game_contract-CardGame::sync_notes","bytecode_size":516} +{"name":"card_game_contract-CardGame::view_collection_cards","bytecode_size":21284} +{"name":"card_game_contract-CardGame::view_game","bytecode_size":19837} +{"name":"card_game_contract-CardGame::view_game_cards","bytecode_size":21882} +{"name":"child_contract-Child::private_get_value","bytecode_size":47626} +{"name":"child_contract-Child::private_set_value","bytecode_size":74751} +{"name":"child_contract-Child::process_log","bytecode_size":16700} +{"name":"child_contract-Child::pub_get_value","bytecode_size":696} +{"name":"child_contract-Child::pub_inc_value","bytecode_size":840} +{"name":"child_contract-Child::pub_inc_value_internal","bytecode_size":909} +{"name":"child_contract-Child::pub_set_value","bytecode_size":809} +{"name":"child_contract-Child::public_dispatch","bytecode_size":3352} +{"name":"child_contract-Child::set_value_twice_with_nested_first","bytecode_size":1283} +{"name":"child_contract-Child::set_value_twice_with_nested_last","bytecode_size":1284} +{"name":"child_contract-Child::set_value_with_two_nested_calls","bytecode_size":1561} +{"name":"child_contract-Child::sync_notes","bytecode_size":516} +{"name":"child_contract-Child::value","bytecode_size":23425} +{"name":"child_contract-Child::value_internal","bytecode_size":23524} +{"name":"claim_contract-Claim::claim","bytecode_size":43497} +{"name":"claim_contract-Claim::constructor","bytecode_size":4408} +{"name":"claim_contract-Claim::process_log","bytecode_size":16635} +{"name":"claim_contract-Claim::public_dispatch","bytecode_size":4817} +{"name":"claim_contract-Claim::sync_notes","bytecode_size":516} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::assert_class_id_is_registered","bytecode_size":4414} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_private_function","bytecode_size":22511} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_unconstrained_function","bytecode_size":22401} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::process_log","bytecode_size":1655} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::register","bytecode_size":230787} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::sync_notes","bytecode_size":516} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::deploy","bytecode_size":8583} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::get_update_delay","bytecode_size":2033} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::process_log","bytecode_size":1655} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::public_dispatch","bytecode_size":9804} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::set_update_delay","bytecode_size":5087} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::sync_notes","bytecode_size":516} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::update","bytecode_size":5329} +{"name":"counter_contract-Counter::decrement","bytecode_size":254480} +{"name":"counter_contract-Counter::get_counter","bytecode_size":21075} +{"name":"counter_contract-Counter::increment","bytecode_size":70337} +{"name":"counter_contract-Counter::increment_and_decrement","bytecode_size":270638} +{"name":"counter_contract-Counter::increment_twice","bytecode_size":86317} +{"name":"counter_contract-Counter::initialize","bytecode_size":76021} +{"name":"counter_contract-Counter::process_log","bytecode_size":16700} +{"name":"counter_contract-Counter::sync_notes","bytecode_size":516} +{"name":"crowdfunding_contract-Crowdfunding::_publish_donation_receipts","bytecode_size":973} +{"name":"crowdfunding_contract-Crowdfunding::donate","bytecode_size":77345} +{"name":"crowdfunding_contract-Crowdfunding::init","bytecode_size":4312} +{"name":"crowdfunding_contract-Crowdfunding::process_log","bytecode_size":16635} +{"name":"crowdfunding_contract-Crowdfunding::public_dispatch","bytecode_size":5255} +{"name":"crowdfunding_contract-Crowdfunding::sync_notes","bytecode_size":516} +{"name":"crowdfunding_contract-Crowdfunding::withdraw","bytecode_size":31332} +{"name":"docs_example_contract-DocsExample::get_imm_card","bytecode_size":25226} +{"name":"docs_example_contract-DocsExample::get_leader","bytecode_size":18185} +{"name":"docs_example_contract-DocsExample::get_legendary_card","bytecode_size":19987} +{"name":"docs_example_contract-DocsExample::get_public_immutable","bytecode_size":18192} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private","bytecode_size":30684} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private_indirect","bytecode_size":24417} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public","bytecode_size":723} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_indirect","bytecode_size":1271} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_multiple","bytecode_size":842} +{"name":"docs_example_contract-DocsExample::increase_legendary_points","bytecode_size":78409} +{"name":"docs_example_contract-DocsExample::initialize_private","bytecode_size":70326} +{"name":"docs_example_contract-DocsExample::initialize_private_immutable","bytecode_size":70239} +{"name":"docs_example_contract-DocsExample::initialize_public_immutable","bytecode_size":1824} +{"name":"docs_example_contract-DocsExample::insert_note","bytecode_size":69930} +{"name":"docs_example_contract-DocsExample::insert_notes","bytecode_size":98188} +{"name":"docs_example_contract-DocsExample::is_legendary_initialized","bytecode_size":18665} +{"name":"docs_example_contract-DocsExample::is_priv_imm_initialized","bytecode_size":18679} +{"name":"docs_example_contract-DocsExample::match_public_immutable","bytecode_size":30504} +{"name":"docs_example_contract-DocsExample::process_log","bytecode_size":16729} +{"name":"docs_example_contract-DocsExample::public_dispatch","bytecode_size":4145} +{"name":"docs_example_contract-DocsExample::read_note","bytecode_size":20277} +{"name":"docs_example_contract-DocsExample::simple_macro_example","bytecode_size":23456} +{"name":"docs_example_contract-DocsExample::simple_macro_example_expanded","bytecode_size":5189} +{"name":"docs_example_contract-DocsExample::spend_public_authwit","bytecode_size":548} +{"name":"docs_example_contract-DocsExample::sync_notes","bytecode_size":516} +{"name":"docs_example_contract-DocsExample::update_leader","bytecode_size":763} +{"name":"docs_example_contract-DocsExample::update_legendary_card","bytecode_size":74145} +{"name":"docs_example_contract-DocsExample::verify_private_authwit","bytecode_size":23518} +{"name":"docs_example_contract-DocsExample::view_imm_card","bytecode_size":19923} +{"name":"easy_private_token_contract-EasyPrivateToken::constructor","bytecode_size":76021} +{"name":"easy_private_token_contract-EasyPrivateToken::get_balance","bytecode_size":21075} +{"name":"easy_private_token_contract-EasyPrivateToken::mint","bytecode_size":74268} +{"name":"easy_private_token_contract-EasyPrivateToken::process_log","bytecode_size":16700} +{"name":"easy_private_token_contract-EasyPrivateToken::sync_notes","bytecode_size":516} +{"name":"easy_private_token_contract-EasyPrivateToken::transfer","bytecode_size":294981} +{"name":"easy_private_voting_contract-EasyPrivateVoting::add_to_tally_public","bytecode_size":2406} +{"name":"easy_private_voting_contract-EasyPrivateVoting::cast_vote","bytecode_size":8727} +{"name":"easy_private_voting_contract-EasyPrivateVoting::constructor","bytecode_size":3559} +{"name":"easy_private_voting_contract-EasyPrivateVoting::end_vote","bytecode_size":739} +{"name":"easy_private_voting_contract-EasyPrivateVoting::get_vote","bytecode_size":1809} +{"name":"easy_private_voting_contract-EasyPrivateVoting::process_log","bytecode_size":1655} +{"name":"easy_private_voting_contract-EasyPrivateVoting::public_dispatch","bytecode_size":5517} +{"name":"easy_private_voting_contract-EasyPrivateVoting::sync_notes","bytecode_size":516} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::constructor","bytecode_size":80420} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::entrypoint","bytecode_size":74347} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::process_log","bytecode_size":18391} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::sync_notes","bytecode_size":516} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::verify_private_authwit","bytecode_size":44192} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::constructor","bytecode_size":80420} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::entrypoint","bytecode_size":74282} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::process_log","bytecode_size":18391} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::sync_notes","bytecode_size":516} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::verify_private_authwit","bytecode_size":44297} +{"name":"escrow_contract-Escrow::constructor","bytecode_size":74545} +{"name":"escrow_contract-Escrow::process_log","bytecode_size":23808} +{"name":"escrow_contract-Escrow::sync_notes","bytecode_size":516} +{"name":"escrow_contract-Escrow::withdraw","bytecode_size":33106} +{"name":"fee_juice_contract-FeeJuice::_increase_public_balance","bytecode_size":2563} +{"name":"fee_juice_contract-FeeJuice::balance_of_public","bytecode_size":1823} +{"name":"fee_juice_contract-FeeJuice::check_balance","bytecode_size":2085} +{"name":"fee_juice_contract-FeeJuice::claim","bytecode_size":76197} +{"name":"fee_juice_contract-FeeJuice::initialize","bytecode_size":6540} +{"name":"fee_juice_contract-FeeJuice::process_log","bytecode_size":1655} +{"name":"fee_juice_contract-FeeJuice::public_dispatch","bytecode_size":5371} +{"name":"fee_juice_contract-FeeJuice::set_portal","bytecode_size":1737} +{"name":"fee_juice_contract-FeeJuice::sync_notes","bytecode_size":516} +{"name":"fpc_contract-FPC::complete_refund","bytecode_size":1837} +{"name":"fpc_contract-FPC::constructor","bytecode_size":4102} +{"name":"fpc_contract-FPC::fee_entrypoint_private","bytecode_size":32384} +{"name":"fpc_contract-FPC::fee_entrypoint_public","bytecode_size":31857} +{"name":"fpc_contract-FPC::get_accepted_asset","bytecode_size":30603} +{"name":"fpc_contract-FPC::pay_refund","bytecode_size":1838} +{"name":"fpc_contract-FPC::process_log","bytecode_size":16635} +{"name":"fpc_contract-FPC::public_dispatch","bytecode_size":7470} +{"name":"fpc_contract-FPC::pull_funds","bytecode_size":1813} +{"name":"fpc_contract-FPC::sync_notes","bytecode_size":516} +{"name":"import_test_contract-ImportTest::call_no_args","bytecode_size":32298} +{"name":"import_test_contract-ImportTest::call_public_fn","bytecode_size":31949} +{"name":"import_test_contract-ImportTest::main_contract","bytecode_size":32495} +{"name":"import_test_contract-ImportTest::process_log","bytecode_size":24708} +{"name":"import_test_contract-ImportTest::pub_call_public_fn","bytecode_size":1179} +{"name":"import_test_contract-ImportTest::public_dispatch","bytecode_size":1749} +{"name":"import_test_contract-ImportTest::sync_notes","bytecode_size":516} +{"name":"inclusion_proofs_contract-InclusionProofs::constructor","bytecode_size":3070} +{"name":"inclusion_proofs_contract-InclusionProofs::create_note","bytecode_size":74443} +{"name":"inclusion_proofs_contract-InclusionProofs::nullify_note","bytecode_size":43239} +{"name":"inclusion_proofs_contract-InclusionProofs::process_log","bytecode_size":16700} +{"name":"inclusion_proofs_contract-InclusionProofs::public_dispatch","bytecode_size":3823} +{"name":"inclusion_proofs_contract-InclusionProofs::push_nullifier_public","bytecode_size":692} +{"name":"inclusion_proofs_contract-InclusionProofs::sync_notes","bytecode_size":516} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_inclusion","bytecode_size":37382} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_non_inclusion","bytecode_size":41252} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion","bytecode_size":49813} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion_fail_case","bytecode_size":33516} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_not_nullified","bytecode_size":54684} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_validity","bytecode_size":57999} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion","bytecode_size":33902} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion_from_public","bytecode_size":690} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read","bytecode_size":36157} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read_unset_slot","bytecode_size":36218} +{"name":"lending_contract-Lending::_borrow","bytecode_size":9236} +{"name":"lending_contract-Lending::_deposit","bytecode_size":2741} +{"name":"lending_contract-Lending::_repay","bytecode_size":6498} +{"name":"lending_contract-Lending::_withdraw","bytecode_size":8470} +{"name":"lending_contract-Lending::borrow_private","bytecode_size":24566} +{"name":"lending_contract-Lending::borrow_public","bytecode_size":1292} +{"name":"lending_contract-Lending::constructor","bytecode_size":25535} +{"name":"lending_contract-Lending::deposit_private","bytecode_size":25152} +{"name":"lending_contract-Lending::deposit_public","bytecode_size":1608} +{"name":"lending_contract-Lending::get_asset","bytecode_size":2292} +{"name":"lending_contract-Lending::get_assets","bytecode_size":953} +{"name":"lending_contract-Lending::get_position","bytecode_size":5216} +{"name":"lending_contract-Lending::init","bytecode_size":2628} +{"name":"lending_contract-Lending::process_log","bytecode_size":16635} +{"name":"lending_contract-Lending::public_dispatch","bytecode_size":34158} +{"name":"lending_contract-Lending::repay_private","bytecode_size":25048} +{"name":"lending_contract-Lending::repay_public","bytecode_size":1649} +{"name":"lending_contract-Lending::sync_notes","bytecode_size":516} +{"name":"lending_contract-Lending::update_accumulator","bytecode_size":7448} +{"name":"lending_contract-Lending::withdraw_private","bytecode_size":24565} +{"name":"lending_contract-Lending::withdraw_public","bytecode_size":1284} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::entrypoint","bytecode_size":22132} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::process_log","bytecode_size":1655} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::sync_notes","bytecode_size":516} +{"name":"nft_contract-NFT::_finalize_transfer_to_private_unsafe","bytecode_size":4393} +{"name":"nft_contract-NFT::_finish_transfer_to_public","bytecode_size":1813} +{"name":"nft_contract-NFT::_store_payload_in_transient_storage_unsafe","bytecode_size":1746} +{"name":"nft_contract-NFT::cancel_authwit","bytecode_size":23246} +{"name":"nft_contract-NFT::constructor","bytecode_size":6357} +{"name":"nft_contract-NFT::finalize_transfer_to_private","bytecode_size":4357} +{"name":"nft_contract-NFT::get_admin","bytecode_size":734} +{"name":"nft_contract-NFT::get_private_nfts","bytecode_size":22430} +{"name":"nft_contract-NFT::is_minter","bytecode_size":1836} +{"name":"nft_contract-NFT::mint","bytecode_size":3176} +{"name":"nft_contract-NFT::owner_of","bytecode_size":2372} +{"name":"nft_contract-NFT::prepare_private_balance_increase","bytecode_size":70529} +{"name":"nft_contract-NFT::private_get_name","bytecode_size":30564} +{"name":"nft_contract-NFT::private_get_symbol","bytecode_size":30570} +{"name":"nft_contract-NFT::process_log","bytecode_size":16557} +{"name":"nft_contract-NFT::public_dispatch","bytecode_size":22926} +{"name":"nft_contract-NFT::public_get_name","bytecode_size":735} +{"name":"nft_contract-NFT::public_get_symbol","bytecode_size":729} +{"name":"nft_contract-NFT::set_admin","bytecode_size":790} +{"name":"nft_contract-NFT::set_minter","bytecode_size":1846} +{"name":"nft_contract-NFT::sync_notes","bytecode_size":516} +{"name":"nft_contract-NFT::transfer_in_private","bytecode_size":104038} +{"name":"nft_contract-NFT::transfer_in_public","bytecode_size":4525} +{"name":"nft_contract-NFT::transfer_to_private","bytecode_size":70684} +{"name":"nft_contract-NFT::transfer_to_public","bytecode_size":53653} +{"name":"parent_contract-Parent::enqueue_call_to_child","bytecode_size":23839} +{"name":"parent_contract-Parent::enqueue_call_to_child_twice","bytecode_size":23961} +{"name":"parent_contract-Parent::enqueue_call_to_pub_entry_point","bytecode_size":23786} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_first","bytecode_size":24344} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_last","bytecode_size":24290} +{"name":"parent_contract-Parent::enqueue_calls_to_pub_entry_point","bytecode_size":23879} +{"name":"parent_contract-Parent::enqueue_static_call_to_pub_function","bytecode_size":23849} +{"name":"parent_contract-Parent::enqueue_static_nested_call_to_pub_function","bytecode_size":23775} +{"name":"parent_contract-Parent::entry_point","bytecode_size":24247} +{"name":"parent_contract-Parent::private_call","bytecode_size":24253} +{"name":"parent_contract-Parent::private_nested_static_call","bytecode_size":24396} +{"name":"parent_contract-Parent::private_static_call","bytecode_size":24386} +{"name":"parent_contract-Parent::process_log","bytecode_size":16700} +{"name":"parent_contract-Parent::pub_entry_point","bytecode_size":1269} +{"name":"parent_contract-Parent::pub_entry_point_twice","bytecode_size":1548} +{"name":"parent_contract-Parent::public_dispatch","bytecode_size":4912} +{"name":"parent_contract-Parent::public_nested_static_call","bytecode_size":3407} +{"name":"parent_contract-Parent::public_static_call","bytecode_size":1755} +{"name":"parent_contract-Parent::sync_notes","bytecode_size":516} +{"name":"pending_note_hashes_contract-PendingNoteHashes::dummy","bytecode_size":22984} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_note_zero_balance","bytecode_size":62117} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_then_nullify_note","bytecode_size":43453} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note","bytecode_size":74375} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_extra_emit","bytecode_size":85778} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_static_randomness","bytecode_size":70166} +{"name":"pending_note_hashes_contract-PendingNoteHashes::process_log","bytecode_size":16700} +{"name":"pending_note_hashes_contract-PendingNoteHashes::recursively_destroy_and_create_notes","bytecode_size":460237} +{"name":"pending_note_hashes_contract-PendingNoteHashes::sync_notes","bytecode_size":516} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_bad_get_then_insert_flat","bytecode_size":95555} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_emit_bad_note_log","bytecode_size":85700} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert1_then_get2_then_nullify2_all_in_nested_calls","bytecode_size":24261} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify1_all_in_nested_calls","bytecode_size":24251} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify2_all_in_nested_calls","bytecode_size":24326} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_all_in_nested_calls","bytecode_size":24206} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_flat","bytecode_size":253714} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_recursively_create_notes","bytecode_size":311745} +{"name":"price_feed_contract-PriceFeed::get_price","bytecode_size":1812} +{"name":"price_feed_contract-PriceFeed::process_log","bytecode_size":1655} +{"name":"price_feed_contract-PriceFeed::public_dispatch","bytecode_size":3212} +{"name":"price_feed_contract-PriceFeed::set_price","bytecode_size":1696} +{"name":"price_feed_contract-PriceFeed::sync_notes","bytecode_size":516} +{"name":"router_contract-Router::_check_block_number","bytecode_size":1537} +{"name":"router_contract-Router::_check_timestamp","bytecode_size":1561} +{"name":"router_contract-Router::check_block_number","bytecode_size":5555} +{"name":"router_contract-Router::check_timestamp","bytecode_size":5562} +{"name":"router_contract-Router::process_log","bytecode_size":1655} +{"name":"router_contract-Router::public_dispatch","bytecode_size":2660} +{"name":"router_contract-Router::sync_notes","bytecode_size":516} +{"name":"schnorr_account_contract-SchnorrAccount::constructor","bytecode_size":67241} +{"name":"schnorr_account_contract-SchnorrAccount::entrypoint","bytecode_size":73078} +{"name":"schnorr_account_contract-SchnorrAccount::lookup_validity","bytecode_size":25868} +{"name":"schnorr_account_contract-SchnorrAccount::process_log","bytecode_size":16693} +{"name":"schnorr_account_contract-SchnorrAccount::sync_notes","bytecode_size":516} +{"name":"schnorr_account_contract-SchnorrAccount::verify_private_authwit","bytecode_size":43535} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::entrypoint","bytecode_size":53697} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::process_log","bytecode_size":1655} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::sync_notes","bytecode_size":516} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::verify_private_authwit","bytecode_size":23403} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::entrypoint","bytecode_size":50603} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::process_log","bytecode_size":1655} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::sync_notes","bytecode_size":516} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::verify_private_authwit","bytecode_size":19946} +{"name":"spam_contract-Spam::process_log","bytecode_size":23784} +{"name":"spam_contract-Spam::public_dispatch","bytecode_size":3092} +{"name":"spam_contract-Spam::public_spam","bytecode_size":2508} +{"name":"spam_contract-Spam::spam","bytecode_size":109031} +{"name":"spam_contract-Spam::sync_notes","bytecode_size":516} +{"name":"stateful_test_contract-StatefulTest::constructor","bytecode_size":26408} +{"name":"stateful_test_contract-StatefulTest::create_note","bytecode_size":76544} +{"name":"stateful_test_contract-StatefulTest::create_note_no_init_check","bytecode_size":76358} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create","bytecode_size":475999} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create_no_init_check","bytecode_size":475946} +{"name":"stateful_test_contract-StatefulTest::get_public_value","bytecode_size":1702} +{"name":"stateful_test_contract-StatefulTest::increment_public_value","bytecode_size":1790} +{"name":"stateful_test_contract-StatefulTest::increment_public_value_no_init_check","bytecode_size":1695} +{"name":"stateful_test_contract-StatefulTest::process_log","bytecode_size":16700} +{"name":"stateful_test_contract-StatefulTest::public_constructor","bytecode_size":3974} +{"name":"stateful_test_contract-StatefulTest::public_dispatch","bytecode_size":6535} +{"name":"stateful_test_contract-StatefulTest::summed_values","bytecode_size":21075} +{"name":"stateful_test_contract-StatefulTest::sync_notes","bytecode_size":516} +{"name":"stateful_test_contract-StatefulTest::wrong_constructor","bytecode_size":26179} +{"name":"static_child_contract-StaticChild::private_get_value","bytecode_size":54245} +{"name":"static_child_contract-StaticChild::private_illegal_set_value","bytecode_size":70428} +{"name":"static_child_contract-StaticChild::private_set_value","bytecode_size":70459} +{"name":"static_child_contract-StaticChild::process_log","bytecode_size":16700} +{"name":"static_child_contract-StaticChild::pub_get_value","bytecode_size":759} +{"name":"static_child_contract-StaticChild::pub_illegal_inc_value","bytecode_size":880} +{"name":"static_child_contract-StaticChild::pub_inc_value","bytecode_size":840} +{"name":"static_child_contract-StaticChild::pub_set_value","bytecode_size":809} +{"name":"static_child_contract-StaticChild::public_dispatch","bytecode_size":1920} +{"name":"static_child_contract-StaticChild::sync_notes","bytecode_size":516} +{"name":"static_parent_contract-StaticParent::enqueue_call","bytecode_size":23870} +{"name":"static_parent_contract-StaticParent::enqueue_public_get_value_from_child","bytecode_size":23810} +{"name":"static_parent_contract-StaticParent::enqueue_static_call_to_pub_function","bytecode_size":23849} +{"name":"static_parent_contract-StaticParent::enqueue_static_nested_call_to_pub_function","bytecode_size":23782} +{"name":"static_parent_contract-StaticParent::private_call","bytecode_size":24253} +{"name":"static_parent_contract-StaticParent::private_call_3_args","bytecode_size":24429} +{"name":"static_parent_contract-StaticParent::private_get_value_from_child","bytecode_size":24279} +{"name":"static_parent_contract-StaticParent::private_nested_static_call","bytecode_size":24345} +{"name":"static_parent_contract-StaticParent::private_nested_static_call_3_args","bytecode_size":24294} +{"name":"static_parent_contract-StaticParent::private_static_call","bytecode_size":24386} +{"name":"static_parent_contract-StaticParent::private_static_call_3_args","bytecode_size":24394} +{"name":"static_parent_contract-StaticParent::process_log","bytecode_size":16700} +{"name":"static_parent_contract-StaticParent::public_call","bytecode_size":1269} +{"name":"static_parent_contract-StaticParent::public_dispatch","bytecode_size":2769} +{"name":"static_parent_contract-StaticParent::public_get_value_from_child","bytecode_size":1215} +{"name":"static_parent_contract-StaticParent::public_nested_static_call","bytecode_size":1472} +{"name":"static_parent_contract-StaticParent::public_static_call","bytecode_size":1755} +{"name":"static_parent_contract-StaticParent::sync_notes","bytecode_size":516} +{"name":"test_contract-Test::assert_header_private","bytecode_size":31722} +{"name":"test_contract-Test::assert_private_global_vars","bytecode_size":31230} +{"name":"test_contract-Test::assert_public_global_vars","bytecode_size":940} +{"name":"test_contract-Test::call_create_note","bytecode_size":82377} +{"name":"test_contract-Test::call_destroy_note","bytecode_size":78240} +{"name":"test_contract-Test::call_get_notes","bytecode_size":70803} +{"name":"test_contract-Test::call_get_notes_many","bytecode_size":70630} +{"name":"test_contract-Test::call_view_notes","bytecode_size":28234} +{"name":"test_contract-Test::call_view_notes_many","bytecode_size":28307} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_private","bytecode_size":81241} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_public","bytecode_size":6082} +{"name":"test_contract-Test::consume_mint_to_private_message","bytecode_size":88804} +{"name":"test_contract-Test::consume_mint_to_public_message","bytecode_size":8825} +{"name":"test_contract-Test::consume_note_from_secret","bytecode_size":53551} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_private","bytecode_size":31204} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_public","bytecode_size":608} +{"name":"test_contract-Test::create_l2_to_l1_message_public","bytecode_size":2368} +{"name":"test_contract-Test::deliver_note","bytecode_size":46705} +{"name":"test_contract-Test::deploy_contract","bytecode_size":34604} +{"name":"test_contract-Test::dummy_public_call","bytecode_size":600} +{"name":"test_contract-Test::emit_array_as_encrypted_log","bytecode_size":56154} +{"name":"test_contract-Test::emit_encrypted_logs_nested","bytecode_size":78978} +{"name":"test_contract-Test::emit_nullifier","bytecode_size":31516} +{"name":"test_contract-Test::emit_nullifier_public","bytecode_size":590} +{"name":"test_contract-Test::emit_public","bytecode_size":1628} +{"name":"test_contract-Test::get_constant","bytecode_size":27586} +{"name":"test_contract-Test::get_master_incoming_viewing_public_key","bytecode_size":33860} +{"name":"test_contract-Test::get_ovsk_app","bytecode_size":32313} +{"name":"test_contract-Test::get_this_address","bytecode_size":31597} +{"name":"test_contract-Test::is_time_equal","bytecode_size":642} +{"name":"test_contract-Test::process_log","bytecode_size":24685} +{"name":"test_contract-Test::public_dispatch","bytecode_size":17249} +{"name":"test_contract-Test::set_constant","bytecode_size":32705} +{"name":"test_contract-Test::set_tx_max_block_number","bytecode_size":32004} +{"name":"test_contract-Test::sync_notes","bytecode_size":516} +{"name":"test_contract-Test::test_code_gen","bytecode_size":32031} +{"name":"test_contract-Test::test_nullifier_key_freshness","bytecode_size":33766} +{"name":"test_contract-Test::test_setting_fee_payer","bytecode_size":31919} +{"name":"test_contract-Test::test_setting_teardown","bytecode_size":31932} +{"name":"test_log_contract-TestLog::emit_encrypted_events","bytecode_size":105340} +{"name":"test_log_contract-TestLog::emit_unencrypted_events","bytecode_size":1122} +{"name":"test_log_contract-TestLog::process_log","bytecode_size":16700} +{"name":"test_log_contract-TestLog::public_dispatch","bytecode_size":2070} +{"name":"test_log_contract-TestLog::sync_notes","bytecode_size":516} +{"name":"token_blacklist_contract-TokenBlacklist::_increase_public_balance","bytecode_size":2658} +{"name":"token_blacklist_contract-TokenBlacklist::_reduce_total_supply","bytecode_size":1057} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_private","bytecode_size":26485} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_public","bytecode_size":1917} +{"name":"token_blacklist_contract-TokenBlacklist::burn","bytecode_size":271060} +{"name":"token_blacklist_contract-TokenBlacklist::burn_public","bytecode_size":6318} +{"name":"token_blacklist_contract-TokenBlacklist::constructor","bytecode_size":6782} +{"name":"token_blacklist_contract-TokenBlacklist::deliver_transparent_note","bytecode_size":39832} +{"name":"token_blacklist_contract-TokenBlacklist::get_roles","bytecode_size":2279} +{"name":"token_blacklist_contract-TokenBlacklist::mint_private","bytecode_size":3404} +{"name":"token_blacklist_contract-TokenBlacklist::mint_public","bytecode_size":4366} +{"name":"token_blacklist_contract-TokenBlacklist::process_log","bytecode_size":20037} +{"name":"token_blacklist_contract-TokenBlacklist::public_dispatch","bytecode_size":50353} +{"name":"token_blacklist_contract-TokenBlacklist::redeem_shield","bytecode_size":117798} +{"name":"token_blacklist_contract-TokenBlacklist::shield","bytecode_size":7387} +{"name":"token_blacklist_contract-TokenBlacklist::sync_notes","bytecode_size":516} +{"name":"token_blacklist_contract-TokenBlacklist::total_supply","bytecode_size":868} +{"name":"token_blacklist_contract-TokenBlacklist::transfer","bytecode_size":262855} +{"name":"token_blacklist_contract-TokenBlacklist::transfer_public","bytecode_size":8167} +{"name":"token_blacklist_contract-TokenBlacklist::unshield","bytecode_size":278431} +{"name":"token_blacklist_contract-TokenBlacklist::update_roles","bytecode_size":6200} +{"name":"token_bridge_contract-TokenBridge::claim_private","bytecode_size":88412} +{"name":"token_bridge_contract-TokenBridge::claim_public","bytecode_size":9631} +{"name":"token_bridge_contract-TokenBridge::constructor","bytecode_size":4102} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_private","bytecode_size":52691} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_public","bytecode_size":4805} +{"name":"token_bridge_contract-TokenBridge::get_config","bytecode_size":30654} +{"name":"token_bridge_contract-TokenBridge::get_config_public","bytecode_size":825} +{"name":"token_bridge_contract-TokenBridge::process_log","bytecode_size":16635} +{"name":"token_bridge_contract-TokenBridge::public_dispatch","bytecode_size":17134} +{"name":"token_bridge_contract-TokenBridge::sync_notes","bytecode_size":516} +{"name":"token_contract-Token::_finalize_mint_to_private_unsafe","bytecode_size":4532} +{"name":"token_contract-Token::_finalize_transfer_to_private_unsafe","bytecode_size":5044} +{"name":"token_contract-Token::_increase_public_balance","bytecode_size":2586} +{"name":"token_contract-Token::_recurse_subtract_balance","bytecode_size":119993} +{"name":"token_contract-Token::_reduce_total_supply","bytecode_size":1016} +{"name":"token_contract-Token::_store_payload_in_transient_storage_unsafe","bytecode_size":1746} +{"name":"token_contract-Token::balance_of_private","bytecode_size":21440} +{"name":"token_contract-Token::balance_of_public","bytecode_size":1911} +{"name":"token_contract-Token::burn_private","bytecode_size":252229} +{"name":"token_contract-Token::burn_public","bytecode_size":5316} +{"name":"token_contract-Token::cancel_authwit","bytecode_size":23329} +{"name":"token_contract-Token::constructor","bytecode_size":6753} +{"name":"token_contract-Token::finalize_mint_to_private","bytecode_size":4496} +{"name":"token_contract-Token::finalize_transfer_to_private","bytecode_size":5026} +{"name":"token_contract-Token::get_admin","bytecode_size":730} +{"name":"token_contract-Token::is_minter","bytecode_size":1833} +{"name":"token_contract-Token::mint_to_private","bytecode_size":70951} +{"name":"token_contract-Token::mint_to_public","bytecode_size":3213} +{"name":"token_contract-Token::prepare_private_balance_increase","bytecode_size":70693} +{"name":"token_contract-Token::private_get_decimals","bytecode_size":30618} +{"name":"token_contract-Token::private_get_name","bytecode_size":30661} +{"name":"token_contract-Token::private_get_symbol","bytecode_size":30684} +{"name":"token_contract-Token::process_log","bytecode_size":16635} +{"name":"token_contract-Token::public_dispatch","bytecode_size":37300} +{"name":"token_contract-Token::public_get_decimals","bytecode_size":783} +{"name":"token_contract-Token::public_get_name","bytecode_size":746} +{"name":"token_contract-Token::public_get_symbol","bytecode_size":753} +{"name":"token_contract-Token::set_admin","bytecode_size":771} +{"name":"token_contract-Token::set_minter","bytecode_size":1831} +{"name":"token_contract-Token::sync_notes","bytecode_size":516} +{"name":"token_contract-Token::total_supply","bytecode_size":848} +{"name":"token_contract-Token::transfer","bytecode_size":127661} +{"name":"token_contract-Token::transfer_in_private","bytecode_size":311699} +{"name":"token_contract-Token::transfer_in_public","bytecode_size":6411} +{"name":"token_contract-Token::transfer_to_private","bytecode_size":71024} +{"name":"token_contract-Token::transfer_to_public","bytecode_size":252091} +{"name":"uniswap_contract-Uniswap::_approve_bridge_and_exit_input_asset_to_L1","bytecode_size":6481} +{"name":"uniswap_contract-Uniswap::constructor","bytecode_size":3554} +{"name":"uniswap_contract-Uniswap::process_log","bytecode_size":16635} +{"name":"uniswap_contract-Uniswap::public_dispatch","bytecode_size":18095} +{"name":"uniswap_contract-Uniswap::swap_private","bytecode_size":77278} +{"name":"uniswap_contract-Uniswap::swap_public","bytecode_size":9280} +{"name":"uniswap_contract-Uniswap::sync_notes","bytecode_size":516} +{"name":"updatable_contract-Updatable::get_private_value","bytecode_size":19920} +{"name":"updatable_contract-Updatable::get_public_value","bytecode_size":18173} +{"name":"updatable_contract-Updatable::get_update_delay","bytecode_size":1265} +{"name":"updatable_contract-Updatable::initialize","bytecode_size":72190} +{"name":"updatable_contract-Updatable::process_log","bytecode_size":16700} +{"name":"updatable_contract-Updatable::public_dispatch","bytecode_size":1923} +{"name":"updatable_contract-Updatable::set_public_value","bytecode_size":699} +{"name":"updatable_contract-Updatable::set_update_delay","bytecode_size":23765} +{"name":"updatable_contract-Updatable::sync_notes","bytecode_size":516} +{"name":"updatable_contract-Updatable::update_to","bytecode_size":23749} +{"name":"updated_contract-Updated::get_private_value","bytecode_size":19920} +{"name":"updated_contract-Updated::get_public_value","bytecode_size":18173} +{"name":"updated_contract-Updated::get_update_delay","bytecode_size":1183} +{"name":"updated_contract-Updated::process_log","bytecode_size":16700} +{"name":"updated_contract-Updated::public_dispatch","bytecode_size":1814} +{"name":"updated_contract-Updated::set_private_value","bytecode_size":69334} +{"name":"updated_contract-Updated::set_public_value","bytecode_size":552} +{"name":"updated_contract-Updated::sync_notes","bytecode_size":516} diff --git a/scripts/bytecode-sizes/compare-bytecode-size.sh b/scripts/bytecode-sizes/compare-bytecode-size.sh new file mode 100755 index 00000000000..12c0bdace38 --- /dev/null +++ b/scripts/bytecode-sizes/compare-bytecode-size.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash +set -eu + +IN1=$1 +IN2=$2 + +jq --slurp -c ' +. as $top | +($top[] | select(.encoding == "base") | .data[]) as $base | +($top[] | select(.encoding == "alt") | .data[] | select(.name == $base.name)) as $alt | +{ + name: $base.name, + base_size: $base.bytecode_size, + alt_size: $alt.bytecode_size, + ratio: ($alt.bytecode_size / $base.bytecode_size) +} +' \ + <(cat $IN1 | jq --slurp '{encoding: "base", data: .}') \ + <(cat $IN2 | jq --slurp '{encoding: "alt", data: .}') \ diff --git a/scripts/bytecode-sizes/flexbuffers.jsonl b/scripts/bytecode-sizes/flexbuffers.jsonl new file mode 100644 index 00000000000..f2f707b10e4 --- /dev/null +++ b/scripts/bytecode-sizes/flexbuffers.jsonl @@ -0,0 +1,645 @@ +{"name":"parity_base","bytecode_size":132137} +{"name":"parity_root","bytecode_size":195369} +{"name":"private_kernel_init","bytecode_size":877913} +{"name":"private_kernel_init_simulated","bytecode_size":385003} +{"name":"private_kernel_inner","bytecode_size":1474626} +{"name":"private_kernel_inner_simulated","bytecode_size":548470} +{"name":"private_kernel_reset","bytecode_size":3563809} +{"name":"private_kernel_reset_simulated","bytecode_size":676273} +{"name":"private_kernel_tail","bytecode_size":643104} +{"name":"private_kernel_tail_simulated","bytecode_size":290026} +{"name":"private_kernel_tail_to_public","bytecode_size":1032856} +{"name":"private_kernel_tail_to_public_simulated","bytecode_size":443226} +{"name":"rollup_base_private","bytecode_size":4945646} +{"name":"rollup_base_private_simulated","bytecode_size":527527} +{"name":"rollup_base_public","bytecode_size":2397504} +{"name":"rollup_base_public_simulated","bytecode_size":455061} +{"name":"rollup_block_merge","bytecode_size":531093} +{"name":"rollup_block_root","bytecode_size":49341442} +{"name":"rollup_block_root_empty","bytecode_size":66040} +{"name":"rollup_block_root_simulated","bytecode_size":437365} +{"name":"rollup_block_root_single_tx","bytecode_size":49235159} +{"name":"rollup_block_root_single_tx_simulated","bytecode_size":393224} +{"name":"rollup_merge","bytecode_size":101367} +{"name":"rollup_root","bytecode_size":530963} +{"name":"amm_contract-AMM::_add_liquidity","bytecode_size":44005} +{"name":"amm_contract-AMM::_remove_liquidity","bytecode_size":27078} +{"name":"amm_contract-AMM::_swap_exact_tokens_for_tokens","bytecode_size":19947} +{"name":"amm_contract-AMM::_swap_tokens_for_exact_tokens","bytecode_size":22802} +{"name":"amm_contract-AMM::add_liquidity","bytecode_size":177007} +{"name":"amm_contract-AMM::constructor","bytecode_size":22424} +{"name":"amm_contract-AMM::get_amount_in_for_exact_out","bytecode_size":129931} +{"name":"amm_contract-AMM::get_amount_out_for_exact_in","bytecode_size":129506} +{"name":"amm_contract-AMM::process_log","bytecode_size":107077} +{"name":"amm_contract-AMM::public_dispatch","bytecode_size":132727} +{"name":"amm_contract-AMM::remove_liquidity","bytecode_size":169544} +{"name":"amm_contract-AMM::swap_exact_tokens_for_tokens","bytecode_size":169249} +{"name":"amm_contract-AMM::swap_tokens_for_exact_tokens","bytecode_size":170054} +{"name":"amm_contract-AMM::sync_notes","bytecode_size":965} +{"name":"app_subscription_contract-AppSubscription::constructor","bytecode_size":24341} +{"name":"app_subscription_contract-AppSubscription::entrypoint","bytecode_size":445495} +{"name":"app_subscription_contract-AppSubscription::is_initialized","bytecode_size":179915} +{"name":"app_subscription_contract-AppSubscription::process_log","bytecode_size":160846} +{"name":"app_subscription_contract-AppSubscription::public_dispatch","bytecode_size":28124} +{"name":"app_subscription_contract-AppSubscription::subscribe","bytecode_size":428609} +{"name":"app_subscription_contract-AppSubscription::sync_notes","bytecode_size":965} +{"name":"auth_contract-Auth::constructor","bytecode_size":16666} +{"name":"auth_contract-Auth::do_private_authorized_thing","bytecode_size":46204} +{"name":"auth_contract-Auth::get_authorized","bytecode_size":3816} +{"name":"auth_contract-Auth::get_authorized_delay","bytecode_size":3102} +{"name":"auth_contract-Auth::get_authorized_in_private","bytecode_size":47732} +{"name":"auth_contract-Auth::get_scheduled_authorized","bytecode_size":3378} +{"name":"auth_contract-Auth::process_log","bytecode_size":6085} +{"name":"auth_contract-Auth::public_dispatch","bytecode_size":67633} +{"name":"auth_contract-Auth::set_authorized","bytecode_size":24157} +{"name":"auth_contract-Auth::set_authorized_delay","bytecode_size":24239} +{"name":"auth_contract-Auth::sync_notes","bytecode_size":965} +{"name":"auth_registry_contract-AuthRegistry::_set_authorized","bytecode_size":9411} +{"name":"auth_registry_contract-AuthRegistry::consume","bytecode_size":26659} +{"name":"auth_registry_contract-AuthRegistry::is_consumable","bytecode_size":9454} +{"name":"auth_registry_contract-AuthRegistry::is_reject_all","bytecode_size":5903} +{"name":"auth_registry_contract-AuthRegistry::process_log","bytecode_size":6085} +{"name":"auth_registry_contract-AuthRegistry::public_dispatch","bytecode_size":66022} +{"name":"auth_registry_contract-AuthRegistry::set_authorized","bytecode_size":9222} +{"name":"auth_registry_contract-AuthRegistry::set_authorized_private","bytecode_size":23807} +{"name":"auth_registry_contract-AuthRegistry::set_reject_all","bytecode_size":5747} +{"name":"auth_registry_contract-AuthRegistry::sync_notes","bytecode_size":965} +{"name":"auth_registry_contract-AuthRegistry::unconstrained_is_consumable","bytecode_size":9759} +{"name":"auth_wit_test_contract-AuthWitTest::consume","bytecode_size":20881} +{"name":"auth_wit_test_contract-AuthWitTest::consume_public","bytecode_size":3676} +{"name":"auth_wit_test_contract-AuthWitTest::process_log","bytecode_size":6085} +{"name":"auth_wit_test_contract-AuthWitTest::public_dispatch","bytecode_size":6573} +{"name":"auth_wit_test_contract-AuthWitTest::sync_notes","bytecode_size":965} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_f1600","bytecode_size":2997} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_hash","bytecode_size":9971} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash","bytecode_size":10828} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash_with_index","bytecode_size":10829} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::poseidon2_hash","bytecode_size":7995} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::process_log","bytecode_size":6085} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::public_dispatch","bytecode_size":296545} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_10","bytecode_size":12304} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_100","bytecode_size":18085} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_20","bytecode_size":12424} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_2048","bytecode_size":95793} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_255","bytecode_size":25511} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_256","bytecode_size":24470} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_30","bytecode_size":13128} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_40","bytecode_size":13271} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_50","bytecode_size":13927} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_511","bytecode_size":36944} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_512","bytecode_size":35733} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_60","bytecode_size":14050} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_70","bytecode_size":17192} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_80","bytecode_size":17332} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_90","bytecode_size":18059} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sync_notes","bytecode_size":965} +{"name":"avm_initializer_test_contract-AvmInitializerTest::constructor","bytecode_size":12912} +{"name":"avm_initializer_test_contract-AvmInitializerTest::process_log","bytecode_size":6085} +{"name":"avm_initializer_test_contract-AvmInitializerTest::public_dispatch","bytecode_size":16491} +{"name":"avm_initializer_test_contract-AvmInitializerTest::read_storage_immutable","bytecode_size":1420} +{"name":"avm_initializer_test_contract-AvmInitializerTest::sync_notes","bytecode_size":965} +{"name":"avm_test_contract-AvmTest::add_args_return","bytecode_size":1162} +{"name":"avm_test_contract-AvmTest::add_storage_map","bytecode_size":12854} +{"name":"avm_test_contract-AvmTest::add_u128","bytecode_size":1697} +{"name":"avm_test_contract-AvmTest::assert_calldata_copy","bytecode_size":2958} +{"name":"avm_test_contract-AvmTest::assert_nullifier_exists","bytecode_size":1321} +{"name":"avm_test_contract-AvmTest::assert_same","bytecode_size":1275} +{"name":"avm_test_contract-AvmTest::assertion_failure","bytecode_size":1089} +{"name":"avm_test_contract-AvmTest::bulk_testing","bytecode_size":120787} +{"name":"avm_test_contract-AvmTest::create_different_nullifier_in_nested_call","bytecode_size":3410} +{"name":"avm_test_contract-AvmTest::create_same_nullifier_in_nested_call","bytecode_size":3324} +{"name":"avm_test_contract-AvmTest::debug_logging","bytecode_size":7343} +{"name":"avm_test_contract-AvmTest::divide_by_zero","bytecode_size":1065} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add","bytecode_size":3332} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add_and_double","bytecode_size":1272} +{"name":"avm_test_contract-AvmTest::emit_nullifier_and_check","bytecode_size":1382} +{"name":"avm_test_contract-AvmTest::emit_public_log","bytecode_size":11559} +{"name":"avm_test_contract-AvmTest::enqueue_public_from_private","bytecode_size":19665} +{"name":"avm_test_contract-AvmTest::external_call_to_assertion_failure","bytecode_size":3147} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero","bytecode_size":3153} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero_recovers","bytecode_size":11581} +{"name":"avm_test_contract-AvmTest::get_address","bytecode_size":1041} +{"name":"avm_test_contract-AvmTest::get_args_hash","bytecode_size":9106} +{"name":"avm_test_contract-AvmTest::get_block_number","bytecode_size":1053} +{"name":"avm_test_contract-AvmTest::get_chain_id","bytecode_size":1044} +{"name":"avm_test_contract-AvmTest::get_da_gas_left","bytecode_size":1050} +{"name":"avm_test_contract-AvmTest::get_fee_per_da_gas","bytecode_size":1053} +{"name":"avm_test_contract-AvmTest::get_fee_per_l2_gas","bytecode_size":1058} +{"name":"avm_test_contract-AvmTest::get_l2_gas_left","bytecode_size":1040} +{"name":"avm_test_contract-AvmTest::get_sender","bytecode_size":1037} +{"name":"avm_test_contract-AvmTest::get_timestamp","bytecode_size":1044} +{"name":"avm_test_contract-AvmTest::get_transaction_fee","bytecode_size":1051} +{"name":"avm_test_contract-AvmTest::get_version","bytecode_size":1040} +{"name":"avm_test_contract-AvmTest::helper_with_failed_assertion","bytecode_size":365} +{"name":"avm_test_contract-AvmTest::inner_helper_with_failed_assertion","bytecode_size":365} +{"name":"avm_test_contract-AvmTest::l1_to_l2_msg_exists","bytecode_size":1254} +{"name":"avm_test_contract-AvmTest::modulo2","bytecode_size":1166} +{"name":"avm_test_contract-AvmTest::n_new_l2_to_l1_msgs","bytecode_size":1398} +{"name":"avm_test_contract-AvmTest::n_new_note_hashes","bytecode_size":1405} +{"name":"avm_test_contract-AvmTest::n_new_nullifiers","bytecode_size":1400} +{"name":"avm_test_contract-AvmTest::n_new_public_logs","bytecode_size":1954} +{"name":"avm_test_contract-AvmTest::n_storage_writes","bytecode_size":5918} +{"name":"avm_test_contract-AvmTest::nested_call_to_add","bytecode_size":3548} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_n_times_different_addresses","bytecode_size":4815} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_with_gas","bytecode_size":3537} +{"name":"avm_test_contract-AvmTest::nested_call_to_assert_same","bytecode_size":3553} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing","bytecode_size":3120} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing_recovers","bytecode_size":2095} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_add","bytecode_size":3577} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_set_storage","bytecode_size":3219} +{"name":"avm_test_contract-AvmTest::new_note_hash","bytecode_size":1107} +{"name":"avm_test_contract-AvmTest::new_nullifier","bytecode_size":1107} +{"name":"avm_test_contract-AvmTest::note_hash_exists","bytecode_size":1266} +{"name":"avm_test_contract-AvmTest::nullifier_collision","bytecode_size":1157} +{"name":"avm_test_contract-AvmTest::nullifier_exists","bytecode_size":1231} +{"name":"avm_test_contract-AvmTest::pedersen_commit","bytecode_size":5364} +{"name":"avm_test_contract-AvmTest::process_log","bytecode_size":6085} +{"name":"avm_test_contract-AvmTest::public_dispatch","bytecode_size":301076} +{"name":"avm_test_contract-AvmTest::read_assert_storage_single","bytecode_size":1287} +{"name":"avm_test_contract-AvmTest::read_storage_list","bytecode_size":1861} +{"name":"avm_test_contract-AvmTest::read_storage_map","bytecode_size":5734} +{"name":"avm_test_contract-AvmTest::read_storage_single","bytecode_size":1109} +{"name":"avm_test_contract-AvmTest::return_oracle","bytecode_size":2558} +{"name":"avm_test_contract-AvmTest::returndata_copy_oracle","bytecode_size":6682} +{"name":"avm_test_contract-AvmTest::revert_oracle","bytecode_size":2552} +{"name":"avm_test_contract-AvmTest::send_l2_to_l1_msg","bytecode_size":1179} +{"name":"avm_test_contract-AvmTest::set_opcode_big_field","bytecode_size":1023} +{"name":"avm_test_contract-AvmTest::set_opcode_really_big_field","bytecode_size":1022} +{"name":"avm_test_contract-AvmTest::set_opcode_small_field","bytecode_size":1021} +{"name":"avm_test_contract-AvmTest::set_opcode_u32","bytecode_size":961} +{"name":"avm_test_contract-AvmTest::set_opcode_u64","bytecode_size":979} +{"name":"avm_test_contract-AvmTest::set_opcode_u8","bytecode_size":975} +{"name":"avm_test_contract-AvmTest::set_read_storage_single","bytecode_size":1248} +{"name":"avm_test_contract-AvmTest::set_storage_list","bytecode_size":1296} +{"name":"avm_test_contract-AvmTest::set_storage_map","bytecode_size":9112} +{"name":"avm_test_contract-AvmTest::set_storage_single","bytecode_size":1154} +{"name":"avm_test_contract-AvmTest::sync_notes","bytecode_size":965} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance","bytecode_size":2455} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance_matches","bytecode_size":2531} +{"name":"avm_test_contract-AvmTest::to_radix_le","bytecode_size":2366} +{"name":"avm_test_contract-AvmTest::u128_addition_overflow","bytecode_size":6826} +{"name":"avm_test_contract-AvmTest::u128_from_integer_overflow","bytecode_size":3979} +{"name":"avm_test_contract-AvmTest::variable_base_msm","bytecode_size":2887} +{"name":"benchmarking_contract-Benchmarking::broadcast","bytecode_size":6170} +{"name":"benchmarking_contract-Benchmarking::create_note","bytecode_size":312547} +{"name":"benchmarking_contract-Benchmarking::increment_balance","bytecode_size":11486} +{"name":"benchmarking_contract-Benchmarking::process_log","bytecode_size":112936} +{"name":"benchmarking_contract-Benchmarking::public_dispatch","bytecode_size":38219} +{"name":"benchmarking_contract-Benchmarking::recreate_note","bytecode_size":390058} +{"name":"benchmarking_contract-Benchmarking::sha256_hash_2048","bytecode_size":95793} +{"name":"benchmarking_contract-Benchmarking::sync_notes","bytecode_size":965} +{"name":"card_game_contract-CardGame::buy_pack","bytecode_size":484032} +{"name":"card_game_contract-CardGame::claim_cards","bytecode_size":563284} +{"name":"card_game_contract-CardGame::join_game","bytecode_size":1167966} +{"name":"card_game_contract-CardGame::on_card_played","bytecode_size":19985} +{"name":"card_game_contract-CardGame::on_cards_claimed","bytecode_size":24387} +{"name":"card_game_contract-CardGame::on_game_joined","bytecode_size":14207} +{"name":"card_game_contract-CardGame::play_card","bytecode_size":879678} +{"name":"card_game_contract-CardGame::process_log","bytecode_size":112936} +{"name":"card_game_contract-CardGame::public_dispatch","bytecode_size":84048} +{"name":"card_game_contract-CardGame::start_game","bytecode_size":22724} +{"name":"card_game_contract-CardGame::sync_notes","bytecode_size":965} +{"name":"card_game_contract-CardGame::view_collection_cards","bytecode_size":145108} +{"name":"card_game_contract-CardGame::view_game","bytecode_size":134004} +{"name":"card_game_contract-CardGame::view_game_cards","bytecode_size":148503} +{"name":"child_contract-Child::private_get_value","bytecode_size":234434} +{"name":"child_contract-Child::private_set_value","bytecode_size":313838} +{"name":"child_contract-Child::process_log","bytecode_size":112936} +{"name":"child_contract-Child::pub_get_value","bytecode_size":1460} +{"name":"child_contract-Child::pub_inc_value","bytecode_size":1919} +{"name":"child_contract-Child::pub_inc_value_internal","bytecode_size":2153} +{"name":"child_contract-Child::pub_set_value","bytecode_size":1814} +{"name":"child_contract-Child::public_dispatch","bytecode_size":17759} +{"name":"child_contract-Child::set_value_twice_with_nested_first","bytecode_size":3939} +{"name":"child_contract-Child::set_value_twice_with_nested_last","bytecode_size":3872} +{"name":"child_contract-Child::set_value_with_two_nested_calls","bytecode_size":5602} +{"name":"child_contract-Child::sync_notes","bytecode_size":965} +{"name":"child_contract-Child::value","bytecode_size":140742} +{"name":"child_contract-Child::value_internal","bytecode_size":140708} +{"name":"claim_contract-Claim::claim","bytecode_size":202301} +{"name":"claim_contract-Claim::constructor","bytecode_size":22066} +{"name":"claim_contract-Claim::process_log","bytecode_size":107077} +{"name":"claim_contract-Claim::public_dispatch","bytecode_size":25485} +{"name":"claim_contract-Claim::sync_notes","bytecode_size":965} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::assert_class_id_is_registered","bytecode_size":14901} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_private_function","bytecode_size":70594} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_unconstrained_function","bytecode_size":70252} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::process_log","bytecode_size":6085} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::register","bytecode_size":832290} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::sync_notes","bytecode_size":965} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::deploy","bytecode_size":29130} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::get_update_delay","bytecode_size":7454} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::process_log","bytecode_size":6085} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::public_dispatch","bytecode_size":59488} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::set_update_delay","bytecode_size":28800} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::sync_notes","bytecode_size":965} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::update","bytecode_size":29430} +{"name":"counter_contract-Counter::decrement","bytecode_size":916247} +{"name":"counter_contract-Counter::get_counter","bytecode_size":145806} +{"name":"counter_contract-Counter::increment","bytecode_size":301734} +{"name":"counter_contract-Counter::increment_and_decrement","bytecode_size":968206} +{"name":"counter_contract-Counter::increment_twice","bytecode_size":351593} +{"name":"counter_contract-Counter::initialize","bytecode_size":316972} +{"name":"counter_contract-Counter::process_log","bytecode_size":112936} +{"name":"counter_contract-Counter::sync_notes","bytecode_size":965} +{"name":"crowdfunding_contract-Crowdfunding::_publish_donation_receipts","bytecode_size":2508} +{"name":"crowdfunding_contract-Crowdfunding::donate","bytecode_size":320957} +{"name":"crowdfunding_contract-Crowdfunding::init","bytecode_size":22493} +{"name":"crowdfunding_contract-Crowdfunding::process_log","bytecode_size":107077} +{"name":"crowdfunding_contract-Crowdfunding::public_dispatch","bytecode_size":28413} +{"name":"crowdfunding_contract-Crowdfunding::sync_notes","bytecode_size":965} +{"name":"crowdfunding_contract-Crowdfunding::withdraw","bytecode_size":163766} +{"name":"docs_example_contract-DocsExample::get_imm_card","bytecode_size":150042} +{"name":"docs_example_contract-DocsExample::get_leader","bytecode_size":125039} +{"name":"docs_example_contract-DocsExample::get_legendary_card","bytecode_size":139524} +{"name":"docs_example_contract-DocsExample::get_public_immutable","bytecode_size":125007} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private","bytecode_size":166373} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private_indirect","bytecode_size":146120} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public","bytecode_size":1556} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_indirect","bytecode_size":3744} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_multiple","bytecode_size":2316} +{"name":"docs_example_contract-DocsExample::increase_legendary_points","bytecode_size":332350} +{"name":"docs_example_contract-DocsExample::initialize_private","bytecode_size":298994} +{"name":"docs_example_contract-DocsExample::initialize_private_immutable","bytecode_size":298925} +{"name":"docs_example_contract-DocsExample::initialize_public_immutable","bytecode_size":6456} +{"name":"docs_example_contract-DocsExample::insert_note","bytecode_size":298099} +{"name":"docs_example_contract-DocsExample::insert_notes","bytecode_size":383424} +{"name":"docs_example_contract-DocsExample::is_legendary_initialized","bytecode_size":127810} +{"name":"docs_example_contract-DocsExample::is_priv_imm_initialized","bytecode_size":127701} +{"name":"docs_example_contract-DocsExample::match_public_immutable","bytecode_size":164761} +{"name":"docs_example_contract-DocsExample::process_log","bytecode_size":112960} +{"name":"docs_example_contract-DocsExample::public_dispatch","bytecode_size":18848} +{"name":"docs_example_contract-DocsExample::read_note","bytecode_size":139287} +{"name":"docs_example_contract-DocsExample::simple_macro_example","bytecode_size":140703} +{"name":"docs_example_contract-DocsExample::simple_macro_example_expanded","bytecode_size":16995} +{"name":"docs_example_contract-DocsExample::spend_public_authwit","bytecode_size":1095} +{"name":"docs_example_contract-DocsExample::sync_notes","bytecode_size":965} +{"name":"docs_example_contract-DocsExample::update_leader","bytecode_size":1577} +{"name":"docs_example_contract-DocsExample::update_legendary_card","bytecode_size":318790} +{"name":"docs_example_contract-DocsExample::verify_private_authwit","bytecode_size":140792} +{"name":"docs_example_contract-DocsExample::view_imm_card","bytecode_size":139101} +{"name":"easy_private_token_contract-EasyPrivateToken::constructor","bytecode_size":316972} +{"name":"easy_private_token_contract-EasyPrivateToken::get_balance","bytecode_size":145806} +{"name":"easy_private_token_contract-EasyPrivateToken::mint","bytecode_size":311891} +{"name":"easy_private_token_contract-EasyPrivateToken::process_log","bytecode_size":112936} +{"name":"easy_private_token_contract-EasyPrivateToken::sync_notes","bytecode_size":965} +{"name":"easy_private_token_contract-EasyPrivateToken::transfer","bytecode_size":1037077} +{"name":"easy_private_voting_contract-EasyPrivateVoting::add_to_tally_public","bytecode_size":9931} +{"name":"easy_private_voting_contract-EasyPrivateVoting::cast_vote","bytecode_size":29468} +{"name":"easy_private_voting_contract-EasyPrivateVoting::constructor","bytecode_size":16725} +{"name":"easy_private_voting_contract-EasyPrivateVoting::end_vote","bytecode_size":1622} +{"name":"easy_private_voting_contract-EasyPrivateVoting::get_vote","bytecode_size":6151} +{"name":"easy_private_voting_contract-EasyPrivateVoting::process_log","bytecode_size":6085} +{"name":"easy_private_voting_contract-EasyPrivateVoting::public_dispatch","bytecode_size":29789} +{"name":"easy_private_voting_contract-EasyPrivateVoting::sync_notes","bytecode_size":965} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::constructor","bytecode_size":335049} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::entrypoint","bytecode_size":327912} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::process_log","bytecode_size":123092} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::sync_notes","bytecode_size":965} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::verify_private_authwit","bytecode_size":227776} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::constructor","bytecode_size":335049} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::entrypoint","bytecode_size":327912} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::process_log","bytecode_size":123092} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::sync_notes","bytecode_size":965} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::verify_private_authwit","bytecode_size":227615} +{"name":"escrow_contract-Escrow::constructor","bytecode_size":336419} +{"name":"escrow_contract-Escrow::process_log","bytecode_size":158244} +{"name":"escrow_contract-Escrow::sync_notes","bytecode_size":965} +{"name":"escrow_contract-Escrow::withdraw","bytecode_size":198058} +{"name":"fee_juice_contract-FeeJuice::_increase_public_balance","bytecode_size":10220} +{"name":"fee_juice_contract-FeeJuice::balance_of_public","bytecode_size":6209} +{"name":"fee_juice_contract-FeeJuice::check_balance","bytecode_size":7232} +{"name":"fee_juice_contract-FeeJuice::claim","bytecode_size":260342} +{"name":"fee_juice_contract-FeeJuice::initialize","bytecode_size":24018} +{"name":"fee_juice_contract-FeeJuice::process_log","bytecode_size":6085} +{"name":"fee_juice_contract-FeeJuice::public_dispatch","bytecode_size":29138} +{"name":"fee_juice_contract-FeeJuice::set_portal","bytecode_size":5701} +{"name":"fee_juice_contract-FeeJuice::sync_notes","bytecode_size":965} +{"name":"fpc_contract-FPC::complete_refund","bytecode_size":5816} +{"name":"fpc_contract-FPC::constructor","bytecode_size":19863} +{"name":"fpc_contract-FPC::fee_entrypoint_private","bytecode_size":171076} +{"name":"fpc_contract-FPC::fee_entrypoint_public","bytecode_size":167903} +{"name":"fpc_contract-FPC::get_accepted_asset","bytecode_size":159964} +{"name":"fpc_contract-FPC::pay_refund","bytecode_size":5941} +{"name":"fpc_contract-FPC::process_log","bytecode_size":107077} +{"name":"fpc_contract-FPC::public_dispatch","bytecode_size":40442} +{"name":"fpc_contract-FPC::pull_funds","bytecode_size":6274} +{"name":"fpc_contract-FPC::sync_notes","bytecode_size":965} +{"name":"import_test_contract-ImportTest::call_no_args","bytecode_size":198018} +{"name":"import_test_contract-ImportTest::call_public_fn","bytecode_size":194463} +{"name":"import_test_contract-ImportTest::main_contract","bytecode_size":198194} +{"name":"import_test_contract-ImportTest::process_log","bytecode_size":165186} +{"name":"import_test_contract-ImportTest::pub_call_public_fn","bytecode_size":3268} +{"name":"import_test_contract-ImportTest::public_dispatch","bytecode_size":6063} +{"name":"import_test_contract-ImportTest::sync_notes","bytecode_size":965} +{"name":"inclusion_proofs_contract-InclusionProofs::constructor","bytecode_size":12955} +{"name":"inclusion_proofs_contract-InclusionProofs::create_note","bytecode_size":312297} +{"name":"inclusion_proofs_contract-InclusionProofs::nullify_note","bytecode_size":222954} +{"name":"inclusion_proofs_contract-InclusionProofs::process_log","bytecode_size":112936} +{"name":"inclusion_proofs_contract-InclusionProofs::public_dispatch","bytecode_size":17711} +{"name":"inclusion_proofs_contract-InclusionProofs::push_nullifier_public","bytecode_size":1406} +{"name":"inclusion_proofs_contract-InclusionProofs::sync_notes","bytecode_size":965} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_inclusion","bytecode_size":187914} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_non_inclusion","bytecode_size":202962} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion","bytecode_size":248475} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion_fail_case","bytecode_size":178018} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_not_nullified","bytecode_size":267192} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_validity","bytecode_size":279805} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion","bytecode_size":178247} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion_from_public","bytecode_size":1529} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read","bytecode_size":187655} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read_unset_slot","bytecode_size":187660} +{"name":"lending_contract-Lending::_borrow","bytecode_size":44954} +{"name":"lending_contract-Lending::_deposit","bytecode_size":10402} +{"name":"lending_contract-Lending::_repay","bytecode_size":29070} +{"name":"lending_contract-Lending::_withdraw","bytecode_size":40733} +{"name":"lending_contract-Lending::borrow_private","bytecode_size":138372} +{"name":"lending_contract-Lending::borrow_public","bytecode_size":3833} +{"name":"lending_contract-Lending::constructor","bytecode_size":141218} +{"name":"lending_contract-Lending::deposit_private","bytecode_size":141845} +{"name":"lending_contract-Lending::deposit_public","bytecode_size":5979} +{"name":"lending_contract-Lending::get_asset","bytecode_size":8397} +{"name":"lending_contract-Lending::get_assets","bytecode_size":2362} +{"name":"lending_contract-Lending::get_position","bytecode_size":24298} +{"name":"lending_contract-Lending::init","bytecode_size":10114} +{"name":"lending_contract-Lending::process_log","bytecode_size":107077} +{"name":"lending_contract-Lending::public_dispatch","bytecode_size":195103} +{"name":"lending_contract-Lending::repay_private","bytecode_size":140479} +{"name":"lending_contract-Lending::repay_public","bytecode_size":5819} +{"name":"lending_contract-Lending::sync_notes","bytecode_size":965} +{"name":"lending_contract-Lending::update_accumulator","bytecode_size":34223} +{"name":"lending_contract-Lending::withdraw_private","bytecode_size":138430} +{"name":"lending_contract-Lending::withdraw_public","bytecode_size":3839} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::entrypoint","bytecode_size":70395} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::process_log","bytecode_size":6085} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::sync_notes","bytecode_size":965} +{"name":"nft_contract-NFT::_finalize_transfer_to_private_unsafe","bytecode_size":19855} +{"name":"nft_contract-NFT::_finish_transfer_to_public","bytecode_size":6130} +{"name":"nft_contract-NFT::_store_payload_in_transient_storage_unsafe","bytecode_size":5871} +{"name":"nft_contract-NFT::cancel_authwit","bytecode_size":133621} +{"name":"nft_contract-NFT::constructor","bytecode_size":33062} +{"name":"nft_contract-NFT::finalize_transfer_to_private","bytecode_size":19640} +{"name":"nft_contract-NFT::get_admin","bytecode_size":1624} +{"name":"nft_contract-NFT::get_private_nfts","bytecode_size":148533} +{"name":"nft_contract-NFT::is_minter","bytecode_size":6194} +{"name":"nft_contract-NFT::mint","bytecode_size":17019} +{"name":"nft_contract-NFT::owner_of","bytecode_size":9816} +{"name":"nft_contract-NFT::prepare_private_balance_increase","bytecode_size":292157} +{"name":"nft_contract-NFT::private_get_name","bytecode_size":159523} +{"name":"nft_contract-NFT::private_get_symbol","bytecode_size":159548} +{"name":"nft_contract-NFT::process_log","bytecode_size":106448} +{"name":"nft_contract-NFT::public_dispatch","bytecode_size":149527} +{"name":"nft_contract-NFT::public_get_name","bytecode_size":1620} +{"name":"nft_contract-NFT::public_get_symbol","bytecode_size":1593} +{"name":"nft_contract-NFT::set_admin","bytecode_size":1702} +{"name":"nft_contract-NFT::set_minter","bytecode_size":6255} +{"name":"nft_contract-NFT::sync_notes","bytecode_size":965} +{"name":"nft_contract-NFT::transfer_in_private","bytecode_size":415691} +{"name":"nft_contract-NFT::transfer_in_public","bytecode_size":21443} +{"name":"nft_contract-NFT::transfer_to_private","bytecode_size":292396} +{"name":"nft_contract-NFT::transfer_to_public","bytecode_size":252027} +{"name":"parent_contract-Parent::enqueue_call_to_child","bytecode_size":142182} +{"name":"parent_contract-Parent::enqueue_call_to_child_twice","bytecode_size":142630} +{"name":"parent_contract-Parent::enqueue_call_to_pub_entry_point","bytecode_size":142003} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_first","bytecode_size":145692} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_last","bytecode_size":145486} +{"name":"parent_contract-Parent::enqueue_calls_to_pub_entry_point","bytecode_size":142335} +{"name":"parent_contract-Parent::enqueue_static_call_to_pub_function","bytecode_size":141995} +{"name":"parent_contract-Parent::enqueue_static_nested_call_to_pub_function","bytecode_size":142017} +{"name":"parent_contract-Parent::entry_point","bytecode_size":143901} +{"name":"parent_contract-Parent::private_call","bytecode_size":146005} +{"name":"parent_contract-Parent::private_nested_static_call","bytecode_size":145493} +{"name":"parent_contract-Parent::private_static_call","bytecode_size":145873} +{"name":"parent_contract-Parent::process_log","bytecode_size":112936} +{"name":"parent_contract-Parent::pub_entry_point","bytecode_size":3534} +{"name":"parent_contract-Parent::pub_entry_point_twice","bytecode_size":5329} +{"name":"parent_contract-Parent::public_dispatch","bytecode_size":28079} +{"name":"parent_contract-Parent::public_nested_static_call","bytecode_size":14582} +{"name":"parent_contract-Parent::public_static_call","bytecode_size":5564} +{"name":"parent_contract-Parent::sync_notes","bytecode_size":965} +{"name":"pending_note_hashes_contract-PendingNoteHashes::dummy","bytecode_size":138808} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_note_zero_balance","bytecode_size":279403} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_then_nullify_note","bytecode_size":224557} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note","bytecode_size":312624} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_extra_emit","bytecode_size":346816} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_static_randomness","bytecode_size":298592} +{"name":"pending_note_hashes_contract-PendingNoteHashes::process_log","bytecode_size":112936} +{"name":"pending_note_hashes_contract-PendingNoteHashes::recursively_destroy_and_create_notes","bytecode_size":1513697} +{"name":"pending_note_hashes_contract-PendingNoteHashes::sync_notes","bytecode_size":965} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_bad_get_then_insert_flat","bytecode_size":426365} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_emit_bad_note_log","bytecode_size":346771} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert1_then_get2_then_nullify2_all_in_nested_calls","bytecode_size":145143} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify1_all_in_nested_calls","bytecode_size":144996} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify2_all_in_nested_calls","bytecode_size":145318} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_all_in_nested_calls","bytecode_size":144801} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_flat","bytecode_size":913218} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_recursively_create_notes","bytecode_size":1046846} +{"name":"price_feed_contract-PriceFeed::get_price","bytecode_size":6229} +{"name":"price_feed_contract-PriceFeed::process_log","bytecode_size":6085} +{"name":"price_feed_contract-PriceFeed::public_dispatch","bytecode_size":13805} +{"name":"price_feed_contract-PriceFeed::set_price","bytecode_size":5823} +{"name":"price_feed_contract-PriceFeed::sync_notes","bytecode_size":965} +{"name":"router_contract-Router::_check_block_number","bytecode_size":4873} +{"name":"router_contract-Router::_check_timestamp","bytecode_size":4953} +{"name":"router_contract-Router::check_block_number","bytecode_size":18242} +{"name":"router_contract-Router::check_timestamp","bytecode_size":18302} +{"name":"router_contract-Router::process_log","bytecode_size":6085} +{"name":"router_contract-Router::public_dispatch","bytecode_size":10187} +{"name":"router_contract-Router::sync_notes","bytecode_size":965} +{"name":"schnorr_account_contract-SchnorrAccount::constructor","bytecode_size":289672} +{"name":"schnorr_account_contract-SchnorrAccount::entrypoint","bytecode_size":308736} +{"name":"schnorr_account_contract-SchnorrAccount::lookup_validity","bytecode_size":175192} +{"name":"schnorr_account_contract-SchnorrAccount::process_log","bytecode_size":112883} +{"name":"schnorr_account_contract-SchnorrAccount::sync_notes","bytecode_size":965} +{"name":"schnorr_account_contract-SchnorrAccount::verify_private_authwit","bytecode_size":208068} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::entrypoint","bytecode_size":173401} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::process_log","bytecode_size":6085} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::sync_notes","bytecode_size":965} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::verify_private_authwit","bytecode_size":75900} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::entrypoint","bytecode_size":160633} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::process_log","bytecode_size":6085} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::sync_notes","bytecode_size":965} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::verify_private_authwit","bytecode_size":63474} +{"name":"spam_contract-Spam::process_log","bytecode_size":164633} +{"name":"spam_contract-Spam::public_dispatch","bytecode_size":13024} +{"name":"spam_contract-Spam::public_spam","bytecode_size":10133} +{"name":"spam_contract-Spam::spam","bytecode_size":594958} +{"name":"spam_contract-Spam::sync_notes","bytecode_size":965} +{"name":"stateful_test_contract-StatefulTest::constructor","bytecode_size":149601} +{"name":"stateful_test_contract-StatefulTest::create_note","bytecode_size":319048} +{"name":"stateful_test_contract-StatefulTest::create_note_no_init_check","bytecode_size":318720} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create","bytecode_size":1563638} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create_no_init_check","bytecode_size":1563070} +{"name":"stateful_test_contract-StatefulTest::get_public_value","bytecode_size":5833} +{"name":"stateful_test_contract-StatefulTest::increment_public_value","bytecode_size":6005} +{"name":"stateful_test_contract-StatefulTest::increment_public_value_no_init_check","bytecode_size":5740} +{"name":"stateful_test_contract-StatefulTest::process_log","bytecode_size":112936} +{"name":"stateful_test_contract-StatefulTest::public_constructor","bytecode_size":17892} +{"name":"stateful_test_contract-StatefulTest::public_dispatch","bytecode_size":36058} +{"name":"stateful_test_contract-StatefulTest::summed_values","bytecode_size":145806} +{"name":"stateful_test_contract-StatefulTest::sync_notes","bytecode_size":965} +{"name":"stateful_test_contract-StatefulTest::wrong_constructor","bytecode_size":148945} +{"name":"static_child_contract-StaticChild::private_get_value","bytecode_size":254991} +{"name":"static_child_contract-StaticChild::private_illegal_set_value","bytecode_size":299512} +{"name":"static_child_contract-StaticChild::private_set_value","bytecode_size":299889} +{"name":"static_child_contract-StaticChild::process_log","bytecode_size":112936} +{"name":"static_child_contract-StaticChild::pub_get_value","bytecode_size":1657} +{"name":"static_child_contract-StaticChild::pub_illegal_inc_value","bytecode_size":2096} +{"name":"static_child_contract-StaticChild::pub_inc_value","bytecode_size":1919} +{"name":"static_child_contract-StaticChild::pub_set_value","bytecode_size":1814} +{"name":"static_child_contract-StaticChild::public_dispatch","bytecode_size":8568} +{"name":"static_child_contract-StaticChild::sync_notes","bytecode_size":965} +{"name":"static_parent_contract-StaticParent::enqueue_call","bytecode_size":142214} +{"name":"static_parent_contract-StaticParent::enqueue_public_get_value_from_child","bytecode_size":141962} +{"name":"static_parent_contract-StaticParent::enqueue_static_call_to_pub_function","bytecode_size":141995} +{"name":"static_parent_contract-StaticParent::enqueue_static_nested_call_to_pub_function","bytecode_size":141937} +{"name":"static_parent_contract-StaticParent::private_call","bytecode_size":146005} +{"name":"static_parent_contract-StaticParent::private_call_3_args","bytecode_size":145933} +{"name":"static_parent_contract-StaticParent::private_get_value_from_child","bytecode_size":145423} +{"name":"static_parent_contract-StaticParent::private_nested_static_call","bytecode_size":145662} +{"name":"static_parent_contract-StaticParent::private_nested_static_call_3_args","bytecode_size":145369} +{"name":"static_parent_contract-StaticParent::private_static_call","bytecode_size":145873} +{"name":"static_parent_contract-StaticParent::private_static_call_3_args","bytecode_size":145605} +{"name":"static_parent_contract-StaticParent::process_log","bytecode_size":112936} +{"name":"static_parent_contract-StaticParent::public_call","bytecode_size":3534} +{"name":"static_parent_contract-StaticParent::public_dispatch","bytecode_size":15313} +{"name":"static_parent_contract-StaticParent::public_get_value_from_child","bytecode_size":3466} +{"name":"static_parent_contract-StaticParent::public_nested_static_call","bytecode_size":4303} +{"name":"static_parent_contract-StaticParent::public_static_call","bytecode_size":5564} +{"name":"static_parent_contract-StaticParent::sync_notes","bytecode_size":965} +{"name":"test_contract-Test::assert_header_private","bytecode_size":192143} +{"name":"test_contract-Test::assert_private_global_vars","bytecode_size":190958} +{"name":"test_contract-Test::assert_public_global_vars","bytecode_size":2334} +{"name":"test_contract-Test::call_create_note","bytecode_size":366702} +{"name":"test_contract-Test::call_destroy_note","bytecode_size":368526} +{"name":"test_contract-Test::call_get_notes","bytecode_size":335103} +{"name":"test_contract-Test::call_get_notes_many","bytecode_size":335103} +{"name":"test_contract-Test::call_view_notes","bytecode_size":191461} +{"name":"test_contract-Test::call_view_notes_many","bytecode_size":191930} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_private","bytecode_size":362459} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_public","bytecode_size":33165} +{"name":"test_contract-Test::consume_mint_to_private_message","bytecode_size":390879} +{"name":"test_contract-Test::consume_mint_to_public_message","bytecode_size":51409} +{"name":"test_contract-Test::consume_note_from_secret","bytecode_size":278442} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_private","bytecode_size":191117} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_public","bytecode_size":1180} +{"name":"test_contract-Test::create_l2_to_l1_message_public","bytecode_size":8320} +{"name":"test_contract-Test::deliver_note","bytecode_size":323762} +{"name":"test_contract-Test::deploy_contract","bytecode_size":203146} +{"name":"test_contract-Test::dummy_public_call","bytecode_size":1172} +{"name":"test_contract-Test::emit_array_as_encrypted_log","bytecode_size":353051} +{"name":"test_contract-Test::emit_encrypted_logs_nested","bytecode_size":356060} +{"name":"test_contract-Test::emit_nullifier","bytecode_size":191829} +{"name":"test_contract-Test::emit_nullifier_public","bytecode_size":1107} +{"name":"test_contract-Test::emit_public","bytecode_size":5895} +{"name":"test_contract-Test::get_constant","bytecode_size":186667} +{"name":"test_contract-Test::get_master_incoming_viewing_public_key","bytecode_size":201550} +{"name":"test_contract-Test::get_ovsk_app","bytecode_size":195888} +{"name":"test_contract-Test::get_this_address","bytecode_size":193161} +{"name":"test_contract-Test::is_time_equal","bytecode_size":1291} +{"name":"test_contract-Test::process_log","bytecode_size":165244} +{"name":"test_contract-Test::public_dispatch","bytecode_size":102750} +{"name":"test_contract-Test::set_constant","bytecode_size":198574} +{"name":"test_contract-Test::set_tx_max_block_number","bytecode_size":194509} +{"name":"test_contract-Test::sync_notes","bytecode_size":965} +{"name":"test_contract-Test::test_code_gen","bytecode_size":194071} +{"name":"test_contract-Test::test_nullifier_key_freshness","bytecode_size":200155} +{"name":"test_contract-Test::test_setting_fee_payer","bytecode_size":194473} +{"name":"test_contract-Test::test_setting_teardown","bytecode_size":193868} +{"name":"test_log_contract-TestLog::emit_encrypted_events","bytecode_size":399523} +{"name":"test_log_contract-TestLog::emit_unencrypted_events","bytecode_size":3515} +{"name":"test_log_contract-TestLog::process_log","bytecode_size":112936} +{"name":"test_log_contract-TestLog::public_dispatch","bytecode_size":7931} +{"name":"test_log_contract-TestLog::sync_notes","bytecode_size":965} +{"name":"token_blacklist_contract-TokenBlacklist::_increase_public_balance","bytecode_size":10679} +{"name":"token_blacklist_contract-TokenBlacklist::_reduce_total_supply","bytecode_size":2767} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_private","bytecode_size":187785} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_public","bytecode_size":6481} +{"name":"token_blacklist_contract-TokenBlacklist::burn","bytecode_size":949051} +{"name":"token_blacklist_contract-TokenBlacklist::burn_public","bytecode_size":34065} +{"name":"token_blacklist_contract-TokenBlacklist::constructor","bytecode_size":41403} +{"name":"token_blacklist_contract-TokenBlacklist::deliver_transparent_note","bytecode_size":288538} +{"name":"token_blacklist_contract-TokenBlacklist::get_roles","bytecode_size":8564} +{"name":"token_blacklist_contract-TokenBlacklist::mint_private","bytecode_size":15268} +{"name":"token_blacklist_contract-TokenBlacklist::mint_public","bytecode_size":22810} +{"name":"token_blacklist_contract-TokenBlacklist::process_log","bytecode_size":141221} +{"name":"token_blacklist_contract-TokenBlacklist::public_dispatch","bytecode_size":421824} +{"name":"token_blacklist_contract-TokenBlacklist::redeem_shield","bytecode_size":482139} +{"name":"token_blacklist_contract-TokenBlacklist::shield","bytecode_size":39974} +{"name":"token_blacklist_contract-TokenBlacklist::sync_notes","bytecode_size":965} +{"name":"token_blacklist_contract-TokenBlacklist::total_supply","bytecode_size":2044} +{"name":"token_blacklist_contract-TokenBlacklist::transfer","bytecode_size":1012275} +{"name":"token_blacklist_contract-TokenBlacklist::transfer_public","bytecode_size":48020} +{"name":"token_blacklist_contract-TokenBlacklist::unshield","bytecode_size":971997} +{"name":"token_blacklist_contract-TokenBlacklist::update_roles","bytecode_size":36899} +{"name":"token_bridge_contract-TokenBridge::claim_private","bytecode_size":359546} +{"name":"token_bridge_contract-TokenBridge::claim_public","bytecode_size":54296} +{"name":"token_bridge_contract-TokenBridge::constructor","bytecode_size":19863} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_private","bytecode_size":237567} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_public","bytecode_size":26307} +{"name":"token_bridge_contract-TokenBridge::get_config","bytecode_size":160264} +{"name":"token_bridge_contract-TokenBridge::get_config_public","bytecode_size":1907} +{"name":"token_bridge_contract-TokenBridge::process_log","bytecode_size":107077} +{"name":"token_bridge_contract-TokenBridge::public_dispatch","bytecode_size":103345} +{"name":"token_bridge_contract-TokenBridge::sync_notes","bytecode_size":965} +{"name":"token_contract-Token::_finalize_mint_to_private_unsafe","bytecode_size":20687} +{"name":"token_contract-Token::_finalize_transfer_to_private_unsafe","bytecode_size":24076} +{"name":"token_contract-Token::_increase_public_balance","bytecode_size":10470} +{"name":"token_contract-Token::_recurse_subtract_balance","bytecode_size":492342} +{"name":"token_contract-Token::_reduce_total_supply","bytecode_size":2623} +{"name":"token_contract-Token::_store_payload_in_transient_storage_unsafe","bytecode_size":5871} +{"name":"token_contract-Token::balance_of_private","bytecode_size":143147} +{"name":"token_contract-Token::balance_of_public","bytecode_size":6438} +{"name":"token_contract-Token::burn_private","bytecode_size":895936} +{"name":"token_contract-Token::burn_public","bytecode_size":26807} +{"name":"token_contract-Token::cancel_authwit","bytecode_size":133832} +{"name":"token_contract-Token::constructor","bytecode_size":36883} +{"name":"token_contract-Token::finalize_mint_to_private","bytecode_size":20552} +{"name":"token_contract-Token::finalize_transfer_to_private","bytecode_size":23904} +{"name":"token_contract-Token::get_admin","bytecode_size":1592} +{"name":"token_contract-Token::is_minter","bytecode_size":6194} +{"name":"token_contract-Token::mint_to_private","bytecode_size":293348} +{"name":"token_contract-Token::mint_to_public","bytecode_size":14580} +{"name":"token_contract-Token::prepare_private_balance_increase","bytecode_size":292346} +{"name":"token_contract-Token::private_get_decimals","bytecode_size":159961} +{"name":"token_contract-Token::private_get_name","bytecode_size":159773} +{"name":"token_contract-Token::private_get_symbol","bytecode_size":160008} +{"name":"token_contract-Token::process_log","bytecode_size":107077} +{"name":"token_contract-Token::public_dispatch","bytecode_size":241835} +{"name":"token_contract-Token::public_get_decimals","bytecode_size":1712} +{"name":"token_contract-Token::public_get_name","bytecode_size":1634} +{"name":"token_contract-Token::public_get_symbol","bytecode_size":1650} +{"name":"token_contract-Token::set_admin","bytecode_size":1702} +{"name":"token_contract-Token::set_minter","bytecode_size":6237} +{"name":"token_contract-Token::sync_notes","bytecode_size":965} +{"name":"token_contract-Token::total_supply","bytecode_size":2001} +{"name":"token_contract-Token::transfer","bytecode_size":713305} +{"name":"token_contract-Token::transfer_in_private","bytecode_size":1087851} +{"name":"token_contract-Token::transfer_in_public","bytecode_size":35240} +{"name":"token_contract-Token::transfer_to_private","bytecode_size":293213} +{"name":"token_contract-Token::transfer_to_public","bytecode_size":897229} +{"name":"uniswap_contract-Uniswap::_approve_bridge_and_exit_input_asset_to_L1","bytecode_size":35065} +{"name":"uniswap_contract-Uniswap::constructor","bytecode_size":16495} +{"name":"uniswap_contract-Uniswap::process_log","bytecode_size":107077} +{"name":"uniswap_contract-Uniswap::public_dispatch","bytecode_size":115643} +{"name":"uniswap_contract-Uniswap::swap_private","bytecode_size":325309} +{"name":"uniswap_contract-Uniswap::swap_public","bytecode_size":61125} +{"name":"uniswap_contract-Uniswap::sync_notes","bytecode_size":965} +{"name":"updatable_contract-Updatable::get_private_value","bytecode_size":138313} +{"name":"updatable_contract-Updatable::get_public_value","bytecode_size":124093} +{"name":"updatable_contract-Updatable::get_update_delay","bytecode_size":3656} +{"name":"updatable_contract-Updatable::initialize","bytecode_size":306461} +{"name":"updatable_contract-Updatable::process_log","bytecode_size":112936} +{"name":"updatable_contract-Updatable::public_dispatch","bytecode_size":7281} +{"name":"updatable_contract-Updatable::set_public_value","bytecode_size":1459} +{"name":"updatable_contract-Updatable::set_update_delay","bytecode_size":141940} +{"name":"updatable_contract-Updatable::sync_notes","bytecode_size":965} +{"name":"updatable_contract-Updatable::update_to","bytecode_size":141900} +{"name":"updated_contract-Updated::get_private_value","bytecode_size":138313} +{"name":"updated_contract-Updated::get_public_value","bytecode_size":124093} +{"name":"updated_contract-Updated::get_update_delay","bytecode_size":3370} +{"name":"updated_contract-Updated::process_log","bytecode_size":112936} +{"name":"updated_contract-Updated::public_dispatch","bytecode_size":6571} +{"name":"updated_contract-Updated::set_private_value","bytecode_size":301812} +{"name":"updated_contract-Updated::set_public_value","bytecode_size":1071} +{"name":"updated_contract-Updated::sync_notes","bytecode_size":965} diff --git a/scripts/bytecode-sizes/plot-bytecode-size.sh b/scripts/bytecode-sizes/plot-bytecode-size.sh new file mode 100755 index 00000000000..39d62876171 --- /dev/null +++ b/scripts/bytecode-sizes/plot-bytecode-size.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +set -eu + +IN=$1 +NAME=$(basename $IN .jsonl) +DAT=$(dirname $IN)/$NAME.dat +PNG=$(dirname $IN)/$NAME.png +PLT=$(dirname $0)/bytecode-size-scatter.plt + +cat $IN | jq -r '[.name, .base_size, .alt_size, .ratio] | @tsv' > $DAT + +gnuplot \ + -e "NAME='$(echo $NAME | tr _ - )'" \ + -e "FILEIN='$DAT'" \ + -e "FILEOUT='$PNG'" \ + $PLT + +rm $DAT diff --git a/scripts/bytecode-sizes/print-bytecode-size.sh b/scripts/bytecode-sizes/print-bytecode-size.sh new file mode 100755 index 00000000000..8b68c5907ef --- /dev/null +++ b/scripts/bytecode-sizes/print-bytecode-size.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +set -eu + +AZTEC_PACKAGES_DIR=$1 + +for file in $AZTEC_PACKAGES_DIR/noir-projects/noir-protocol-circuits/target/*.json; do + PROGRAM=$(basename $file .json) + cat $file \ + | jq --arg PROGRAM $PROGRAM \ + -c '{name: $PROGRAM, bytecode_size: .bytecode | @base64d | length}' +done + +for file in $AZTEC_PACKAGES_DIR/noir-projects/noir-contracts/target/*.json; do + CONTRACT=$(basename $file .json) + cat $file \ + | jq --arg CONTRACT $CONTRACT \ + -c '.functions | sort_by(.name) | .[] | {name: ($CONTRACT + "::" + .name), "bytecode_size": .bytecode | @base64d | length}' +done diff --git a/scripts/bytecode-sizes/protobuf.jsonl b/scripts/bytecode-sizes/protobuf.jsonl new file mode 100644 index 00000000000..be0e8f2956d --- /dev/null +++ b/scripts/bytecode-sizes/protobuf.jsonl @@ -0,0 +1,645 @@ +{"name":"parity_base","bytecode_size":35233} +{"name":"parity_root","bytecode_size":53444} +{"name":"private_kernel_init","bytecode_size":202567} +{"name":"private_kernel_init_simulated","bytecode_size":57905} +{"name":"private_kernel_inner","bytecode_size":332017} +{"name":"private_kernel_inner_simulated","bytecode_size":82266} +{"name":"private_kernel_reset","bytecode_size":842107} +{"name":"private_kernel_reset_simulated","bytecode_size":96108} +{"name":"private_kernel_tail","bytecode_size":110310} +{"name":"private_kernel_tail_simulated","bytecode_size":43124} +{"name":"private_kernel_tail_to_public","bytecode_size":198582} +{"name":"private_kernel_tail_to_public_simulated","bytecode_size":64261} +{"name":"rollup_base_private","bytecode_size":1257801} +{"name":"rollup_base_private_simulated","bytecode_size":72339} +{"name":"rollup_base_public","bytecode_size":626991} +{"name":"rollup_base_public_simulated","bytecode_size":67776} +{"name":"rollup_block_merge","bytecode_size":99872} +{"name":"rollup_block_root","bytecode_size":12803649} +{"name":"rollup_block_root_empty","bytecode_size":20129} +{"name":"rollup_block_root_simulated","bytecode_size":72709} +{"name":"rollup_block_root_single_tx","bytecode_size":12778106} +{"name":"rollup_block_root_single_tx_simulated","bytecode_size":67606} +{"name":"rollup_merge","bytecode_size":27780} +{"name":"rollup_root","bytecode_size":99621} +{"name":"amm_contract-AMM::_add_liquidity","bytecode_size":6831} +{"name":"amm_contract-AMM::_remove_liquidity","bytecode_size":4342} +{"name":"amm_contract-AMM::_swap_exact_tokens_for_tokens","bytecode_size":3499} +{"name":"amm_contract-AMM::_swap_tokens_for_exact_tokens","bytecode_size":3855} +{"name":"amm_contract-AMM::add_liquidity","bytecode_size":28782} +{"name":"amm_contract-AMM::constructor","bytecode_size":3180} +{"name":"amm_contract-AMM::get_amount_in_for_exact_out","bytecode_size":15641} +{"name":"amm_contract-AMM::get_amount_out_for_exact_in","bytecode_size":15625} +{"name":"amm_contract-AMM::process_log","bytecode_size":12646} +{"name":"amm_contract-AMM::public_dispatch","bytecode_size":17230} +{"name":"amm_contract-AMM::remove_liquidity","bytecode_size":26900} +{"name":"amm_contract-AMM::swap_exact_tokens_for_tokens","bytecode_size":26805} +{"name":"amm_contract-AMM::swap_tokens_for_exact_tokens","bytecode_size":27068} +{"name":"amm_contract-AMM::sync_notes","bytecode_size":214} +{"name":"app_subscription_contract-AppSubscription::constructor","bytecode_size":3803} +{"name":"app_subscription_contract-AppSubscription::entrypoint","bytecode_size":89119} +{"name":"app_subscription_contract-AppSubscription::is_initialized","bytecode_size":19950} +{"name":"app_subscription_contract-AppSubscription::process_log","bytecode_size":17982} +{"name":"app_subscription_contract-AppSubscription::public_dispatch","bytecode_size":4193} +{"name":"app_subscription_contract-AppSubscription::subscribe","bytecode_size":85415} +{"name":"app_subscription_contract-AppSubscription::sync_notes","bytecode_size":214} +{"name":"auth_contract-Auth::constructor","bytecode_size":2606} +{"name":"auth_contract-Auth::do_private_authorized_thing","bytecode_size":12711} +{"name":"auth_contract-Auth::get_authorized","bytecode_size":865} +{"name":"auth_contract-Auth::get_authorized_delay","bytecode_size":685} +{"name":"auth_contract-Auth::get_authorized_in_private","bytecode_size":13048} +{"name":"auth_contract-Auth::get_scheduled_authorized","bytecode_size":767} +{"name":"auth_contract-Auth::process_log","bytecode_size":1232} +{"name":"auth_contract-Auth::public_dispatch","bytecode_size":8086} +{"name":"auth_contract-Auth::set_authorized","bytecode_size":3069} +{"name":"auth_contract-Auth::set_authorized_delay","bytecode_size":3040} +{"name":"auth_contract-Auth::sync_notes","bytecode_size":214} +{"name":"auth_registry_contract-AuthRegistry::_set_authorized","bytecode_size":1629} +{"name":"auth_registry_contract-AuthRegistry::consume","bytecode_size":3308} +{"name":"auth_registry_contract-AuthRegistry::is_consumable","bytecode_size":1639} +{"name":"auth_registry_contract-AuthRegistry::is_reject_all","bytecode_size":1141} +{"name":"auth_registry_contract-AuthRegistry::process_log","bytecode_size":1232} +{"name":"auth_registry_contract-AuthRegistry::public_dispatch","bytecode_size":5978} +{"name":"auth_registry_contract-AuthRegistry::set_authorized","bytecode_size":1605} +{"name":"auth_registry_contract-AuthRegistry::set_authorized_private","bytecode_size":5918} +{"name":"auth_registry_contract-AuthRegistry::set_reject_all","bytecode_size":1113} +{"name":"auth_registry_contract-AuthRegistry::sync_notes","bytecode_size":214} +{"name":"auth_registry_contract-AuthRegistry::unconstrained_is_consumable","bytecode_size":1656} +{"name":"auth_wit_test_contract-AuthWitTest::consume","bytecode_size":5406} +{"name":"auth_wit_test_contract-AuthWitTest::consume_public","bytecode_size":765} +{"name":"auth_wit_test_contract-AuthWitTest::process_log","bytecode_size":1232} +{"name":"auth_wit_test_contract-AuthWitTest::public_dispatch","bytecode_size":1266} +{"name":"auth_wit_test_contract-AuthWitTest::sync_notes","bytecode_size":214} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_f1600","bytecode_size":756} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::keccak_hash","bytecode_size":2008} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash","bytecode_size":2474} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::pedersen_hash_with_index","bytecode_size":2484} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::poseidon2_hash","bytecode_size":1495} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::process_log","bytecode_size":1232} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::public_dispatch","bytecode_size":29848} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_10","bytecode_size":2340} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_100","bytecode_size":3592} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_20","bytecode_size":2388} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_2048","bytecode_size":20853} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_255","bytecode_size":5538} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_256","bytecode_size":5234} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_30","bytecode_size":2565} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_40","bytecode_size":2635} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_50","bytecode_size":2781} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_511","bytecode_size":8238} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_512","bytecode_size":7910} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_60","bytecode_size":2851} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_70","bytecode_size":3355} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_80","bytecode_size":3357} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sha256_hash_90","bytecode_size":3483} +{"name":"avm_gadgets_test_contract-AvmGadgetsTest::sync_notes","bytecode_size":214} +{"name":"avm_initializer_test_contract-AvmInitializerTest::constructor","bytecode_size":2233} +{"name":"avm_initializer_test_contract-AvmInitializerTest::process_log","bytecode_size":1232} +{"name":"avm_initializer_test_contract-AvmInitializerTest::public_dispatch","bytecode_size":2829} +{"name":"avm_initializer_test_contract-AvmInitializerTest::read_storage_immutable","bytecode_size":339} +{"name":"avm_initializer_test_contract-AvmInitializerTest::sync_notes","bytecode_size":214} +{"name":"avm_test_contract-AvmTest::add_args_return","bytecode_size":280} +{"name":"avm_test_contract-AvmTest::add_storage_map","bytecode_size":2053} +{"name":"avm_test_contract-AvmTest::add_u128","bytecode_size":412} +{"name":"avm_test_contract-AvmTest::assert_calldata_copy","bytecode_size":682} +{"name":"avm_test_contract-AvmTest::assert_nullifier_exists","bytecode_size":323} +{"name":"avm_test_contract-AvmTest::assert_same","bytecode_size":313} +{"name":"avm_test_contract-AvmTest::assertion_failure","bytecode_size":242} +{"name":"avm_test_contract-AvmTest::bulk_testing","bytecode_size":14924} +{"name":"avm_test_contract-AvmTest::create_different_nullifier_in_nested_call","bytecode_size":743} +{"name":"avm_test_contract-AvmTest::create_same_nullifier_in_nested_call","bytecode_size":724} +{"name":"avm_test_contract-AvmTest::debug_logging","bytecode_size":996} +{"name":"avm_test_contract-AvmTest::divide_by_zero","bytecode_size":225} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add","bytecode_size":685} +{"name":"avm_test_contract-AvmTest::elliptic_curve_add_and_double","bytecode_size":350} +{"name":"avm_test_contract-AvmTest::emit_nullifier_and_check","bytecode_size":319} +{"name":"avm_test_contract-AvmTest::emit_public_log","bytecode_size":1873} +{"name":"avm_test_contract-AvmTest::enqueue_public_from_private","bytecode_size":5022} +{"name":"avm_test_contract-AvmTest::external_call_to_assertion_failure","bytecode_size":660} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero","bytecode_size":673} +{"name":"avm_test_contract-AvmTest::external_call_to_divide_by_zero_recovers","bytecode_size":2003} +{"name":"avm_test_contract-AvmTest::get_address","bytecode_size":240} +{"name":"avm_test_contract-AvmTest::get_args_hash","bytecode_size":1633} +{"name":"avm_test_contract-AvmTest::get_block_number","bytecode_size":248} +{"name":"avm_test_contract-AvmTest::get_chain_id","bytecode_size":246} +{"name":"avm_test_contract-AvmTest::get_da_gas_left","bytecode_size":248} +{"name":"avm_test_contract-AvmTest::get_fee_per_da_gas","bytecode_size":248} +{"name":"avm_test_contract-AvmTest::get_fee_per_l2_gas","bytecode_size":250} +{"name":"avm_test_contract-AvmTest::get_l2_gas_left","bytecode_size":243} +{"name":"avm_test_contract-AvmTest::get_sender","bytecode_size":241} +{"name":"avm_test_contract-AvmTest::get_timestamp","bytecode_size":244} +{"name":"avm_test_contract-AvmTest::get_transaction_fee","bytecode_size":251} +{"name":"avm_test_contract-AvmTest::get_version","bytecode_size":241} +{"name":"avm_test_contract-AvmTest::helper_with_failed_assertion","bytecode_size":87} +{"name":"avm_test_contract-AvmTest::inner_helper_with_failed_assertion","bytecode_size":87} +{"name":"avm_test_contract-AvmTest::l1_to_l2_msg_exists","bytecode_size":316} +{"name":"avm_test_contract-AvmTest::modulo2","bytecode_size":270} +{"name":"avm_test_contract-AvmTest::n_new_l2_to_l1_msgs","bytecode_size":314} +{"name":"avm_test_contract-AvmTest::n_new_note_hashes","bytecode_size":320} +{"name":"avm_test_contract-AvmTest::n_new_nullifiers","bytecode_size":306} +{"name":"avm_test_contract-AvmTest::n_new_public_logs","bytecode_size":424} +{"name":"avm_test_contract-AvmTest::n_storage_writes","bytecode_size":1128} +{"name":"avm_test_contract-AvmTest::nested_call_to_add","bytecode_size":759} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_n_times_different_addresses","bytecode_size":1098} +{"name":"avm_test_contract-AvmTest::nested_call_to_add_with_gas","bytecode_size":748} +{"name":"avm_test_contract-AvmTest::nested_call_to_assert_same","bytecode_size":761} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing","bytecode_size":658} +{"name":"avm_test_contract-AvmTest::nested_call_to_nothing_recovers","bytecode_size":438} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_add","bytecode_size":763} +{"name":"avm_test_contract-AvmTest::nested_static_call_to_set_storage","bytecode_size":691} +{"name":"avm_test_contract-AvmTest::new_note_hash","bytecode_size":264} +{"name":"avm_test_contract-AvmTest::new_nullifier","bytecode_size":265} +{"name":"avm_test_contract-AvmTest::note_hash_exists","bytecode_size":318} +{"name":"avm_test_contract-AvmTest::nullifier_collision","bytecode_size":266} +{"name":"avm_test_contract-AvmTest::nullifier_exists","bytecode_size":313} +{"name":"avm_test_contract-AvmTest::pedersen_commit","bytecode_size":1177} +{"name":"avm_test_contract-AvmTest::process_log","bytecode_size":1232} +{"name":"avm_test_contract-AvmTest::public_dispatch","bytecode_size":31688} +{"name":"avm_test_contract-AvmTest::read_assert_storage_single","bytecode_size":296} +{"name":"avm_test_contract-AvmTest::read_storage_list","bytecode_size":431} +{"name":"avm_test_contract-AvmTest::read_storage_map","bytecode_size":1103} +{"name":"avm_test_contract-AvmTest::read_storage_single","bytecode_size":258} +{"name":"avm_test_contract-AvmTest::return_oracle","bytecode_size":540} +{"name":"avm_test_contract-AvmTest::returndata_copy_oracle","bytecode_size":1300} +{"name":"avm_test_contract-AvmTest::revert_oracle","bytecode_size":541} +{"name":"avm_test_contract-AvmTest::send_l2_to_l1_msg","bytecode_size":287} +{"name":"avm_test_contract-AvmTest::set_opcode_big_field","bytecode_size":235} +{"name":"avm_test_contract-AvmTest::set_opcode_really_big_field","bytecode_size":231} +{"name":"avm_test_contract-AvmTest::set_opcode_small_field","bytecode_size":234} +{"name":"avm_test_contract-AvmTest::set_opcode_u32","bytecode_size":216} +{"name":"avm_test_contract-AvmTest::set_opcode_u64","bytecode_size":215} +{"name":"avm_test_contract-AvmTest::set_opcode_u8","bytecode_size":220} +{"name":"avm_test_contract-AvmTest::set_read_storage_single","bytecode_size":306} +{"name":"avm_test_contract-AvmTest::set_storage_list","bytecode_size":309} +{"name":"avm_test_contract-AvmTest::set_storage_map","bytecode_size":1558} +{"name":"avm_test_contract-AvmTest::set_storage_single","bytecode_size":278} +{"name":"avm_test_contract-AvmTest::sync_notes","bytecode_size":214} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance","bytecode_size":536} +{"name":"avm_test_contract-AvmTest::test_get_contract_instance_matches","bytecode_size":574} +{"name":"avm_test_contract-AvmTest::to_radix_le","bytecode_size":554} +{"name":"avm_test_contract-AvmTest::u128_addition_overflow","bytecode_size":999} +{"name":"avm_test_contract-AvmTest::u128_from_integer_overflow","bytecode_size":625} +{"name":"avm_test_contract-AvmTest::variable_base_msm","bytecode_size":590} +{"name":"benchmarking_contract-Benchmarking::broadcast","bytecode_size":1181} +{"name":"benchmarking_contract-Benchmarking::create_note","bytecode_size":64442} +{"name":"benchmarking_contract-Benchmarking::increment_balance","bytecode_size":2007} +{"name":"benchmarking_contract-Benchmarking::process_log","bytecode_size":12719} +{"name":"benchmarking_contract-Benchmarking::public_dispatch","bytecode_size":5225} +{"name":"benchmarking_contract-Benchmarking::recreate_note","bytecode_size":80522} +{"name":"benchmarking_contract-Benchmarking::sha256_hash_2048","bytecode_size":20853} +{"name":"benchmarking_contract-Benchmarking::sync_notes","bytecode_size":214} +{"name":"card_game_contract-CardGame::buy_pack","bytecode_size":109819} +{"name":"card_game_contract-CardGame::claim_cards","bytecode_size":137580} +{"name":"card_game_contract-CardGame::join_game","bytecode_size":294119} +{"name":"card_game_contract-CardGame::on_card_played","bytecode_size":3122} +{"name":"card_game_contract-CardGame::on_cards_claimed","bytecode_size":3864} +{"name":"card_game_contract-CardGame::on_game_joined","bytecode_size":2353} +{"name":"card_game_contract-CardGame::play_card","bytecode_size":210097} +{"name":"card_game_contract-CardGame::process_log","bytecode_size":12719} +{"name":"card_game_contract-CardGame::public_dispatch","bytecode_size":9744} +{"name":"card_game_contract-CardGame::start_game","bytecode_size":3299} +{"name":"card_game_contract-CardGame::sync_notes","bytecode_size":214} +{"name":"card_game_contract-CardGame::view_collection_cards","bytecode_size":16166} +{"name":"card_game_contract-CardGame::view_game","bytecode_size":15144} +{"name":"card_game_contract-CardGame::view_game_cards","bytecode_size":16601} +{"name":"child_contract-Child::private_get_value","bytecode_size":40012} +{"name":"child_contract-Child::private_set_value","bytecode_size":64666} +{"name":"child_contract-Child::process_log","bytecode_size":12719} +{"name":"child_contract-Child::pub_get_value","bytecode_size":345} +{"name":"child_contract-Child::pub_inc_value","bytecode_size":448} +{"name":"child_contract-Child::pub_inc_value_internal","bytecode_size":510} +{"name":"child_contract-Child::pub_set_value","bytecode_size":425} +{"name":"child_contract-Child::public_dispatch","bytecode_size":2480} +{"name":"child_contract-Child::set_value_twice_with_nested_first","bytecode_size":811} +{"name":"child_contract-Child::set_value_twice_with_nested_last","bytecode_size":811} +{"name":"child_contract-Child::set_value_with_two_nested_calls","bytecode_size":1033} +{"name":"child_contract-Child::sync_notes","bytecode_size":214} +{"name":"child_contract-Child::value","bytecode_size":18902} +{"name":"child_contract-Child::value_internal","bytecode_size":18937} +{"name":"claim_contract-Claim::claim","bytecode_size":37161} +{"name":"claim_contract-Claim::constructor","bytecode_size":3255} +{"name":"claim_contract-Claim::process_log","bytecode_size":12646} +{"name":"claim_contract-Claim::public_dispatch","bytecode_size":3595} +{"name":"claim_contract-Claim::sync_notes","bytecode_size":214} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::assert_class_id_is_registered","bytecode_size":4119} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_private_function","bytecode_size":19446} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::broadcast_unconstrained_function","bytecode_size":19264} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::process_log","bytecode_size":1232} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::register","bytecode_size":202335} +{"name":"contract_class_registerer_contract-ContractClassRegisterer::sync_notes","bytecode_size":214} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::deploy","bytecode_size":7661} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::get_update_delay","bytecode_size":1395} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::process_log","bytecode_size":1232} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::public_dispatch","bytecode_size":7120} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::set_update_delay","bytecode_size":3510} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::sync_notes","bytecode_size":214} +{"name":"contract_instance_deployer_contract-ContractInstanceDeployer::update","bytecode_size":3684} +{"name":"counter_contract-Counter::decrement","bytecode_size":202694} +{"name":"counter_contract-Counter::get_counter","bytecode_size":15975} +{"name":"counter_contract-Counter::increment","bytecode_size":60801} +{"name":"counter_contract-Counter::increment_and_decrement","bytecode_size":216483} +{"name":"counter_contract-Counter::increment_twice","bytecode_size":74934} +{"name":"counter_contract-Counter::initialize","bytecode_size":65930} +{"name":"counter_contract-Counter::process_log","bytecode_size":12719} +{"name":"counter_contract-Counter::sync_notes","bytecode_size":214} +{"name":"crowdfunding_contract-Crowdfunding::_publish_donation_receipts","bytecode_size":563} +{"name":"crowdfunding_contract-Crowdfunding::donate","bytecode_size":67027} +{"name":"crowdfunding_contract-Crowdfunding::init","bytecode_size":3213} +{"name":"crowdfunding_contract-Crowdfunding::process_log","bytecode_size":12646} +{"name":"crowdfunding_contract-Crowdfunding::public_dispatch","bytecode_size":3976} +{"name":"crowdfunding_contract-Crowdfunding::sync_notes","bytecode_size":214} +{"name":"crowdfunding_contract-Crowdfunding::withdraw","bytecode_size":26149} +{"name":"docs_example_contract-DocsExample::get_imm_card","bytecode_size":20391} +{"name":"docs_example_contract-DocsExample::get_leader","bytecode_size":13808} +{"name":"docs_example_contract-DocsExample::get_legendary_card","bytecode_size":15102} +{"name":"docs_example_contract-DocsExample::get_public_immutable","bytecode_size":13892} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private","bytecode_size":25527} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_private_indirect","bytecode_size":19685} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public","bytecode_size":377} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_indirect","bytecode_size":810} +{"name":"docs_example_contract-DocsExample::get_public_immutable_constrained_public_multiple","bytecode_size":501} +{"name":"docs_example_contract-DocsExample::increase_legendary_points","bytecode_size":67029} +{"name":"docs_example_contract-DocsExample::initialize_private","bytecode_size":60777} +{"name":"docs_example_contract-DocsExample::initialize_private_immutable","bytecode_size":60739} +{"name":"docs_example_contract-DocsExample::initialize_public_immutable","bytecode_size":1220} +{"name":"docs_example_contract-DocsExample::insert_note","bytecode_size":60570} +{"name":"docs_example_contract-DocsExample::insert_notes","bytecode_size":85663} +{"name":"docs_example_contract-DocsExample::is_legendary_initialized","bytecode_size":14267} +{"name":"docs_example_contract-DocsExample::is_priv_imm_initialized","bytecode_size":14278} +{"name":"docs_example_contract-DocsExample::match_public_immutable","bytecode_size":25389} +{"name":"docs_example_contract-DocsExample::process_log","bytecode_size":12736} +{"name":"docs_example_contract-DocsExample::public_dispatch","bytecode_size":3009} +{"name":"docs_example_contract-DocsExample::read_note","bytecode_size":15572} +{"name":"docs_example_contract-DocsExample::simple_macro_example","bytecode_size":18911} +{"name":"docs_example_contract-DocsExample::simple_macro_example_expanded","bytecode_size":4756} +{"name":"docs_example_contract-DocsExample::spend_public_authwit","bytecode_size":255} +{"name":"docs_example_contract-DocsExample::sync_notes","bytecode_size":214} +{"name":"docs_example_contract-DocsExample::update_leader","bytecode_size":391} +{"name":"docs_example_contract-DocsExample::update_legendary_card","bytecode_size":63815} +{"name":"docs_example_contract-DocsExample::verify_private_authwit","bytecode_size":18922} +{"name":"docs_example_contract-DocsExample::view_imm_card","bytecode_size":15186} +{"name":"easy_private_token_contract-EasyPrivateToken::constructor","bytecode_size":65930} +{"name":"easy_private_token_contract-EasyPrivateToken::get_balance","bytecode_size":15975} +{"name":"easy_private_token_contract-EasyPrivateToken::mint","bytecode_size":64459} +{"name":"easy_private_token_contract-EasyPrivateToken::process_log","bytecode_size":12719} +{"name":"easy_private_token_contract-EasyPrivateToken::sync_notes","bytecode_size":214} +{"name":"easy_private_token_contract-EasyPrivateToken::transfer","bytecode_size":240279} +{"name":"easy_private_voting_contract-EasyPrivateVoting::add_to_tally_public","bytecode_size":1760} +{"name":"easy_private_voting_contract-EasyPrivateVoting::cast_vote","bytecode_size":7706} +{"name":"easy_private_voting_contract-EasyPrivateVoting::constructor","bytecode_size":2647} +{"name":"easy_private_voting_contract-EasyPrivateVoting::end_vote","bytecode_size":389} +{"name":"easy_private_voting_contract-EasyPrivateVoting::get_vote","bytecode_size":1213} +{"name":"easy_private_voting_contract-EasyPrivateVoting::process_log","bytecode_size":1232} +{"name":"easy_private_voting_contract-EasyPrivateVoting::public_dispatch","bytecode_size":4178} +{"name":"easy_private_voting_contract-EasyPrivateVoting::sync_notes","bytecode_size":214} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::constructor","bytecode_size":69911} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::entrypoint","bytecode_size":58985} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::process_log","bytecode_size":14178} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::sync_notes","bytecode_size":214} +{"name":"ecdsa_k_account_contract-EcdsaKAccount::verify_private_authwit","bytecode_size":36913} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::constructor","bytecode_size":69911} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::entrypoint","bytecode_size":59063} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::process_log","bytecode_size":14178} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::sync_notes","bytecode_size":214} +{"name":"ecdsa_r_account_contract-EcdsaRAccount::verify_private_authwit","bytecode_size":36799} +{"name":"escrow_contract-Escrow::constructor","bytecode_size":63487} +{"name":"escrow_contract-Escrow::process_log","bytecode_size":17773} +{"name":"escrow_contract-Escrow::sync_notes","bytecode_size":214} +{"name":"escrow_contract-Escrow::withdraw","bytecode_size":25928} +{"name":"fee_juice_contract-FeeJuice::_increase_public_balance","bytecode_size":1826} +{"name":"fee_juice_contract-FeeJuice::balance_of_public","bytecode_size":1224} +{"name":"fee_juice_contract-FeeJuice::check_balance","bytecode_size":1417} +{"name":"fee_juice_contract-FeeJuice::claim","bytecode_size":66784} +{"name":"fee_juice_contract-FeeJuice::initialize","bytecode_size":5914} +{"name":"fee_juice_contract-FeeJuice::process_log","bytecode_size":1232} +{"name":"fee_juice_contract-FeeJuice::public_dispatch","bytecode_size":3917} +{"name":"fee_juice_contract-FeeJuice::set_portal","bytecode_size":1150} +{"name":"fee_juice_contract-FeeJuice::sync_notes","bytecode_size":214} +{"name":"fpc_contract-FPC::complete_refund","bytecode_size":1248} +{"name":"fpc_contract-FPC::constructor","bytecode_size":3070} +{"name":"fpc_contract-FPC::fee_entrypoint_private","bytecode_size":26921} +{"name":"fpc_contract-FPC::fee_entrypoint_public","bytecode_size":26469} +{"name":"fpc_contract-FPC::get_accepted_asset","bytecode_size":25423} +{"name":"fpc_contract-FPC::pay_refund","bytecode_size":1263} +{"name":"fpc_contract-FPC::process_log","bytecode_size":12646} +{"name":"fpc_contract-FPC::public_dispatch","bytecode_size":5729} +{"name":"fpc_contract-FPC::pull_funds","bytecode_size":1220} +{"name":"fpc_contract-FPC::sync_notes","bytecode_size":214} +{"name":"import_test_contract-ImportTest::call_no_args","bytecode_size":25289} +{"name":"import_test_contract-ImportTest::call_public_fn","bytecode_size":24953} +{"name":"import_test_contract-ImportTest::main_contract","bytecode_size":25430} +{"name":"import_test_contract-ImportTest::process_log","bytecode_size":18652} +{"name":"import_test_contract-ImportTest::pub_call_public_fn","bytecode_size":689} +{"name":"import_test_contract-ImportTest::public_dispatch","bytecode_size":1177} +{"name":"import_test_contract-ImportTest::sync_notes","bytecode_size":214} +{"name":"inclusion_proofs_contract-InclusionProofs::constructor","bytecode_size":2226} +{"name":"inclusion_proofs_contract-InclusionProofs::create_note","bytecode_size":64477} +{"name":"inclusion_proofs_contract-InclusionProofs::nullify_note","bytecode_size":35932} +{"name":"inclusion_proofs_contract-InclusionProofs::process_log","bytecode_size":12719} +{"name":"inclusion_proofs_contract-InclusionProofs::public_dispatch","bytecode_size":2842} +{"name":"inclusion_proofs_contract-InclusionProofs::push_nullifier_public","bytecode_size":340} +{"name":"inclusion_proofs_contract-InclusionProofs::sync_notes","bytecode_size":214} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_inclusion","bytecode_size":31376} +{"name":"inclusion_proofs_contract-InclusionProofs::test_contract_non_inclusion","bytecode_size":34877} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion","bytecode_size":42012} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_inclusion_fail_case","bytecode_size":27936} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_not_nullified","bytecode_size":46088} +{"name":"inclusion_proofs_contract-InclusionProofs::test_note_validity","bytecode_size":49261} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion","bytecode_size":28147} +{"name":"inclusion_proofs_contract-InclusionProofs::test_nullifier_inclusion_from_public","bytecode_size":335} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read","bytecode_size":30282} +{"name":"inclusion_proofs_contract-InclusionProofs::test_storage_historical_read_unset_slot","bytecode_size":30401} +{"name":"lending_contract-Lending::_borrow","bytecode_size":6911} +{"name":"lending_contract-Lending::_deposit","bytecode_size":2003} +{"name":"lending_contract-Lending::_repay","bytecode_size":4904} +{"name":"lending_contract-Lending::_withdraw","bytecode_size":6338} +{"name":"lending_contract-Lending::borrow_private","bytecode_size":19737} +{"name":"lending_contract-Lending::borrow_public","bytecode_size":822} +{"name":"lending_contract-Lending::constructor","bytecode_size":20537} +{"name":"lending_contract-Lending::deposit_private","bytecode_size":20284} +{"name":"lending_contract-Lending::deposit_public","bytecode_size":1087} +{"name":"lending_contract-Lending::get_asset","bytecode_size":1580} +{"name":"lending_contract-Lending::get_assets","bytecode_size":569} +{"name":"lending_contract-Lending::get_position","bytecode_size":3942} +{"name":"lending_contract-Lending::init","bytecode_size":1891} +{"name":"lending_contract-Lending::process_log","bytecode_size":12646} +{"name":"lending_contract-Lending::public_dispatch","bytecode_size":24879} +{"name":"lending_contract-Lending::repay_private","bytecode_size":20168} +{"name":"lending_contract-Lending::repay_public","bytecode_size":1134} +{"name":"lending_contract-Lending::sync_notes","bytecode_size":214} +{"name":"lending_contract-Lending::update_accumulator","bytecode_size":5805} +{"name":"lending_contract-Lending::withdraw_private","bytecode_size":19653} +{"name":"lending_contract-Lending::withdraw_public","bytecode_size":823} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::entrypoint","bytecode_size":17304} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::process_log","bytecode_size":1232} +{"name":"multi_call_entrypoint_contract-MultiCallEntrypoint::sync_notes","bytecode_size":214} +{"name":"nft_contract-NFT::_finalize_transfer_to_private_unsafe","bytecode_size":3220} +{"name":"nft_contract-NFT::_finish_transfer_to_public","bytecode_size":1248} +{"name":"nft_contract-NFT::_store_payload_in_transient_storage_unsafe","bytecode_size":1239} +{"name":"nft_contract-NFT::cancel_authwit","bytecode_size":18532} +{"name":"nft_contract-NFT::constructor","bytecode_size":5046} +{"name":"nft_contract-NFT::finalize_transfer_to_private","bytecode_size":3184} +{"name":"nft_contract-NFT::get_admin","bytecode_size":400} +{"name":"nft_contract-NFT::get_private_nfts","bytecode_size":16803} +{"name":"nft_contract-NFT::is_minter","bytecode_size":1250} +{"name":"nft_contract-NFT::mint","bytecode_size":2286} +{"name":"nft_contract-NFT::owner_of","bytecode_size":1704} +{"name":"nft_contract-NFT::prepare_private_balance_increase","bytecode_size":60927} +{"name":"nft_contract-NFT::private_get_name","bytecode_size":25377} +{"name":"nft_contract-NFT::private_get_symbol","bytecode_size":25440} +{"name":"nft_contract-NFT::process_log","bytecode_size":12592} +{"name":"nft_contract-NFT::public_dispatch","bytecode_size":16192} +{"name":"nft_contract-NFT::public_get_name","bytecode_size":388} +{"name":"nft_contract-NFT::public_get_symbol","bytecode_size":388} +{"name":"nft_contract-NFT::set_admin","bytecode_size":423} +{"name":"nft_contract-NFT::set_minter","bytecode_size":1275} +{"name":"nft_contract-NFT::sync_notes","bytecode_size":214} +{"name":"nft_contract-NFT::transfer_in_private","bytecode_size":89597} +{"name":"nft_contract-NFT::transfer_in_public","bytecode_size":3300} +{"name":"nft_contract-NFT::transfer_to_private","bytecode_size":61062} +{"name":"nft_contract-NFT::transfer_to_public","bytecode_size":45141} +{"name":"parent_contract-Parent::enqueue_call_to_child","bytecode_size":19248} +{"name":"parent_contract-Parent::enqueue_call_to_child_twice","bytecode_size":19369} +{"name":"parent_contract-Parent::enqueue_call_to_pub_entry_point","bytecode_size":19166} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_first","bytecode_size":19585} +{"name":"parent_contract-Parent::enqueue_calls_to_child_with_nested_last","bytecode_size":19537} +{"name":"parent_contract-Parent::enqueue_calls_to_pub_entry_point","bytecode_size":19269} +{"name":"parent_contract-Parent::enqueue_static_call_to_pub_function","bytecode_size":19211} +{"name":"parent_contract-Parent::enqueue_static_nested_call_to_pub_function","bytecode_size":19204} +{"name":"parent_contract-Parent::entry_point","bytecode_size":19480} +{"name":"parent_contract-Parent::private_call","bytecode_size":19540} +{"name":"parent_contract-Parent::private_nested_static_call","bytecode_size":19539} +{"name":"parent_contract-Parent::private_static_call","bytecode_size":19558} +{"name":"parent_contract-Parent::process_log","bytecode_size":12719} +{"name":"parent_contract-Parent::pub_entry_point","bytecode_size":788} +{"name":"parent_contract-Parent::pub_entry_point_twice","bytecode_size":1011} +{"name":"parent_contract-Parent::public_dispatch","bytecode_size":3546} +{"name":"parent_contract-Parent::public_nested_static_call","bytecode_size":2476} +{"name":"parent_contract-Parent::public_static_call","bytecode_size":1208} +{"name":"parent_contract-Parent::sync_notes","bytecode_size":214} +{"name":"pending_note_hashes_contract-PendingNoteHashes::dummy","bytecode_size":18561} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_note_zero_balance","bytecode_size":49602} +{"name":"pending_note_hashes_contract-PendingNoteHashes::get_then_nullify_note","bytecode_size":36188} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note","bytecode_size":64408} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_extra_emit","bytecode_size":74657} +{"name":"pending_note_hashes_contract-PendingNoteHashes::insert_note_static_randomness","bytecode_size":60746} +{"name":"pending_note_hashes_contract-PendingNoteHashes::process_log","bytecode_size":12719} +{"name":"pending_note_hashes_contract-PendingNoteHashes::recursively_destroy_and_create_notes","bytecode_size":389816} +{"name":"pending_note_hashes_contract-PendingNoteHashes::sync_notes","bytecode_size":214} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_bad_get_then_insert_flat","bytecode_size":74795} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_emit_bad_note_log","bytecode_size":74497} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert1_then_get2_then_nullify2_all_in_nested_calls","bytecode_size":19505} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify1_all_in_nested_calls","bytecode_size":19480} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert2_then_get2_then_nullify2_all_in_nested_calls","bytecode_size":19728} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_all_in_nested_calls","bytecode_size":19553} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_insert_then_get_then_nullify_flat","bytecode_size":201481} +{"name":"pending_note_hashes_contract-PendingNoteHashes::test_recursively_create_notes","bytecode_size":277805} +{"name":"price_feed_contract-PriceFeed::get_price","bytecode_size":1224} +{"name":"price_feed_contract-PriceFeed::process_log","bytecode_size":1232} +{"name":"price_feed_contract-PriceFeed::public_dispatch","bytecode_size":2288} +{"name":"price_feed_contract-PriceFeed::set_price","bytecode_size":1122} +{"name":"price_feed_contract-PriceFeed::sync_notes","bytecode_size":214} +{"name":"router_contract-Router::_check_block_number","bytecode_size":1043} +{"name":"router_contract-Router::_check_timestamp","bytecode_size":1069} +{"name":"router_contract-Router::check_block_number","bytecode_size":4912} +{"name":"router_contract-Router::check_timestamp","bytecode_size":4975} +{"name":"router_contract-Router::process_log","bytecode_size":1232} +{"name":"router_contract-Router::public_dispatch","bytecode_size":1895} +{"name":"router_contract-Router::sync_notes","bytecode_size":214} +{"name":"schnorr_account_contract-SchnorrAccount::constructor","bytecode_size":58436} +{"name":"schnorr_account_contract-SchnorrAccount::entrypoint","bytecode_size":59230} +{"name":"schnorr_account_contract-SchnorrAccount::lookup_validity","bytecode_size":19846} +{"name":"schnorr_account_contract-SchnorrAccount::process_log","bytecode_size":12741} +{"name":"schnorr_account_contract-SchnorrAccount::sync_notes","bytecode_size":214} +{"name":"schnorr_account_contract-SchnorrAccount::verify_private_authwit","bytecode_size":37275} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::entrypoint","bytecode_size":43869} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::process_log","bytecode_size":1232} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::sync_notes","bytecode_size":214} +{"name":"schnorr_hardcoded_account_contract-SchnorrHardcodedAccount::verify_private_authwit","bytecode_size":21162} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::entrypoint","bytecode_size":40261} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::process_log","bytecode_size":1232} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::sync_notes","bytecode_size":214} +{"name":"schnorr_single_key_account_contract-SchnorrSingleKeyAccount::verify_private_authwit","bytecode_size":17960} +{"name":"spam_contract-Spam::process_log","bytecode_size":18058} +{"name":"spam_contract-Spam::public_dispatch","bytecode_size":2238} +{"name":"spam_contract-Spam::public_spam","bytecode_size":1756} +{"name":"spam_contract-Spam::spam","bytecode_size":80116} +{"name":"spam_contract-Spam::sync_notes","bytecode_size":214} +{"name":"stateful_test_contract-StatefulTest::constructor","bytecode_size":21468} +{"name":"stateful_test_contract-StatefulTest::create_note","bytecode_size":66229} +{"name":"stateful_test_contract-StatefulTest::create_note_no_init_check","bytecode_size":66294} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create","bytecode_size":408106} +{"name":"stateful_test_contract-StatefulTest::destroy_and_create_no_init_check","bytecode_size":408312} +{"name":"stateful_test_contract-StatefulTest::get_public_value","bytecode_size":1155} +{"name":"stateful_test_contract-StatefulTest::increment_public_value","bytecode_size":1214} +{"name":"stateful_test_contract-StatefulTest::increment_public_value_no_init_check","bytecode_size":1123} +{"name":"stateful_test_contract-StatefulTest::process_log","bytecode_size":12719} +{"name":"stateful_test_contract-StatefulTest::public_constructor","bytecode_size":2939} +{"name":"stateful_test_contract-StatefulTest::public_dispatch","bytecode_size":5030} +{"name":"stateful_test_contract-StatefulTest::summed_values","bytecode_size":15975} +{"name":"stateful_test_contract-StatefulTest::sync_notes","bytecode_size":214} +{"name":"stateful_test_contract-StatefulTest::wrong_constructor","bytecode_size":21239} +{"name":"static_child_contract-StaticChild::private_get_value","bytecode_size":46225} +{"name":"static_child_contract-StaticChild::private_illegal_set_value","bytecode_size":60801} +{"name":"static_child_contract-StaticChild::private_set_value","bytecode_size":60856} +{"name":"static_child_contract-StaticChild::process_log","bytecode_size":12719} +{"name":"static_child_contract-StaticChild::pub_get_value","bytecode_size":411} +{"name":"static_child_contract-StaticChild::pub_illegal_inc_value","bytecode_size":506} +{"name":"static_child_contract-StaticChild::pub_inc_value","bytecode_size":448} +{"name":"static_child_contract-StaticChild::pub_set_value","bytecode_size":425} +{"name":"static_child_contract-StaticChild::public_dispatch","bytecode_size":1323} +{"name":"static_child_contract-StaticChild::sync_notes","bytecode_size":214} +{"name":"static_parent_contract-StaticParent::enqueue_call","bytecode_size":19213} +{"name":"static_parent_contract-StaticParent::enqueue_public_get_value_from_child","bytecode_size":19129} +{"name":"static_parent_contract-StaticParent::enqueue_static_call_to_pub_function","bytecode_size":19211} +{"name":"static_parent_contract-StaticParent::enqueue_static_nested_call_to_pub_function","bytecode_size":19194} +{"name":"static_parent_contract-StaticParent::private_call","bytecode_size":19540} +{"name":"static_parent_contract-StaticParent::private_call_3_args","bytecode_size":19699} +{"name":"static_parent_contract-StaticParent::private_get_value_from_child","bytecode_size":19575} +{"name":"static_parent_contract-StaticParent::private_nested_static_call","bytecode_size":19513} +{"name":"static_parent_contract-StaticParent::private_nested_static_call_3_args","bytecode_size":19594} +{"name":"static_parent_contract-StaticParent::private_static_call","bytecode_size":19558} +{"name":"static_parent_contract-StaticParent::private_static_call_3_args","bytecode_size":19656} +{"name":"static_parent_contract-StaticParent::process_log","bytecode_size":12719} +{"name":"static_parent_contract-StaticParent::public_call","bytecode_size":788} +{"name":"static_parent_contract-StaticParent::public_dispatch","bytecode_size":1900} +{"name":"static_parent_contract-StaticParent::public_get_value_from_child","bytecode_size":747} +{"name":"static_parent_contract-StaticParent::public_nested_static_call","bytecode_size":941} +{"name":"static_parent_contract-StaticParent::public_static_call","bytecode_size":1208} +{"name":"static_parent_contract-StaticParent::sync_notes","bytecode_size":214} +{"name":"test_contract-Test::assert_header_private","bytecode_size":25017} +{"name":"test_contract-Test::assert_private_global_vars","bytecode_size":24428} +{"name":"test_contract-Test::assert_public_global_vars","bytecode_size":566} +{"name":"test_contract-Test::call_create_note","bytecode_size":70480} +{"name":"test_contract-Test::call_destroy_note","bytecode_size":62597} +{"name":"test_contract-Test::call_get_notes","bytecode_size":55740} +{"name":"test_contract-Test::call_get_notes_many","bytecode_size":55662} +{"name":"test_contract-Test::call_view_notes","bytecode_size":21163} +{"name":"test_contract-Test::call_view_notes_many","bytecode_size":21273} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_private","bytecode_size":68935} +{"name":"test_contract-Test::consume_message_from_arbitrary_sender_public","bytecode_size":4594} +{"name":"test_contract-Test::consume_mint_to_private_message","bytecode_size":74977} +{"name":"test_contract-Test::consume_mint_to_public_message","bytecode_size":6634} +{"name":"test_contract-Test::consume_note_from_secret","bytecode_size":44218} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_private","bytecode_size":24520} +{"name":"test_contract-Test::create_l2_to_l1_message_arbitrary_recipient_public","bytecode_size":287} +{"name":"test_contract-Test::create_l2_to_l1_message_public","bytecode_size":1597} +{"name":"test_contract-Test::deliver_note","bytecode_size":35213} +{"name":"test_contract-Test::deploy_contract","bytecode_size":27416} +{"name":"test_contract-Test::dummy_public_call","bytecode_size":277} +{"name":"test_contract-Test::emit_array_as_encrypted_log","bytecode_size":44331} +{"name":"test_contract-Test::emit_encrypted_logs_nested","bytecode_size":67298} +{"name":"test_contract-Test::emit_nullifier","bytecode_size":24616} +{"name":"test_contract-Test::emit_nullifier_public","bytecode_size":265} +{"name":"test_contract-Test::emit_public","bytecode_size":1097} +{"name":"test_contract-Test::get_constant","bytecode_size":20815} +{"name":"test_contract-Test::get_master_incoming_viewing_public_key","bytecode_size":26767} +{"name":"test_contract-Test::get_ovsk_app","bytecode_size":25455} +{"name":"test_contract-Test::get_this_address","bytecode_size":24849} +{"name":"test_contract-Test::is_time_equal","bytecode_size":308} +{"name":"test_contract-Test::process_log","bytecode_size":18662} +{"name":"test_contract-Test::public_dispatch","bytecode_size":12722} +{"name":"test_contract-Test::set_constant","bytecode_size":25838} +{"name":"test_contract-Test::set_tx_max_block_number","bytecode_size":25141} +{"name":"test_contract-Test::sync_notes","bytecode_size":214} +{"name":"test_contract-Test::test_code_gen","bytecode_size":25216} +{"name":"test_contract-Test::test_nullifier_key_freshness","bytecode_size":26674} +{"name":"test_contract-Test::test_setting_fee_payer","bytecode_size":24972} +{"name":"test_contract-Test::test_setting_teardown","bytecode_size":25007} +{"name":"test_log_contract-TestLog::emit_encrypted_events","bytecode_size":92770} +{"name":"test_log_contract-TestLog::emit_unencrypted_events","bytecode_size":692} +{"name":"test_log_contract-TestLog::process_log","bytecode_size":12719} +{"name":"test_log_contract-TestLog::public_dispatch","bytecode_size":1465} +{"name":"test_log_contract-TestLog::sync_notes","bytecode_size":214} +{"name":"token_blacklist_contract-TokenBlacklist::_increase_public_balance","bytecode_size":1910} +{"name":"token_blacklist_contract-TokenBlacklist::_reduce_total_supply","bytecode_size":604} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_private","bytecode_size":20185} +{"name":"token_blacklist_contract-TokenBlacklist::balance_of_public","bytecode_size":1336} +{"name":"token_blacklist_contract-TokenBlacklist::burn","bytecode_size":217041} +{"name":"token_blacklist_contract-TokenBlacklist::burn_public","bytecode_size":4849} +{"name":"token_blacklist_contract-TokenBlacklist::constructor","bytecode_size":4857} +{"name":"token_blacklist_contract-TokenBlacklist::deliver_transparent_note","bytecode_size":30492} +{"name":"token_blacklist_contract-TokenBlacklist::get_roles","bytecode_size":1609} +{"name":"token_blacklist_contract-TokenBlacklist::mint_private","bytecode_size":2531} +{"name":"token_blacklist_contract-TokenBlacklist::mint_public","bytecode_size":3293} +{"name":"token_blacklist_contract-TokenBlacklist::process_log","bytecode_size":15328} +{"name":"token_blacklist_contract-TokenBlacklist::public_dispatch","bytecode_size":36679} +{"name":"token_blacklist_contract-TokenBlacklist::redeem_shield","bytecode_size":102713} +{"name":"token_blacklist_contract-TokenBlacklist::shield","bytecode_size":5532} +{"name":"token_blacklist_contract-TokenBlacklist::sync_notes","bytecode_size":214} +{"name":"token_blacklist_contract-TokenBlacklist::total_supply","bytecode_size":475} +{"name":"token_blacklist_contract-TokenBlacklist::transfer","bytecode_size":206522} +{"name":"token_blacklist_contract-TokenBlacklist::transfer_public","bytecode_size":6120} +{"name":"token_blacklist_contract-TokenBlacklist::unshield","bytecode_size":223341} +{"name":"token_blacklist_contract-TokenBlacklist::update_roles","bytecode_size":4392} +{"name":"token_bridge_contract-TokenBridge::claim_private","bytecode_size":75695} +{"name":"token_bridge_contract-TokenBridge::claim_public","bytecode_size":7210} +{"name":"token_bridge_contract-TokenBridge::constructor","bytecode_size":3070} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_private","bytecode_size":44831} +{"name":"token_bridge_contract-TokenBridge::exit_to_l1_public","bytecode_size":3551} +{"name":"token_bridge_contract-TokenBridge::get_config","bytecode_size":25554} +{"name":"token_bridge_contract-TokenBridge::get_config_public","bytecode_size":457} +{"name":"token_bridge_contract-TokenBridge::process_log","bytecode_size":12646} +{"name":"token_bridge_contract-TokenBridge::public_dispatch","bytecode_size":12379} +{"name":"token_bridge_contract-TokenBridge::sync_notes","bytecode_size":214} +{"name":"token_contract-Token::_finalize_mint_to_private_unsafe","bytecode_size":3290} +{"name":"token_contract-Token::_finalize_transfer_to_private_unsafe","bytecode_size":3660} +{"name":"token_contract-Token::_increase_public_balance","bytecode_size":1852} +{"name":"token_contract-Token::_recurse_subtract_balance","bytecode_size":90525} +{"name":"token_contract-Token::_reduce_total_supply","bytecode_size":598} +{"name":"token_contract-Token::_store_payload_in_transient_storage_unsafe","bytecode_size":1239} +{"name":"token_contract-Token::balance_of_private","bytecode_size":16238} +{"name":"token_contract-Token::balance_of_public","bytecode_size":1309} +{"name":"token_contract-Token::burn_private","bytecode_size":193985} +{"name":"token_contract-Token::burn_public","bytecode_size":3810} +{"name":"token_contract-Token::cancel_authwit","bytecode_size":18608} +{"name":"token_contract-Token::constructor","bytecode_size":5329} +{"name":"token_contract-Token::finalize_mint_to_private","bytecode_size":3283} +{"name":"token_contract-Token::finalize_transfer_to_private","bytecode_size":3634} +{"name":"token_contract-Token::get_admin","bytecode_size":385} +{"name":"token_contract-Token::is_minter","bytecode_size":1250} +{"name":"token_contract-Token::mint_to_private","bytecode_size":61019} +{"name":"token_contract-Token::mint_to_public","bytecode_size":2338} +{"name":"token_contract-Token::prepare_private_balance_increase","bytecode_size":60897} +{"name":"token_contract-Token::private_get_decimals","bytecode_size":25380} +{"name":"token_contract-Token::private_get_name","bytecode_size":25425} +{"name":"token_contract-Token::private_get_symbol","bytecode_size":25493} +{"name":"token_contract-Token::process_log","bytecode_size":12646} +{"name":"token_contract-Token::public_dispatch","bytecode_size":23909} +{"name":"token_contract-Token::public_get_decimals","bytecode_size":415} +{"name":"token_contract-Token::public_get_name","bytecode_size":395} +{"name":"token_contract-Token::public_get_symbol","bytecode_size":400} +{"name":"token_contract-Token::set_admin","bytecode_size":413} +{"name":"token_contract-Token::set_minter","bytecode_size":1266} +{"name":"token_contract-Token::sync_notes","bytecode_size":214} +{"name":"token_contract-Token::total_supply","bytecode_size":494} +{"name":"token_contract-Token::transfer","bytecode_size":99747} +{"name":"token_contract-Token::transfer_in_private","bytecode_size":248026} +{"name":"token_contract-Token::transfer_in_public","bytecode_size":4659} +{"name":"token_contract-Token::transfer_to_private","bytecode_size":61241} +{"name":"token_contract-Token::transfer_to_public","bytecode_size":194255} +{"name":"uniswap_contract-Uniswap::_approve_bridge_and_exit_input_asset_to_L1","bytecode_size":4983} +{"name":"uniswap_contract-Uniswap::constructor","bytecode_size":2602} +{"name":"uniswap_contract-Uniswap::process_log","bytecode_size":12646} +{"name":"uniswap_contract-Uniswap::public_dispatch","bytecode_size":13550} +{"name":"uniswap_contract-Uniswap::swap_private","bytecode_size":66303} +{"name":"uniswap_contract-Uniswap::swap_public","bytecode_size":6981} +{"name":"uniswap_contract-Uniswap::sync_notes","bytecode_size":214} +{"name":"updatable_contract-Updatable::get_private_value","bytecode_size":15069} +{"name":"updatable_contract-Updatable::get_public_value","bytecode_size":13802} +{"name":"updatable_contract-Updatable::get_update_delay","bytecode_size":817} +{"name":"updatable_contract-Updatable::initialize","bytecode_size":62562} +{"name":"updatable_contract-Updatable::process_log","bytecode_size":12719} +{"name":"updatable_contract-Updatable::public_dispatch","bytecode_size":1341} +{"name":"updatable_contract-Updatable::set_public_value","bytecode_size":353} +{"name":"updatable_contract-Updatable::set_update_delay","bytecode_size":18958} +{"name":"updatable_contract-Updatable::sync_notes","bytecode_size":214} +{"name":"updatable_contract-Updatable::update_to","bytecode_size":19217} +{"name":"updated_contract-Updated::get_private_value","bytecode_size":15069} +{"name":"updated_contract-Updated::get_public_value","bytecode_size":13802} +{"name":"updated_contract-Updated::get_update_delay","bytecode_size":715} +{"name":"updated_contract-Updated::process_log","bytecode_size":12719} +{"name":"updated_contract-Updated::public_dispatch","bytecode_size":1233} +{"name":"updated_contract-Updated::set_private_value","bytecode_size":59871} +{"name":"updated_contract-Updated::set_public_value","bytecode_size":258} +{"name":"updated_contract-Updated::sync_notes","bytecode_size":214} diff --git a/utils/protobuf/Cargo.toml b/utils/protobuf/Cargo.toml new file mode 100644 index 00000000000..fdd8fb0ba2e --- /dev/null +++ b/utils/protobuf/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "noir_protobuf" +version.workspace = true +authors.workspace = true +edition.workspace = true +rust-version.workspace = true +license.workspace = true + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +color-eyre.workspace = true +prost.workspace = true diff --git a/utils/protobuf/src/lib.rs b/utils/protobuf/src/lib.rs new file mode 100644 index 00000000000..f8221917f31 --- /dev/null +++ b/utils/protobuf/src/lib.rs @@ -0,0 +1,128 @@ +use color_eyre::eyre::{self, eyre, Context}; + +/// A protobuf codec to convert between a domain type `T` +/// and its protobuf representation `R`. +/// +/// It is to be implemented on a `Self` independent of `T` and `R`, +/// so that `T` can be in a third party crate, and `Self` can be +/// generic in the `F` _field_ type as well, which would be cumbersome +/// if we had to implement traits on `R` because `T` is in another +/// crate from the schema, or to scatter the `.proto` schema around +/// so that the traits can be co-defined with `T` which is what can +/// actually be generic in `F`. +pub trait ProtoCodec { + /// Convert domain type `T` to protobuf representation `R`. + fn encode(value: &T) -> R; + /// Encode a field as `Some`. + fn encode_some(value: &T) -> Option { + Some(Self::encode(value)) + } + /// Encode an `enum` to the `i32` value that `prost` represents it with. + fn encode_enum(value: &T) -> i32 + where + R: Into, + { + Self::encode(value).into() + } + /// Encode multiple values as a vector. + fn encode_vec<'a, I>(values: I) -> Vec + where + I: IntoIterator, + T: 'a, + { + values.into_iter().map(Self::encode).collect() + } + + /// Try to convert protobuf representation `R` to domain type `T`. + fn decode(value: &R) -> eyre::Result; + /// Decode a field and attach the name of the field if it fails. + fn decode_msg(value: &R, msg: &'static str) -> eyre::Result { + Self::decode(value).wrap_err(msg) + } + /// Decode multiple values into a vector. + fn decode_vec(values: &[R]) -> eyre::Result> { + values.iter().map(Self::decode).collect() + } + /// Decode multiple values into a vector, attaching a field name to any errors. + fn decode_vec_msg(values: &[R], msg: &'static str) -> eyre::Result> { + Self::decode_vec(values).wrap_err(msg) + } + /// Decode an optional field as a required one; fails if it's `None`. + fn decode_some(value: &Option) -> eyre::Result { + match value { + Some(value) => Self::decode(value), + None => Err(eyre!("missing field")), + } + } + /// Decode an optional field as a required one, attaching a field name to any errors. + fn decode_some_msg(value: &Option, msg: &'static str) -> eyre::Result { + Self::decode_some(value).wrap_err(msg) + } + /// Decode the numeric representation of an enum into the domain type. + /// Return an error if the value cannot be recognized. + fn decode_enum(value: i32) -> eyre::Result + where + R: TryFrom, + { + let r = R::try_from(value)?; + Self::decode(&r) + } + /// Decode the numeric representation of an enum, attaching the field name to any errors. + fn decode_enum_msg(value: i32, msg: &'static str) -> eyre::Result + where + R: TryFrom, + { + Self::decode_enum(value).wrap_err(msg) + } + + /// Encode a domain type to protobuf and serialize it to bytes. + fn serialize_to_vec(value: &T) -> Vec + where + R: prost::Message, + { + Self::encode(value).encode_to_vec() + } + /// Deserialize a buffer into protobuf and then decode into the domain type. + fn deserialize_from_vec(buf: &[u8]) -> eyre::Result + where + R: prost::Message + Default, + { + let repr = R::decode(buf).wrap_err("failed to decode into protobuf")?; + Self::decode(&repr).wrap_err("failed to decode protobuf into domain") + } +} + +/// Decode repeated items by mapping a function over them, attaching an error message if it fails. +pub fn decode_vec_msg_map(rs: &[R], msg: &'static str, f: F) -> eyre::Result> +where + F: Fn(&R) -> eyre::Result, +{ + rs.iter().map(f).collect::>>().wrap_err(msg) +} + +/// Decode an optional item, returning an error if it's `None`. +pub fn decode_some_map(r: &Option, f: F) -> eyre::Result +where + F: Fn(&R) -> eyre::Result, +{ + match r { + Some(r) => f(r), + None => Err(eyre!("missing field")), + } +} + +/// Decode an optional item, attaching a field name to any errors. +pub fn decode_some_msg_map(r: &Option, msg: &'static str, f: F) -> eyre::Result +where + F: Fn(&R) -> eyre::Result, +{ + decode_some_map(r, f).wrap_err(msg) +} + +/// Decode a `oneof` field, returning an error if it's missing. +pub fn decode_oneof_map(r: &Option, f: F) -> eyre::Result +where + F: Fn(&R) -> eyre::Result, +{ + decode_some_msg_map(r, "oneof value", f) +}