@aztec/protocol-contracts 0.0.1-commit.f5d02921e → 0.0.1-commit.f650c0a5c
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/artifacts/AuthRegistry.json +541 -521
- package/artifacts/ContractClassRegistry.json +56 -56
- package/artifacts/ContractInstanceRegistry.json +62 -216
- package/artifacts/FeeJuice.json +64 -222
- package/artifacts/MultiCallEntrypoint.json +487 -365
- package/artifacts/PublicChecks.json +503 -381
- package/dest/protocol_contract_data.js +39 -39
- package/package.json +4 -4
- package/src/protocol_contract_data.ts +38 -38
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"transpiled": true,
|
|
3
|
-
"noir_version": "1.0.0-beta.19+
|
|
3
|
+
"noir_version": "1.0.0-beta.19+c09ce9a7dbec1708a8b167fad7411ece61d8b9ea",
|
|
4
4
|
"name": "ContractInstanceRegistry",
|
|
5
5
|
"functions": [
|
|
6
6
|
{
|
|
@@ -52,10 +52,6 @@
|
|
|
52
52
|
],
|
|
53
53
|
"return_type": null,
|
|
54
54
|
"error_types": {
|
|
55
|
-
"361444214588792908": {
|
|
56
|
-
"error_kind": "string",
|
|
57
|
-
"string": "attempt to multiply with overflow"
|
|
58
|
-
},
|
|
59
55
|
"1998584279744703196": {
|
|
60
56
|
"error_kind": "string",
|
|
61
57
|
"string": "attempt to subtract with overflow"
|
|
@@ -99,8 +95,8 @@
|
|
|
99
95
|
}
|
|
100
96
|
}
|
|
101
97
|
},
|
|
102
|
-
"bytecode": "
|
|
103
|
-
"debug_symbols": "
|
|
98
|
+
"bytecode": "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",
|
|
99
|
+
"debug_symbols": "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"
|
|
104
100
|
},
|
|
105
101
|
{
|
|
106
102
|
"name": "publish_for_public_execution",
|
|
@@ -2082,9 +2078,9 @@
|
|
|
2082
2078
|
}
|
|
2083
2079
|
}
|
|
2084
2080
|
},
|
|
2085
|
-
"bytecode": "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",
|
|
2086
|
-
"debug_symbols": "tVvbbhs5DP0XP/tBFC+
|
|
2087
|
-
"verification_key": "
|
|
2081
|
+
"bytecode": "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",
|
|
2082
|
+
"debug_symbols": "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",
|
|
2083
|
+
"verification_key": "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"
|
|
2088
2084
|
},
|
|
2089
2085
|
{
|
|
2090
2086
|
"name": "set_update_delay",
|
|
@@ -2106,10 +2102,6 @@
|
|
|
2106
2102
|
],
|
|
2107
2103
|
"return_type": null,
|
|
2108
2104
|
"error_types": {
|
|
2109
|
-
"361444214588792908": {
|
|
2110
|
-
"error_kind": "string",
|
|
2111
|
-
"string": "attempt to multiply with overflow"
|
|
2112
|
-
},
|
|
2113
2105
|
"1998584279744703196": {
|
|
2114
2106
|
"error_kind": "string",
|
|
2115
2107
|
"string": "attempt to subtract with overflow"
|
|
@@ -2136,8 +2128,8 @@
|
|
|
2136
2128
|
}
|
|
2137
2129
|
}
|
|
2138
2130
|
},
|
|
2139
|
-
"bytecode": "
|
|
2140
|
-
"debug_symbols": "
|
|
2131
|
+
"bytecode": "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",
|
|
2132
|
+
"debug_symbols": "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"
|
|
2141
2133
|
},
|
|
2142
2134
|
{
|
|
2143
2135
|
"name": "update",
|
|
@@ -2166,10 +2158,6 @@
|
|
|
2166
2158
|
],
|
|
2167
2159
|
"return_type": null,
|
|
2168
2160
|
"error_types": {
|
|
2169
|
-
"361444214588792908": {
|
|
2170
|
-
"error_kind": "string",
|
|
2171
|
-
"string": "attempt to multiply with overflow"
|
|
2172
|
-
},
|
|
2173
2161
|
"1998584279744703196": {
|
|
2174
2162
|
"error_kind": "string",
|
|
2175
2163
|
"string": "attempt to subtract with overflow"
|
|
@@ -2196,8 +2184,8 @@
|
|
|
2196
2184
|
}
|
|
2197
2185
|
}
|
|
2198
2186
|
},
|
|
2199
|
-
"bytecode": "
|
|
2200
|
-
"debug_symbols": "
|
|
2187
|
+
"bytecode": "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",
|
|
2188
|
+
"debug_symbols": "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"
|
|
2201
2189
|
}
|
|
2202
2190
|
],
|
|
2203
2191
|
"outputs": {
|
|
@@ -3623,95 +3611,95 @@
|
|
|
3623
3611
|
},
|
|
3624
3612
|
{
|
|
3625
3613
|
"name": "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher",
|
|
3626
|
-
"start":
|
|
3614
|
+
"start": 6947
|
|
3627
3615
|
},
|
|
3628
3616
|
{
|
|
3629
3617
|
"name": "<impl Default for BuildHasherDefault<H>>::default",
|
|
3630
|
-
"start":
|
|
3618
|
+
"start": 7079
|
|
3631
3619
|
},
|
|
3632
3620
|
{
|
|
3633
3621
|
"name": "<impl Hash for Field>::hash",
|
|
3634
|
-
"start":
|
|
3622
|
+
"start": 7211
|
|
3635
3623
|
},
|
|
3636
3624
|
{
|
|
3637
3625
|
"name": "<impl Hash for u1>::hash",
|
|
3638
|
-
"start":
|
|
3626
|
+
"start": 7341
|
|
3639
3627
|
},
|
|
3640
3628
|
{
|
|
3641
3629
|
"name": "<impl Hash for u8>::hash",
|
|
3642
|
-
"start":
|
|
3630
|
+
"start": 7480
|
|
3643
3631
|
},
|
|
3644
3632
|
{
|
|
3645
3633
|
"name": "<impl Hash for u16>::hash",
|
|
3646
|
-
"start":
|
|
3634
|
+
"start": 7620
|
|
3647
3635
|
},
|
|
3648
3636
|
{
|
|
3649
3637
|
"name": "<impl Hash for u32>::hash",
|
|
3650
|
-
"start":
|
|
3638
|
+
"start": 7760
|
|
3651
3639
|
},
|
|
3652
3640
|
{
|
|
3653
3641
|
"name": "<impl Hash for u64>::hash",
|
|
3654
|
-
"start":
|
|
3642
|
+
"start": 7900
|
|
3655
3643
|
},
|
|
3656
3644
|
{
|
|
3657
3645
|
"name": "<impl Hash for u128>::hash",
|
|
3658
|
-
"start":
|
|
3646
|
+
"start": 8041
|
|
3659
3647
|
},
|
|
3660
3648
|
{
|
|
3661
3649
|
"name": "<impl Hash for i8>::hash",
|
|
3662
|
-
"start":
|
|
3650
|
+
"start": 8180
|
|
3663
3651
|
},
|
|
3664
3652
|
{
|
|
3665
3653
|
"name": "<impl Hash for i16>::hash",
|
|
3666
|
-
"start":
|
|
3654
|
+
"start": 8326
|
|
3667
3655
|
},
|
|
3668
3656
|
{
|
|
3669
3657
|
"name": "<impl Hash for i32>::hash",
|
|
3670
|
-
"start":
|
|
3658
|
+
"start": 8473
|
|
3671
3659
|
},
|
|
3672
3660
|
{
|
|
3673
3661
|
"name": "<impl Hash for i64>::hash",
|
|
3674
|
-
"start":
|
|
3662
|
+
"start": 8620
|
|
3675
3663
|
},
|
|
3676
3664
|
{
|
|
3677
3665
|
"name": "<impl Hash for bool>::hash",
|
|
3678
|
-
"start":
|
|
3666
|
+
"start": 8768
|
|
3679
3667
|
},
|
|
3680
3668
|
{
|
|
3681
3669
|
"name": "<impl Hash for ()>::hash",
|
|
3682
|
-
"start":
|
|
3670
|
+
"start": 8915
|
|
3683
3671
|
},
|
|
3684
3672
|
{
|
|
3685
3673
|
"name": "<impl Hash for [T; N]>::hash",
|
|
3686
|
-
"start":
|
|
3674
|
+
"start": 9047
|
|
3687
3675
|
},
|
|
3688
3676
|
{
|
|
3689
3677
|
"name": "<impl Hash for [T]>::hash",
|
|
3690
|
-
"start":
|
|
3678
|
+
"start": 9236
|
|
3691
3679
|
},
|
|
3692
3680
|
{
|
|
3693
3681
|
"name": "<impl Hash for (A, B)>::hash",
|
|
3694
|
-
"start":
|
|
3682
|
+
"start": 9476
|
|
3695
3683
|
},
|
|
3696
3684
|
{
|
|
3697
3685
|
"name": "<impl Hash for (A, B, C)>::hash",
|
|
3698
|
-
"start":
|
|
3686
|
+
"start": 9692
|
|
3699
3687
|
},
|
|
3700
3688
|
{
|
|
3701
3689
|
"name": "<impl Hash for (A, B, C, D)>::hash",
|
|
3702
|
-
"start":
|
|
3690
|
+
"start": 9955
|
|
3703
3691
|
},
|
|
3704
3692
|
{
|
|
3705
3693
|
"name": "<impl Hash for (A, B, C, D, E)>::hash",
|
|
3706
|
-
"start":
|
|
3694
|
+
"start": 10265
|
|
3707
3695
|
},
|
|
3708
3696
|
{
|
|
3709
3697
|
"name": "assert_pedersen",
|
|
3710
|
-
"start":
|
|
3698
|
+
"start": 10661
|
|
3711
3699
|
}
|
|
3712
3700
|
],
|
|
3713
3701
|
"path": "std/hash/mod.nr",
|
|
3714
|
-
"source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n crate::assert_constant(separator);\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n crate::assert_constant(starting_index);\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Decompose the input 'bn254 scalar' into two 128 bits limbs.\n// It is called 'unsafe' because it does not assert the limbs are 128 bits\n// Assuming the limbs are 128 bits:\n// Assert the decomposition does not overflow the field size.\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n // Check that the decomposition does not overflow the field size\n let (a, b) = if xhi == crate::field::bn254::PHI {\n (xlo, crate::field::bn254::PLO)\n } else {\n (xhi, crate::field::bn254::PHI)\n };\n crate::field::bn254::assert_lt(a, b);\n\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n\n static_assert(\n N == POSEIDON2_CONFIG_STATE_SIZE,\n f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n );\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u8 as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u16 as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u32 as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u64 as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash<H>(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<T> Hash for [T]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n"
|
|
3702
|
+
"source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n crate::assert_constant(separator);\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n crate::assert_constant(starting_index);\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Decompose the input 'bn254 scalar' into two 128 bits limbs.\n// It is called 'unsafe' because it does not assert the limbs are 128 bits\n// Assuming the limbs are 128 bits:\n// Assert the decomposition does not overflow the field size.\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n // Check that the decomposition does not overflow the field size\n let (a, b) = if xhi == crate::field::bn254::PHI {\n (xlo, crate::field::bn254::PLO)\n } else {\n (xhi, crate::field::bn254::PHI)\n };\n crate::field::bn254::assert_lt(a, b);\n\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N], state_len: u32) -> [Field; N] {\n assert_eq(input.len(), state_len);\n\n static_assert(\n N == POSEIDON2_CONFIG_STATE_SIZE,\n f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n );\n poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n /// Returns the hash value without consuming the hasher.\n /// Override this for more efficient implementations that avoid copying.\n /// TODO: deprecate finish() and replace it\n fn finish_ref(&self) -> Field {\n (*self).finish()\n }\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u8 as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u16 as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u32 as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as u64 as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash<H>(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<T> Hash for [T]\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n"
|
|
3715
3703
|
},
|
|
3716
3704
|
"181": {
|
|
3717
3705
|
"function_locations": [
|
|
@@ -4475,148 +4463,6 @@
|
|
|
4475
4463
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
|
|
4476
4464
|
"source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal U1_SERIALIZED_LEN: u32 = 1;\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for bool {\n let N: u32 = BOOL_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> bool {\n reader.read() != 0\n }\n}\n\nimpl Serialize for u1 {\n let N: u32 = U1_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u1 {\n let N: u32 = U1_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u1\n }\n}\n\nimpl Serialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u8 {\n let N: u32 = U8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8\n }\n}\n\nimpl Serialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u16 {\n let N: u32 = U16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16\n }\n}\n\nimpl Serialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u32 {\n let N: u32 = U32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32\n }\n}\n\nimpl Serialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u64 {\n let N: u32 = U64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64\n }\n}\n\nimpl Serialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as Field);\n }\n}\n\nimpl Deserialize for u128 {\n let N: u32 = U128_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u128\n }\n}\n\nimpl Serialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self);\n }\n}\n\nimpl Deserialize for Field {\n let N: u32 = FIELD_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read()\n }\n}\n\nimpl Serialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u8 as Field);\n }\n}\n\nimpl Deserialize for i8 {\n let N: u32 = I8_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u8 as i8\n }\n}\n\nimpl Serialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u16 as Field);\n }\n}\n\nimpl Deserialize for i16 {\n let N: u32 = I16_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u16 as i16\n }\n}\n\nimpl Serialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u32 as Field);\n }\n}\n\nimpl Deserialize for i32 {\n let N: u32 = I32_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u32 as i32\n }\n}\n\nimpl Serialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self as u64 as Field);\n }\n}\n\nimpl Deserialize for i64 {\n let N: u32 = I64_SERIALIZED_LEN;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n reader.read() as u64 as i64\n }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n for i in 0..M {\n self[i].stream_serialize(writer);\n }\n }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut result: [T; M] = std::mem::zeroed();\n for i in 0..M {\n result[i] = T::stream_deserialize(reader);\n }\n result\n }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N + 1;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write_bool(self.is_some());\n if self.is_some() {\n self.unwrap_unchecked().stream_serialize(writer);\n } else {\n writer.advance_offset(<T as Serialize>::N);\n }\n }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n if reader.read_bool() {\n Option::some(<T as Deserialize>::stream_deserialize(reader))\n } else {\n reader.advance_offset(<T as Deserialize>::N);\n Option::none()\n }\n }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n let N: u32 = SCALAR_SIZE;\n\n fn serialize(self) -> [Field; SCALAR_SIZE] {\n [self.lo, self.hi]\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.lo);\n writer.write(self.hi);\n }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n let N: u32 = SCALAR_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { lo: fields[0], hi: fields[1] }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { lo: reader.read(), hi: reader.read() }\n }\n}\n\nglobal POINT_SIZE: u32 = 3;\n\nimpl Serialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn serialize(self) -> [Field; Self::N] {\n [self.x, self.y, self.is_infinite as Field]\n }\n\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n writer.write(self.x);\n writer.write(self.y);\n writer.write(self.is_infinite as Field);\n }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n let N: u32 = POINT_SIZE;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n Self { x: fields[0], y: fields[1], is_infinite: fields[2] != 0 }\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n Self { x: reader.read(), y: reader.read(), is_infinite: reader.read_bool() }\n }\n}\n\nimpl<let M: u32> Deserialize for str<M> {\n let N: u32 = M;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n str::<Self::N>::from(u8_arr)\n }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n let N: u32 = M;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.as_bytes().stream_serialize(writer);\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n T: Deserialize,\n{\n let N: u32 = <T as Deserialize>::N * M + 1;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n let payload_len = Self::N - 1;\n\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n let len = reader.peek_offset(payload_len) as u32;\n\n for i in 0..M {\n if i < len {\n new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n }\n }\n\n // +1 for the length of the BoundedVec\n reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n new_bounded_vec\n }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n let N: u32 = 0;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(_reader: &mut Reader<K>) -> Self {\n ()\n }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n T: Serialize,\n{\n let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: Writer<Self::N> = Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.storage().stream_serialize(writer);\n // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n writer.write_u32(self.len() as u32);\n }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n let mut slice = @[];\n for i in 0..length {\n slice = slice.push_back(f(i));\n }\n slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n // `T0`, `T1`, `T2`\n let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n // `result0`, `result1`, `result2`\n let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n // `T0, T1, T2`\n let field_generics = type_names.join(quote [,]);\n\n // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n let full_size_serialize = type_names\n .map(|type_name| quote {\n <$type_name as Serialize>::N\n })\n .join(quote [+]);\n\n // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n let full_size_deserialize = type_names\n .map(|type_name| quote {\n <$type_name as Deserialize>::N\n })\n .join(quote [+]);\n\n // `T0: Serialize, T1: Serialize, T2: Serialize,`\n let serialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Serialize,\n })\n .join(quote []);\n\n // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n let deserialize_constraints = type_names\n .map(|field_name| quote {\n $field_name: Deserialize,\n })\n .join(quote []);\n\n // Statements to serialize each field\n let serialized_fields = type_names\n .mapi(|i, _type_name| quote {\n $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n })\n .join(quote []);\n\n // Statements to deserialize each field\n let deserialized_fields = type_names\n .mapi(|i, type_name| {\n let result_name = result_names[i];\n quote {\n let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n }\n })\n .join(quote []);\n let deserialize_results = result_names.join(quote [,]);\n\n quote {\n impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n let N: u32 = $full_size_serialize;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n\n $serialized_fields\n }\n }\n\n impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n let N: u32 = $full_size_deserialize;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = $crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n \n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n $deserialized_fields\n ($deserialize_results)\n }\n }\n }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n T1: Serialize,\n{\n let N: u32 = <T1 as Serialize>::N;\n\n fn serialize(self) -> [Field; Self::N] {\n let mut writer: crate::writer::Writer<Self::N> = crate::writer::Writer::new();\n self.stream_serialize(&mut writer);\n writer.finish()\n }\n\n #[inline_always]\n fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n self.0.stream_serialize(writer);\n }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n T1: Deserialize,\n{\n let N: u32 = <T1 as Deserialize>::N;\n\n fn deserialize(fields: [Field; Self::N]) -> Self {\n let mut reader = crate::reader::Reader::new(fields);\n let result = Self::stream_deserialize(&mut reader);\n reader.finish();\n result\n }\n\n #[inline_always]\n fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n (<T1 as Deserialize>::stream_deserialize(reader),)\n }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n use crate::serialization::{Deserialize, Serialize};\n}\n\n#[test]\nunconstrained fn bounded_vec_serialization() {\n // Test empty BoundedVec\n let empty_vec: BoundedVec<Field, 3> = BoundedVec::from_array([]);\n let serialized = empty_vec.serialize();\n let deserialized = BoundedVec::<Field, 3>::deserialize(serialized);\n assert_eq(empty_vec, deserialized);\n assert_eq(deserialized.len(), 0);\n\n // Test partially filled BoundedVec\n let partial_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2]]);\n let serialized = partial_vec.serialize();\n let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n assert_eq(partial_vec, deserialized);\n assert_eq(deserialized.len(), 1);\n assert_eq(deserialized.get(0), [1, 2]);\n\n // Test full BoundedVec\n let full_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2], [3, 4], [5, 6]]);\n let serialized = full_vec.serialize();\n let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n assert_eq(full_vec, deserialized);\n assert_eq(deserialized.len(), 3);\n assert_eq(deserialized.get(0), [1, 2]);\n assert_eq(deserialized.get(1), [3, 4]);\n assert_eq(deserialized.get(2), [5, 6]);\n}\n"
|
|
4477
4465
|
},
|
|
4478
|
-
"3": {
|
|
4479
|
-
"function_locations": [
|
|
4480
|
-
{
|
|
4481
|
-
"name": "[T; N]::len",
|
|
4482
|
-
"start": 480
|
|
4483
|
-
},
|
|
4484
|
-
{
|
|
4485
|
-
"name": "[T; N]::as_vector",
|
|
4486
|
-
"start": 735
|
|
4487
|
-
},
|
|
4488
|
-
{
|
|
4489
|
-
"name": "[T; N]::as_slice",
|
|
4490
|
-
"start": 1112
|
|
4491
|
-
},
|
|
4492
|
-
{
|
|
4493
|
-
"name": "[T; N]::map",
|
|
4494
|
-
"start": 1442
|
|
4495
|
-
},
|
|
4496
|
-
{
|
|
4497
|
-
"name": "[T; N]::mapi",
|
|
4498
|
-
"start": 2002
|
|
4499
|
-
},
|
|
4500
|
-
{
|
|
4501
|
-
"name": "[T; N]::for_each",
|
|
4502
|
-
"start": 2549
|
|
4503
|
-
},
|
|
4504
|
-
{
|
|
4505
|
-
"name": "[T; N]::for_eachi",
|
|
4506
|
-
"start": 2966
|
|
4507
|
-
},
|
|
4508
|
-
{
|
|
4509
|
-
"name": "[T; N]::fold",
|
|
4510
|
-
"start": 3832
|
|
4511
|
-
},
|
|
4512
|
-
{
|
|
4513
|
-
"name": "[T; N]::reduce",
|
|
4514
|
-
"start": 4349
|
|
4515
|
-
},
|
|
4516
|
-
{
|
|
4517
|
-
"name": "[T; N]::all",
|
|
4518
|
-
"start": 4858
|
|
4519
|
-
},
|
|
4520
|
-
{
|
|
4521
|
-
"name": "[T; N]::any",
|
|
4522
|
-
"start": 5330
|
|
4523
|
-
},
|
|
4524
|
-
{
|
|
4525
|
-
"name": "[T; N]::concat",
|
|
4526
|
-
"start": 5872
|
|
4527
|
-
},
|
|
4528
|
-
{
|
|
4529
|
-
"name": "[T; N]::sort",
|
|
4530
|
-
"start": 6768
|
|
4531
|
-
},
|
|
4532
|
-
{
|
|
4533
|
-
"name": "[T; N]::sort_via",
|
|
4534
|
-
"start": 7783
|
|
4535
|
-
},
|
|
4536
|
-
{
|
|
4537
|
-
"name": "[u8; N]::as_str_unchecked",
|
|
4538
|
-
"start": 8811
|
|
4539
|
-
},
|
|
4540
|
-
{
|
|
4541
|
-
"name": "<impl From<str<N>> for [u8; N]>::from",
|
|
4542
|
-
"start": 8938
|
|
4543
|
-
},
|
|
4544
|
-
{
|
|
4545
|
-
"name": "test::map_empty",
|
|
4546
|
-
"start": 9012
|
|
4547
|
-
},
|
|
4548
|
-
{
|
|
4549
|
-
"name": "test::sort_u32",
|
|
4550
|
-
"start": 10122
|
|
4551
|
-
},
|
|
4552
|
-
{
|
|
4553
|
-
"name": "test::test_sort",
|
|
4554
|
-
"start": 10177
|
|
4555
|
-
},
|
|
4556
|
-
{
|
|
4557
|
-
"name": "test::test_sort_100_values",
|
|
4558
|
-
"start": 10408
|
|
4559
|
-
},
|
|
4560
|
-
{
|
|
4561
|
-
"name": "test::test_sort_100_values_comptime",
|
|
4562
|
-
"start": 11576
|
|
4563
|
-
},
|
|
4564
|
-
{
|
|
4565
|
-
"name": "test::test_sort_via",
|
|
4566
|
-
"start": 11721
|
|
4567
|
-
},
|
|
4568
|
-
{
|
|
4569
|
-
"name": "test::test_sort_via_100_values",
|
|
4570
|
-
"start": 11968
|
|
4571
|
-
},
|
|
4572
|
-
{
|
|
4573
|
-
"name": "test::mapi_empty",
|
|
4574
|
-
"start": 13129
|
|
4575
|
-
},
|
|
4576
|
-
{
|
|
4577
|
-
"name": "test::for_each_empty",
|
|
4578
|
-
"start": 13224
|
|
4579
|
-
},
|
|
4580
|
-
{
|
|
4581
|
-
"name": "test::for_eachi_empty",
|
|
4582
|
-
"start": 13362
|
|
4583
|
-
},
|
|
4584
|
-
{
|
|
4585
|
-
"name": "test::map_example",
|
|
4586
|
-
"start": 13501
|
|
4587
|
-
},
|
|
4588
|
-
{
|
|
4589
|
-
"name": "test::mapi_example",
|
|
4590
|
-
"start": 13638
|
|
4591
|
-
},
|
|
4592
|
-
{
|
|
4593
|
-
"name": "test::for_each_example",
|
|
4594
|
-
"start": 13787
|
|
4595
|
-
},
|
|
4596
|
-
{
|
|
4597
|
-
"name": "test::for_eachi_example",
|
|
4598
|
-
"start": 14127
|
|
4599
|
-
},
|
|
4600
|
-
{
|
|
4601
|
-
"name": "test::concat",
|
|
4602
|
-
"start": 14338
|
|
4603
|
-
},
|
|
4604
|
-
{
|
|
4605
|
-
"name": "test::concat_zero_length_with_something",
|
|
4606
|
-
"start": 14597
|
|
4607
|
-
},
|
|
4608
|
-
{
|
|
4609
|
-
"name": "test::concat_something_with_zero_length",
|
|
4610
|
-
"start": 14800
|
|
4611
|
-
},
|
|
4612
|
-
{
|
|
4613
|
-
"name": "test::concat_zero_lengths",
|
|
4614
|
-
"start": 14989
|
|
4615
|
-
}
|
|
4616
|
-
],
|
|
4617
|
-
"path": "std/array/mod.nr",
|
|
4618
|
-
"source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n /// Returns the length of this array.\n ///\n /// ```noir\n /// fn len(self) -> Field\n /// ```\n ///\n /// example\n ///\n /// ```noir\n /// fn main() {\n /// let array = [42, 42];\n /// assert(array.len() == 2);\n /// }\n /// ```\n #[builtin(array_len)]\n pub fn len(self) -> u32 {}\n\n /// Returns this array as a vector.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let vector = array.as_vector();\n /// assert_eq(vector, [1, 2].as_vector());\n /// ```\n #[builtin(as_vector)]\n pub fn as_vector(self) -> [T] {}\n\n /// Returns this array as a vector.\n /// This method is deprecated in favor of `as_vector`.\n ///\n /// ```noir\n /// let array = [1, 2];\n /// let vector = array.as_slice();\n /// assert_eq(vector, [1, 2].as_vector());\n /// ```\n #[builtin(as_vector)]\n #[deprecated(\"This method has been renamed to `as_vector`\")]\n pub fn as_slice(self) -> [T] {}\n\n /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.map(|a| a * 2);\n /// assert_eq(b, [2, 4, 6]);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array along with its index,\n /// returning a new array containing the mapped elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let b = a.mapi(|i, a| i + a * 2);\n /// assert_eq(b, [2, 5, 8]);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> [U; N] {\n let uninitialized = crate::mem::zeroed();\n let mut ret = [uninitialized; N];\n\n for i in 0..self.len() {\n ret[i] = f(i, self[i]);\n }\n\n ret\n }\n\n /// Applies a function to each element of this array.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// let mut i = 0;\n /// a.for_each(|x| {\n /// b[i] = x;\n /// i += 1;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n for i in 0..self.len() {\n f(self[i]);\n }\n }\n\n /// Applies a function to each element of this array along with its index.\n ///\n /// Example:\n ///\n /// ```rust\n /// let a = [1, 2, 3];\n /// let mut b = [0; 3];\n /// a.for_eachi(|i, x| {\n /// b[i] = x;\n /// });\n /// assert_eq(a, b);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n for i in 0..self.len() {\n f(i, self[i]);\n }\n }\n\n /// Applies a function to each element of the array, returning the final accumulated value. The first\n /// parameter is the initial value.\n ///\n /// This is a left fold, so the given function will be applied to the accumulator and first element of\n /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n ///\n /// ```rust\n /// let a1 = [1];\n /// let a2 = [1, 2];\n /// let a3 = [1, 2, 3];\n ///\n /// let f = |a, b| a - b;\n /// a1.fold(10, f); //=> f(10, 1)\n /// a2.fold(10, f); //=> f(f(10, 1), 2)\n /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n ///\n /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n /// ```\n pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n for elem in self {\n accumulator = f(accumulator, elem);\n }\n accumulator\n }\n\n /// Same as fold, but uses the first element as the starting element.\n ///\n /// Requires the input array to be non-empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [1, 2, 3, 4];\n /// let reduced = arr.reduce(|a, b| a + b);\n /// assert(reduced == 10);\n /// }\n /// ```\n pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n let mut accumulator = self[0];\n for i in 1..self.len() {\n accumulator = f(accumulator, self[i]);\n }\n accumulator\n }\n\n /// Returns true if all the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 2];\n /// let all = arr.all(|a| a == 2);\n /// assert(all);\n /// }\n /// ```\n pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = true;\n for elem in self {\n ret &= predicate(elem);\n }\n ret\n }\n\n /// Returns true if any of the elements in this array satisfy the given predicate.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr = [2, 2, 2, 2, 5];\n /// let any = arr.any(|a| a == 5);\n /// assert(any);\n /// }\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n for elem in self {\n ret |= predicate(elem);\n }\n ret\n }\n\n /// Concatenates this array with another array.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn main() {\n /// let arr1 = [1, 2, 3, 4];\n /// let arr2 = [6, 7, 8, 9, 10, 11];\n /// let concatenated_arr = arr1.concat(arr2);\n /// assert(concatenated_arr == [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n /// }\n /// ```\n pub fn concat<let M: u32>(self, array2: [T; M]) -> [T; N + M] {\n let mut result = [crate::mem::zeroed(); N + M];\n for i in 0..N {\n result[i] = self[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Ord + Eq,\n{\n /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n /// sort any type, you should use the [`Self::sort_via`] function.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32];\n /// let sorted = arr.sort();\n /// assert(sorted == [32, 42]);\n /// }\n /// ```\n pub fn sort(self) -> Self {\n self.sort_via(|a, b| a <= b)\n }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n T: Eq,\n{\n /// Returns a new sorted array by sorting it with a custom comparison function.\n /// The original array remains untouched.\n /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n ///\n /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let arr = [42, 32]\n /// let sorted_ascending = arr.sort_via(|a, b| a <= b);\n /// assert(sorted_ascending == [32, 42]); // verifies\n ///\n /// let sorted_descending = arr.sort_via(|a, b| a >= b);\n /// assert(sorted_descending == [32, 42]); // does not verify\n /// }\n /// ```\n pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n // Safety: `sorted` array is checked to be:\n // a. a permutation of `input`'s elements\n // b. satisfying the predicate `ordering`\n let sorted = unsafe { quicksort::quicksort(self, ordering) };\n\n if !is_unconstrained() {\n for i in 0..N - 1 {\n assert(\n ordering(sorted[i], sorted[i + 1]),\n \"Array has not been sorted correctly according to `ordering`.\",\n );\n }\n check_shuffle::check_shuffle(self, sorted);\n }\n sorted\n }\n}\n\nimpl<let N: u32> [u8; N] {\n /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n /// the given array is interpreted as-is as a string.\n ///\n /// Example:\n ///\n /// ```rust\n /// fn main() {\n /// let hi = [104, 105].as_str_unchecked();\n /// assert_eq(hi, \"hi\");\n /// }\n /// ```\n #[builtin(array_as_str_unchecked)]\n pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n /// Returns an array of the string bytes.\n fn from(s: str<N>) -> Self {\n s.as_bytes()\n }\n}\n\nmod test {\n #[test]\n fn map_empty() {\n assert_eq([].map(|x| x + 1), []);\n }\n\n global arr_with_100_values: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2, 54,\n 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41, 19, 98,\n 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21, 43, 86, 35,\n 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15, 127, 81, 30, 8,\n 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n global expected_with_100_values: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30, 32,\n 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58, 61, 62,\n 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82, 84, 84, 86,\n 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114, 114, 116, 118,\n 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n fn sort_u32(a: u32, b: u32) -> bool {\n a <= b\n }\n\n #[test]\n fn test_sort() {\n let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort();\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values() {\n let arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort();\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_100_values_comptime() {\n let sorted = arr_with_100_values.sort();\n assert(sorted == expected_with_100_values);\n }\n\n #[test]\n fn test_sort_via() {\n let arr: [u32; 7] = [3, 6, 8, 10, 1, 2, 1];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 7] = [1, 1, 2, 3, 6, 8, 10];\n assert(sorted == expected);\n }\n\n #[test]\n fn test_sort_via_100_values() {\n let arr: [u32; 100] = [\n 42, 123, 87, 93, 48, 80, 50, 5, 104, 84, 70, 47, 119, 66, 71, 121, 3, 29, 42, 118, 2,\n 54, 89, 44, 81, 0, 26, 106, 68, 96, 84, 48, 95, 54, 45, 32, 89, 100, 109, 19, 37, 41,\n 19, 98, 53, 114, 107, 66, 6, 74, 13, 19, 105, 64, 123, 28, 44, 50, 89, 58, 123, 126, 21,\n 43, 86, 35, 21, 62, 82, 0, 108, 120, 72, 72, 62, 80, 12, 71, 70, 86, 116, 73, 38, 15,\n 127, 81, 30, 8, 125, 28, 26, 69, 114, 63, 27, 28, 61, 42, 13, 32,\n ];\n\n let sorted = arr.sort_via(sort_u32);\n\n let expected: [u32; 100] = [\n 0, 0, 2, 3, 5, 6, 8, 12, 13, 13, 15, 19, 19, 19, 21, 21, 26, 26, 27, 28, 28, 28, 29, 30,\n 32, 32, 35, 37, 38, 41, 42, 42, 42, 43, 44, 44, 45, 47, 48, 48, 50, 50, 53, 54, 54, 58,\n 61, 62, 62, 63, 64, 66, 66, 68, 69, 70, 70, 71, 71, 72, 72, 73, 74, 80, 80, 81, 81, 82,\n 84, 84, 86, 86, 87, 89, 89, 89, 93, 95, 96, 98, 100, 104, 105, 106, 107, 108, 109, 114,\n 114, 116, 118, 119, 120, 121, 123, 123, 123, 125, 126, 127,\n ];\n assert(sorted == expected);\n }\n\n #[test]\n fn mapi_empty() {\n assert_eq([].mapi(|i, x| i * x + 1), []);\n }\n\n #[test]\n fn for_each_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_each(|_x| assert(false));\n }\n\n #[test]\n fn for_eachi_empty() {\n let empty_array: [Field; 0] = [];\n empty_array.for_eachi(|_i, _x| assert(false));\n }\n\n #[test]\n fn map_example() {\n let a = [1, 2, 3];\n let b = a.map(|a| a * 2);\n assert_eq(b, [2, 4, 6]);\n }\n\n #[test]\n fn mapi_example() {\n let a = [1, 2, 3];\n let b = a.mapi(|i, a| i + a * 2);\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn for_each_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n let mut i = 0;\n let i_ref = &mut i;\n a.for_each(|x| {\n b_ref[*i_ref] = x * 2;\n *i_ref += 1;\n });\n assert_eq(b, [2, 4, 6]);\n assert_eq(i, 3);\n }\n\n #[test]\n fn for_eachi_example() {\n let a = [1, 2, 3];\n let mut b = [0, 0, 0];\n let b_ref = &mut b;\n a.for_eachi(|i, a| { b_ref[i] = i + a * 2; });\n assert_eq(b, [2, 5, 8]);\n }\n\n #[test]\n fn concat() {\n let arr1 = [1, 2, 3, 4];\n let arr2 = [6, 7, 8, 9, 10, 11];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]);\n }\n\n #[test]\n fn concat_zero_length_with_something() {\n let arr1 = [];\n let arr2 = [1];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_something_with_zero_length() {\n let arr1 = [1];\n let arr2 = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, [1]);\n }\n\n #[test]\n fn concat_zero_lengths() {\n let arr1: [Field; 0] = [];\n let arr2: [Field; 0] = [];\n let concatenated_arr = arr1.concat(arr2);\n assert_eq(concatenated_arr, []);\n }\n}\n"
|
|
4619
|
-
},
|
|
4620
4466
|
"41": {
|
|
4621
4467
|
"function_locations": [
|
|
4622
4468
|
{
|
|
@@ -4629,91 +4475,91 @@
|
|
|
4629
4475
|
},
|
|
4630
4476
|
{
|
|
4631
4477
|
"name": "Option<T>::is_none",
|
|
4632
|
-
"start":
|
|
4478
|
+
"start": 672
|
|
4633
4479
|
},
|
|
4634
4480
|
{
|
|
4635
4481
|
"name": "Option<T>::is_some",
|
|
4636
|
-
"start":
|
|
4482
|
+
"start": 774
|
|
4637
4483
|
},
|
|
4638
4484
|
{
|
|
4639
4485
|
"name": "Option<T>::unwrap",
|
|
4640
|
-
"start":
|
|
4486
|
+
"start": 898
|
|
4641
4487
|
},
|
|
4642
4488
|
{
|
|
4643
4489
|
"name": "Option<T>::unwrap_unchecked",
|
|
4644
|
-
"start":
|
|
4490
|
+
"start": 1196
|
|
4645
4491
|
},
|
|
4646
4492
|
{
|
|
4647
4493
|
"name": "Option<T>::unwrap_or",
|
|
4648
|
-
"start":
|
|
4494
|
+
"start": 1368
|
|
4649
4495
|
},
|
|
4650
4496
|
{
|
|
4651
4497
|
"name": "Option<T>::unwrap_or_else",
|
|
4652
|
-
"start":
|
|
4498
|
+
"start": 1668
|
|
4653
4499
|
},
|
|
4654
4500
|
{
|
|
4655
4501
|
"name": "Option<T>::expect",
|
|
4656
|
-
"start":
|
|
4502
|
+
"start": 1969
|
|
4657
4503
|
},
|
|
4658
4504
|
{
|
|
4659
4505
|
"name": "Option<T>::map",
|
|
4660
|
-
"start":
|
|
4506
|
+
"start": 2190
|
|
4661
4507
|
},
|
|
4662
4508
|
{
|
|
4663
4509
|
"name": "Option<T>::map_or",
|
|
4664
|
-
"start":
|
|
4510
|
+
"start": 2490
|
|
4665
4511
|
},
|
|
4666
4512
|
{
|
|
4667
4513
|
"name": "Option<T>::map_or_else",
|
|
4668
|
-
"start":
|
|
4514
|
+
"start": 2784
|
|
4669
4515
|
},
|
|
4670
4516
|
{
|
|
4671
4517
|
"name": "Option<T>::and",
|
|
4672
|
-
"start":
|
|
4518
|
+
"start": 3009
|
|
4673
4519
|
},
|
|
4674
4520
|
{
|
|
4675
4521
|
"name": "Option<T>::and_then",
|
|
4676
|
-
"start":
|
|
4522
|
+
"start": 3446
|
|
4677
4523
|
},
|
|
4678
4524
|
{
|
|
4679
4525
|
"name": "Option<T>::or",
|
|
4680
|
-
"start":
|
|
4526
|
+
"start": 3669
|
|
4681
4527
|
},
|
|
4682
4528
|
{
|
|
4683
4529
|
"name": "Option<T>::or_else",
|
|
4684
|
-
"start":
|
|
4530
|
+
"start": 3902
|
|
4685
4531
|
},
|
|
4686
4532
|
{
|
|
4687
4533
|
"name": "Option<T>::xor",
|
|
4688
|
-
"start":
|
|
4534
|
+
"start": 4192
|
|
4689
4535
|
},
|
|
4690
4536
|
{
|
|
4691
4537
|
"name": "Option<T>::filter",
|
|
4692
|
-
"start":
|
|
4538
|
+
"start": 4636
|
|
4693
4539
|
},
|
|
4694
4540
|
{
|
|
4695
4541
|
"name": "Option<T>::flatten",
|
|
4696
|
-
"start":
|
|
4542
|
+
"start": 5065
|
|
4697
4543
|
},
|
|
4698
4544
|
{
|
|
4699
4545
|
"name": "<impl Default for Option<T>>::default",
|
|
4700
|
-
"start":
|
|
4546
|
+
"start": 5242
|
|
4701
4547
|
},
|
|
4702
4548
|
{
|
|
4703
4549
|
"name": "<impl Eq for Option<T>>::eq",
|
|
4704
|
-
"start":
|
|
4550
|
+
"start": 5357
|
|
4705
4551
|
},
|
|
4706
4552
|
{
|
|
4707
4553
|
"name": "<impl Hash for Option<T>>::hash",
|
|
4708
|
-
"start":
|
|
4554
|
+
"start": 5706
|
|
4709
4555
|
},
|
|
4710
4556
|
{
|
|
4711
4557
|
"name": "<impl Ord for Option<T>>::cmp",
|
|
4712
|
-
"start":
|
|
4558
|
+
"start": 5975
|
|
4713
4559
|
}
|
|
4714
4560
|
],
|
|
4715
4561
|
"path": "std/option.nr",
|
|
4716
|
-
"source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n _is_some: bool,\n _value: T,\n}\n\nimpl<T> Option<T> {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option<Option<T>> into a Option<T>.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl<T> Default for Option<T> {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n"
|
|
4562
|
+
"source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n _is_some: bool,\n _value: T,\n}\n\nimpl<T> Option<T> {\n /// Constructs a None value\n pub fn none() -> Self {\n Self { _is_some: false, _value: crate::mem::zeroed() }\n }\n\n /// Constructs a Some wrapper around the given value\n pub fn some(_value: T) -> Self {\n Self { _is_some: true, _value }\n }\n\n /// True if this Option is None\n pub fn is_none(&self) -> bool {\n !self._is_some\n }\n\n /// True if this Option is Some\n pub fn is_some(&self) -> bool {\n self._is_some\n }\n\n /// Asserts `self.is_some()` and returns the wrapped value.\n pub fn unwrap(self) -> T {\n assert(self._is_some);\n self._value\n }\n\n /// Returns the inner value without asserting `self.is_some()`\n /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n /// only that it will be of type `T`.\n pub fn unwrap_unchecked(self) -> T {\n self._value\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n pub fn unwrap_or(self, default: T) -> T {\n if self._is_some {\n self._value\n } else {\n default\n }\n }\n\n /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n /// a default value.\n pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n if self._is_some {\n self._value\n } else {\n default()\n }\n }\n\n /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n assert(self.is_some(), message);\n self._value\n }\n\n /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n if self._is_some {\n Option::some(f(self._value))\n } else {\n Option::none()\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default\n }\n }\n\n /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n if self._is_some {\n f(self._value)\n } else {\n default()\n }\n }\n\n /// Returns None if self is None. Otherwise, this returns `other`.\n pub fn and(self, other: Self) -> Self {\n if self.is_none() {\n Option::none()\n } else {\n other\n }\n }\n\n /// If self is None, this returns None. Otherwise, this calls the given function\n /// with the Some value contained within self, and returns the result of that call.\n ///\n /// In some languages this function is called `flat_map` or `bind`.\n pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n if self._is_some {\n f(self._value)\n } else {\n Option::none()\n }\n }\n\n /// If self is Some, return self. Otherwise, return `other`.\n pub fn or(self, other: Self) -> Self {\n if self._is_some {\n self\n } else {\n other\n }\n }\n\n /// If self is Some, return self. Otherwise, return `default()`.\n pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n if self._is_some {\n self\n } else {\n default()\n }\n }\n\n // If only one of the two Options is Some, return that option.\n // Otherwise, if both options are Some or both are None, None is returned.\n pub fn xor(self, other: Self) -> Self {\n if self._is_some {\n if other._is_some {\n Option::none()\n } else {\n self\n }\n } else if other._is_some {\n other\n } else {\n Option::none()\n }\n }\n\n /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n /// Otherwise, this returns `None`\n pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n if self._is_some {\n if predicate(self._value) {\n self\n } else {\n Option::none()\n }\n } else {\n Option::none()\n }\n }\n\n /// Flattens an Option<Option<T>> into a Option<T>.\n /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n if option._is_some {\n option._value\n } else {\n Option::none()\n }\n }\n}\n\nimpl<T> Default for Option<T> {\n fn default() -> Self {\n Option::none()\n }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n T: Eq,\n{\n fn eq(self, other: Self) -> bool {\n if self._is_some == other._is_some {\n if self._is_some {\n self._value == other._value\n } else {\n true\n }\n } else {\n false\n }\n }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n T: Hash,\n{\n fn hash<H>(self, state: &mut H)\n where\n H: Hasher,\n {\n self._is_some.hash(state);\n if self._is_some {\n self._value.hash(state);\n }\n }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n T: Ord,\n{\n fn cmp(self, other: Self) -> Ordering {\n if self._is_some {\n if other._is_some {\n self._value.cmp(other._value)\n } else {\n Ordering::greater()\n }\n } else if other._is_some {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n"
|
|
4717
4563
|
},
|
|
4718
4564
|
"42": {
|
|
4719
4565
|
"function_locations": [
|
|
@@ -5569,27 +5415,27 @@
|
|
|
5569
5415
|
"function_locations": [
|
|
5570
5416
|
{
|
|
5571
5417
|
"name": "assert_compatible_oracle_version",
|
|
5572
|
-
"start":
|
|
5418
|
+
"start": 1191
|
|
5573
5419
|
},
|
|
5574
5420
|
{
|
|
5575
5421
|
"name": "assert_compatible_oracle_version_wrapper",
|
|
5576
|
-
"start":
|
|
5422
|
+
"start": 1500
|
|
5577
5423
|
},
|
|
5578
5424
|
{
|
|
5579
5425
|
"name": "assert_compatible_oracle_version_oracle",
|
|
5580
|
-
"start":
|
|
5426
|
+
"start": 1732
|
|
5581
5427
|
},
|
|
5582
5428
|
{
|
|
5583
5429
|
"name": "test::compatible_oracle_version",
|
|
5584
|
-
"start":
|
|
5430
|
+
"start": 1911
|
|
5585
5431
|
},
|
|
5586
5432
|
{
|
|
5587
|
-
"name": "test::
|
|
5588
|
-
"start":
|
|
5433
|
+
"name": "test::incompatible_oracle_version_major",
|
|
5434
|
+
"start": 2136
|
|
5589
5435
|
}
|
|
5590
5436
|
],
|
|
5591
5437
|
"path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr",
|
|
5592
|
-
"source": "/// The
|
|
5438
|
+
"source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n/// - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n/// - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_utl_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 22;\npub global ORACLE_VERSION_MINOR: Field = 1;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n // compatible. It is therefore always safe to call.\n unsafe {\n assert_compatible_oracle_version_wrapper();\n }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_utl_assertCompatibleOracleVersionV2)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n use super::{assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR};\n\n #[test]\n unconstrained fn compatible_oracle_version() {\n assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n }\n\n #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n unconstrained fn incompatible_oracle_version_major() {\n let arbitrary_incorrect_major = 318183437;\n assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n }\n}\n"
|
|
5593
5439
|
},
|
|
5594
5440
|
"84": {
|
|
5595
5441
|
"function_locations": [
|