From 8cc43b269bb2f317fed1bdfbd7996734e7de2cd6 Mon Sep 17 00:00:00 2001 From: Danny Willems Date: Mon, 18 Aug 2025 16:37:39 +0200 Subject: [PATCH 1/3] Lint: fix all warnings for Rust 1.84 --- Cargo.toml | 5 +++ arrabbiata/src/challenge.rs | 2 +- curves/Cargo.toml | 3 ++ folding/src/eval_leaf.rs | 12 ++--- internal-tracing/Cargo.toml | 3 ++ ivc/tests/simple.rs | 40 ++++++++--------- kimchi-stubs/Cargo.toml | 6 +++ kimchi-stubs/src/arkworks/bigint_256.rs | 2 +- kimchi-stubs/src/arkworks/group_projective.rs | 4 +- kimchi-stubs/src/arkworks/pasta_fp.rs | 2 +- kimchi-stubs/src/arkworks/pasta_fq.rs | 2 +- kimchi-stubs/src/caml/caml_bytes_string.rs | 4 +- kimchi-stubs/src/caml/caml_pointer.rs | 2 +- kimchi/Cargo.toml | 3 ++ kimchi/src/circuits/berkeley_columns.rs | 2 +- kimchi/src/circuits/expr.rs | 2 +- kimchi/src/circuits/gate.rs | 2 +- .../circuits/polynomials/keccak/constants.rs | 1 - kimchi/src/circuits/serialization_helper.rs | 2 +- kimchi/src/circuits/witness/index_cell.rs | 2 +- .../circuits/witness/variable_bits_cell.rs | 2 +- kimchi/src/circuits/witness/variable_cell.rs | 2 +- msm/src/circuit_design/composition.rs | 44 ++++++++----------- msm/src/test/proof_system.rs | 1 - o1vm/src/interpreters/keccak/column.rs | 1 - o1vm/src/interpreters/keccak/interpreter.rs | 2 - o1vm/src/pickles/lookup_columns.rs | 2 +- o1vm/src/pickles/lookup_prover.rs | 1 - o1vm/src/pickles/main.rs | 19 +++++--- o1vm/src/test_preimage_read.rs | 5 ++- plonk-wasm/src/rayon.rs | 1 + plonk-wasm/src/wasm_ocaml_serde/de.rs | 2 +- poly-commitment/Cargo.toml | 3 ++ poly-commitment/src/commitment.rs | 4 +- poly-commitment/src/ipa.rs | 2 +- poly-commitment/src/utils.rs | 2 +- poly-commitment/tests/ipa_commitment.rs | 2 +- poseidon/Cargo.toml | 3 ++ rust-toolchain.toml | 2 +- saffron/src/utils.rs | 4 +- turshi/src/runner.rs | 4 +- utils/src/chunked_polynomial.rs | 2 +- utils/src/math.rs | 2 +- 43 files changed, 118 insertions(+), 95 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a4303d92371..68292999a3a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -28,6 +28,11 @@ members = [ ] resolver = "2" +# Ignore non-local impl warnings from OCaml derive macros in nested contexts +# See: https://github.com/o1-labs/proof-systems/issues/3319 +[workspace.lints.rust] +non_local_definitions = "allow" + [workspace.dependencies] ark-algebra-test-templates = "0.5" ark-bn254 = { version = "0.5" } diff --git a/arrabbiata/src/challenge.rs b/arrabbiata/src/challenge.rs index ddc9a35fc3f..cd9b4f8b684 100644 --- a/arrabbiata/src/challenge.rs +++ b/arrabbiata/src/challenge.rs @@ -142,6 +142,6 @@ impl Index for Challenges { } } -impl<'a> AlphaChallengeTerm<'a> for ChallengeTerm { +impl AlphaChallengeTerm<'_> for ChallengeTerm { const ALPHA: Self = Self::ConstraintCombiner; } diff --git a/curves/Cargo.toml b/curves/Cargo.toml index 3c06d1e8f41..dca7cd36051 100644 --- a/curves/Cargo.toml +++ b/curves/Cargo.toml @@ -9,6 +9,9 @@ readme = "../README.md" edition = "2021" license = "Apache-2.0" +[features] +asm = ["ark-ff/asm"] + [dependencies] ark-bn254.workspace = true ark-ec.workspace = true diff --git a/folding/src/eval_leaf.rs b/folding/src/eval_leaf.rs index c9adf39d8ca..3b1b553ff1d 100644 --- a/folding/src/eval_leaf.rs +++ b/folding/src/eval_leaf.rs @@ -6,7 +6,7 @@ pub enum EvalLeaf<'a, F> { Result(Vec), } -impl<'a, F: core::fmt::Display> core::fmt::Display for EvalLeaf<'a, F> { +impl core::fmt::Display for EvalLeaf<'_, F> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let slice = match self { EvalLeaf::Const(c) => { @@ -25,7 +25,7 @@ impl<'a, F: core::fmt::Display> core::fmt::Display for EvalLeaf<'a, F> { } } -impl<'a, F: core::ops::Add + Clone> core::ops::Add for EvalLeaf<'a, F> { +impl + Clone> core::ops::Add for EvalLeaf<'_, F> { type Output = Self; fn add(self, rhs: Self) -> Self { @@ -33,7 +33,7 @@ impl<'a, F: core::ops::Add + Clone> core::ops::Add for EvalLeaf<'a, } } -impl<'a, F: core::ops::Sub + Clone> core::ops::Sub for EvalLeaf<'a, F> { +impl + Clone> core::ops::Sub for EvalLeaf<'_, F> { type Output = Self; fn sub(self, rhs: Self) -> Self { @@ -41,7 +41,7 @@ impl<'a, F: core::ops::Sub + Clone> core::ops::Sub for EvalLeaf<'a, } } -impl<'a, F: core::ops::Mul + Clone> core::ops::Mul for EvalLeaf<'a, F> { +impl + Clone> core::ops::Mul for EvalLeaf<'_, F> { type Output = Self; fn mul(self, rhs: Self) -> Self { @@ -49,7 +49,7 @@ impl<'a, F: core::ops::Mul + Clone> core::ops::Mul for EvalLeaf<'a, } } -impl<'a, F: core::ops::Mul + Clone> core::ops::Mul for EvalLeaf<'a, F> { +impl + Clone> core::ops::Mul for EvalLeaf<'_, F> { type Output = Self; fn mul(self, rhs: F) -> Self { @@ -57,7 +57,7 @@ impl<'a, F: core::ops::Mul + Clone> core::ops::Mul for EvalLeaf<' } } -impl<'a, F: Clone> EvalLeaf<'a, F> { +impl EvalLeaf<'_, F> { pub fn map F, I: Fn(&mut F)>(self, map: M, in_place: I) -> Self { use EvalLeaf::*; match self { diff --git a/internal-tracing/Cargo.toml b/internal-tracing/Cargo.toml index bc3d848b97a..10d312c6e61 100644 --- a/internal-tracing/Cargo.toml +++ b/internal-tracing/Cargo.toml @@ -4,6 +4,9 @@ version = "0.1.0" edition = "2021" license = "Apache-2.0" +[lints] +workspace = true + [dependencies] ocaml = { workspace = true, optional = true } ocaml-gen = { workspace = true, optional = true } diff --git a/ivc/tests/simple.rs b/ivc/tests/simple.rs index 6d77deae31b..36425c6a4af 100644 --- a/ivc/tests/simple.rs +++ b/ivc/tests/simple.rs @@ -80,6 +80,26 @@ impl ColumnIndexer for AdditionColumn { } } +impl FoldingColumnTrait for AdditionColumn { + fn is_witness(&self) -> bool { + true + } +} + +impl Index + for PlonkishWitness +{ + type Output = [Fp]; + + fn index(&self, index: AdditionColumn) -> &Self::Output { + match index { + AdditionColumn::A => &self.witness.cols[0].evals, + AdditionColumn::B => &self.witness.cols[1].evals, + AdditionColumn::C => &self.witness.cols[2].evals, + } + } +} + /// Simply compute A + B - C pub fn interpreter_simple_add< F: PrimeField, @@ -153,12 +173,6 @@ pub fn heavy_test_simple_add() { // ---- Defining the folding configuration ---- // FoldingConfig - impl FoldingColumnTrait for AdditionColumn { - fn is_witness(&self) -> bool { - true - } - } - type AppWitnessBuilderEnv = WitnessBuilderEnv< Fp, AdditionColumn, @@ -169,20 +183,6 @@ pub fn heavy_test_simple_add() { DummyLookupTable, >; - impl Index - for PlonkishWitness - { - type Output = [Fp]; - - fn index(&self, index: AdditionColumn) -> &Self::Output { - match index { - AdditionColumn::A => &self.witness.cols[0].evals, - AdditionColumn::B => &self.witness.cols[1].evals, - AdditionColumn::C => &self.witness.cols[2].evals, - } - } - } - type Config< const N_COL_TOTAL: usize, const N_CHALS: usize, diff --git a/kimchi-stubs/Cargo.toml b/kimchi-stubs/Cargo.toml index e5ae3d69a54..d002526ff56 100644 --- a/kimchi-stubs/Cargo.toml +++ b/kimchi-stubs/Cargo.toml @@ -7,6 +7,9 @@ repository = "https://github.com/MinaProtocol/mina" license = "MIT/Apache-2.0" edition = "2021" +[lints] +workspace = true + [lib] name = "kimchi_stubs" # Important: do not ask to build a dynamic library. @@ -14,6 +17,9 @@ name = "kimchi_stubs" # On the Mina side, a fake and empty dllkimchi_stubs.so file is used. crate-type = ["lib", "staticlib"] +[features] +no-std = [] + [dependencies] libc.workspace = true num-bigint = { workspace = true, features = ["rand", "serde"] } diff --git a/kimchi-stubs/src/arkworks/bigint_256.rs b/kimchi-stubs/src/arkworks/bigint_256.rs index 8833a47333a..933b38e5c08 100644 --- a/kimchi-stubs/src/arkworks/bigint_256.rs +++ b/kimchi-stubs/src/arkworks/bigint_256.rs @@ -32,7 +32,7 @@ impl From for CamlBigInteger256 { } } -unsafe impl<'a> ocaml::FromValue<'a> for CamlBigInteger256 { +unsafe impl ocaml::FromValue<'_> for CamlBigInteger256 { fn from_value(value: ocaml::Value) -> Self { let x: ocaml::Pointer = ocaml::FromValue::from_value(value); *x.as_ref() diff --git a/kimchi-stubs/src/arkworks/group_projective.rs b/kimchi-stubs/src/arkworks/group_projective.rs index 39b7c02df16..e1fe9e29260 100644 --- a/kimchi-stubs/src/arkworks/group_projective.rs +++ b/kimchi-stubs/src/arkworks/group_projective.rs @@ -6,7 +6,7 @@ use mina_curves::pasta::curves::{pallas::ProjectivePallas, vesta::ProjectiveVest #[derive(Clone, Copy, ocaml_gen::CustomType)] pub struct CamlGroupProjectivePallas(pub ProjectivePallas); -unsafe impl<'a> ocaml::FromValue<'a> for CamlGroupProjectivePallas { +unsafe impl ocaml::FromValue<'_> for CamlGroupProjectivePallas { fn from_value(value: ocaml::Value) -> Self { let x: ocaml::Pointer = ocaml::FromValue::from_value(value); *x.as_ref() @@ -111,7 +111,7 @@ impl Neg for &CamlGroupProjectivePallas { #[derive(Clone, Copy, ocaml_gen::CustomType)] pub struct CamlGroupProjectiveVesta(pub ProjectiveVesta); -unsafe impl<'a> ocaml::FromValue<'a> for CamlGroupProjectiveVesta { +unsafe impl ocaml::FromValue<'_> for CamlGroupProjectiveVesta { fn from_value(value: ocaml::Value) -> Self { let x: ocaml::Pointer = ocaml::FromValue::from_value(value); *x.as_ref() diff --git a/kimchi-stubs/src/arkworks/pasta_fp.rs b/kimchi-stubs/src/arkworks/pasta_fp.rs index 3dca35984db..a0da5ca9903 100644 --- a/kimchi-stubs/src/arkworks/pasta_fp.rs +++ b/kimchi-stubs/src/arkworks/pasta_fp.rs @@ -17,7 +17,7 @@ use rand::rngs::StdRng; #[derive(Clone, Copy, Debug, ocaml_gen::CustomType)] pub struct CamlFp(pub Fp); -unsafe impl<'a> ocaml::FromValue<'a> for CamlFp { +unsafe impl ocaml::FromValue<'_> for CamlFp { fn from_value(value: ocaml::Value) -> Self { let x: ocaml::Pointer = ocaml::FromValue::from_value(value); *x.as_ref() diff --git a/kimchi-stubs/src/arkworks/pasta_fq.rs b/kimchi-stubs/src/arkworks/pasta_fq.rs index 3a816fae460..6a24594ba55 100644 --- a/kimchi-stubs/src/arkworks/pasta_fq.rs +++ b/kimchi-stubs/src/arkworks/pasta_fq.rs @@ -21,7 +21,7 @@ use rand::rngs::StdRng; #[derive(Clone, Copy, ocaml_gen::CustomType)] pub struct CamlFq(pub Fq); -unsafe impl<'a> ocaml::FromValue<'a> for CamlFq { +unsafe impl ocaml::FromValue<'_> for CamlFq { fn from_value(value: ocaml::Value) -> Self { let x: ocaml::Pointer = ocaml::FromValue::from_value(value); *x.as_ref() diff --git a/kimchi-stubs/src/caml/caml_bytes_string.rs b/kimchi-stubs/src/caml/caml_bytes_string.rs index 48964a05f65..c79d317058c 100644 --- a/kimchi-stubs/src/caml/caml_bytes_string.rs +++ b/kimchi-stubs/src/caml/caml_bytes_string.rs @@ -3,7 +3,7 @@ use ocaml_gen::{const_random, Env, OCamlDesc}; pub struct CamlBytesString<'a>(pub &'a [u8]); -unsafe impl<'a> IntoValue for CamlBytesString<'a> { +unsafe impl IntoValue for CamlBytesString<'_> { fn into_value(self, rt: &Runtime) -> Value { self.0.into_value(rt) } @@ -15,7 +15,7 @@ unsafe impl<'a> FromValue<'a> for CamlBytesString<'a> { } } -impl<'a> OCamlDesc for CamlBytesString<'a> { +impl OCamlDesc for CamlBytesString<'_> { fn ocaml_desc(_env: &Env, _generics: &[&str]) -> String { "string".to_string() } diff --git a/kimchi-stubs/src/caml/caml_pointer.rs b/kimchi-stubs/src/caml/caml_pointer.rs index b6a9af3dcda..eabb1c82732 100644 --- a/kimchi-stubs/src/caml/caml_pointer.rs +++ b/kimchi-stubs/src/caml/caml_pointer.rs @@ -23,7 +23,7 @@ macro_rules! impl_caml_pointer { compare: $name::caml_pointer_compare, }); - unsafe impl<'a> ocaml::FromValue<'a> for $name { + unsafe impl ocaml::FromValue<'_> for $name { fn from_value(x: ocaml::Value) -> Self { let x = ocaml::Pointer::::from_value(x); $name(x.as_ref().0.clone()) diff --git a/kimchi/Cargo.toml b/kimchi/Cargo.toml index 126ef673977..acf8a9e8d55 100644 --- a/kimchi/Cargo.toml +++ b/kimchi/Cargo.toml @@ -9,6 +9,9 @@ readme = "README.md" edition = "2021" license = "Apache-2.0" +[lints] +workspace = true + [lib] path = "src/lib.rs" bench = false # needed for criterion (https://bheisler.github.io/criterion.rs/book/faq.html#cargo-bench-gives-unrecognized-option-errors-for-valid-command-line-options) diff --git a/kimchi/src/circuits/berkeley_columns.rs b/kimchi/src/circuits/berkeley_columns.rs index edfc6dfed0e..ac68417ce3f 100644 --- a/kimchi/src/circuits/berkeley_columns.rs +++ b/kimchi/src/circuits/berkeley_columns.rs @@ -63,7 +63,7 @@ impl core::fmt::Display for BerkeleyChallengeTerm { } } -impl<'a> super::expr::AlphaChallengeTerm<'a> for BerkeleyChallengeTerm { +impl super::expr::AlphaChallengeTerm<'_> for BerkeleyChallengeTerm { const ALPHA: Self = Self::Alpha; } diff --git a/kimchi/src/circuits/expr.rs b/kimchi/src/circuits/expr.rs index 660241953a5..fc96efea458 100644 --- a/kimchi/src/circuits/expr.rs +++ b/kimchi/src/circuits/expr.rs @@ -1123,7 +1123,7 @@ fn unnormalized_lagrange_evals< /// Implement algebraic methods like `add`, `sub`, `mul`, `square`, etc to use /// algebra on the type `EvalResult`. -impl<'a, F: FftField> EvalResult<'a, F> { +impl EvalResult<'_, F> { /// Create an evaluation over the domain `res_domain`. /// The second parameter, `g`, is a function used to define the /// evaluations at a given point of the domain. diff --git a/kimchi/src/circuits/gate.rs b/kimchi/src/circuits/gate.rs index 01428491a52..8faf330d9d1 100644 --- a/kimchi/src/circuits/gate.rs +++ b/kimchi/src/circuits/gate.rs @@ -442,7 +442,7 @@ where } } -impl<'a, F: PrimeField> CryptoDigest for Circuit<'a, F> { +impl CryptoDigest for Circuit<'_, F> { const PREFIX: &'static [u8; 15] = b"kimchi-circuit0"; } diff --git a/kimchi/src/circuits/polynomials/keccak/constants.rs b/kimchi/src/circuits/polynomials/keccak/constants.rs index e8416cf2db0..5d3a3169b15 100644 --- a/kimchi/src/circuits/polynomials/keccak/constants.rs +++ b/kimchi/src/circuits/polynomials/keccak/constants.rs @@ -1,5 +1,4 @@ /// Constants for each witness' index offsets and lengths - // KECCAK PARAMETERS /// The dimension of the Keccak state pub const DIM: usize = 5; diff --git a/kimchi/src/circuits/serialization_helper.rs b/kimchi/src/circuits/serialization_helper.rs index 34b87ddb590..ea4ec7e6fe6 100644 --- a/kimchi/src/circuits/serialization_helper.rs +++ b/kimchi/src/circuits/serialization_helper.rs @@ -39,7 +39,7 @@ impl<'de, F, G: DeserializeAs<'de, F>> DeserializeAs<'de, JointLookupValue> ignore, } struct FieldVisitor; - impl<'de> serde::de::Visitor<'de> for FieldVisitor { + impl serde::de::Visitor<'_> for FieldVisitor { type Value = Field; fn expecting(&self, formatter: &mut Formatter) -> core::fmt::Result { Formatter::write_str(formatter, "field identifier") diff --git a/kimchi/src/circuits/witness/index_cell.rs b/kimchi/src/circuits/witness/index_cell.rs index fd2628a316c..2fe7c0ffd2e 100644 --- a/kimchi/src/circuits/witness/index_cell.rs +++ b/kimchi/src/circuits/witness/index_cell.rs @@ -18,7 +18,7 @@ impl<'a> IndexCell<'a> { } } -impl<'a, F: Field, const W: usize> WitnessCell, W> for IndexCell<'a> { +impl WitnessCell, W> for IndexCell<'_> { fn value(&self, _witness: &mut [Vec; W], variables: &Variables>, index: usize) -> F { assert!(index < self.length, "index out of bounds of `IndexCell`"); variables[self.name][index] diff --git a/kimchi/src/circuits/witness/variable_bits_cell.rs b/kimchi/src/circuits/witness/variable_bits_cell.rs index 584920592d5..d668ff0bfa8 100644 --- a/kimchi/src/circuits/witness/variable_bits_cell.rs +++ b/kimchi/src/circuits/witness/variable_bits_cell.rs @@ -18,7 +18,7 @@ impl<'a> VariableBitsCell<'a> { } } -impl<'a, F: Field, const W: usize> WitnessCell for VariableBitsCell<'a> { +impl WitnessCell for VariableBitsCell<'_> { fn value(&self, _witness: &mut [Vec; W], variables: &Variables, _index: usize) -> F { let bits = if let Some(end) = self.end { F::from_bits(&variables[self.name].to_bits()[self.start..end]) diff --git a/kimchi/src/circuits/witness/variable_cell.rs b/kimchi/src/circuits/witness/variable_cell.rs index fcb6ee9f210..40d826b3940 100644 --- a/kimchi/src/circuits/witness/variable_cell.rs +++ b/kimchi/src/circuits/witness/variable_cell.rs @@ -14,7 +14,7 @@ impl<'a> VariableCell<'a> { } } -impl<'a, F: Field, const W: usize> WitnessCell for VariableCell<'a> { +impl WitnessCell for VariableCell<'_> { fn value(&self, _witness: &mut [Vec; W], variables: &Variables, _index: usize) -> F { variables[self.name] } diff --git a/msm/src/circuit_design/composition.rs b/msm/src/circuit_design/composition.rs index c32d7dabf00..0e9876564e1 100644 --- a/msm/src/circuit_design/composition.rs +++ b/msm/src/circuit_design/composition.rs @@ -208,13 +208,12 @@ impl<'a, F: PrimeField, CIx1: ColumnIndexer, Env1: ColAccessCap, } impl< - 'a, F: PrimeField, CIx1: ColumnIndexer, CIx2: ColumnIndexer, Env1: ColAccessCap, L: MPrism, - > ColAccessCap for SubEnv<'a, F, CIx1, Env1, L> + > ColAccessCap for SubEnv<'_, F, CIx1, Env1, L> { type Variable = Env1::Variable; @@ -236,13 +235,12 @@ impl< } impl< - 'a, F: PrimeField, CIx1: ColumnIndexer, CIx2: ColumnIndexer, Env1: ColWriteCap, L: MPrism, - > ColWriteCap for SubEnv<'a, F, CIx1, Env1, L> + > ColWriteCap for SubEnv<'_, F, CIx1, Env1, L> { fn write_column(&mut self, ix: CIx2, value: &Self::Variable) { self.env.write_column(self.lens.re_get(ix), value) @@ -250,13 +248,12 @@ impl< } impl< - 'a, F: PrimeField, CIx1: ColumnIndexer, CIx2: ColumnIndexer, Env1: HybridCopyCap, L: MPrism, - > HybridCopyCap for SubEnv<'a, F, CIx1, Env1, L> + > HybridCopyCap for SubEnv<'_, F, CIx1, Env1, L> { fn hcopy(&mut self, x: &Self::Variable, ix: CIx2) -> Self::Variable { self.env.hcopy(x, self.lens.re_get(ix)) @@ -264,13 +261,12 @@ impl< } impl< - 'a, F: PrimeField, CIx1: ColumnIndexer, CIx2: ColumnIndexer, Env1: ColAccessCap, L: MPrism, - > ColAccessCap for SubEnvColumn<'a, F, CIx1, Env1, L> + > ColAccessCap for SubEnvColumn<'_, F, CIx1, Env1, L> { type Variable = Env1::Variable; @@ -292,13 +288,12 @@ impl< } impl< - 'a, F: PrimeField, CIx1: ColumnIndexer, CIx2: ColumnIndexer, Env1: ColWriteCap, L: MPrism, - > ColWriteCap for SubEnvColumn<'a, F, CIx1, Env1, L> + > ColWriteCap for SubEnvColumn<'_, F, CIx1, Env1, L> { fn write_column(&mut self, ix: CIx2, value: &Self::Variable) { self.0.write_column(ix, value); @@ -306,21 +301,20 @@ impl< } impl< - 'a, F: PrimeField, CIx1: ColumnIndexer, CIx2: ColumnIndexer, Env1: HybridCopyCap, L: MPrism, - > HybridCopyCap for SubEnvColumn<'a, F, CIx1, Env1, L> + > HybridCopyCap for SubEnvColumn<'_, F, CIx1, Env1, L> { fn hcopy(&mut self, x: &Self::Variable, ix: CIx2) -> Self::Variable { self.0.hcopy(x, ix) } } -impl<'a, F: PrimeField, CIx1: ColumnIndexer, Env1: ColAccessCap, L> - ColAccessCap for SubEnvLookup<'a, F, CIx1, Env1, L> +impl, Env1: ColAccessCap, L> + ColAccessCap for SubEnvLookup<'_, F, CIx1, Env1, L> { type Variable = Env1::Variable; @@ -341,16 +335,16 @@ impl<'a, F: PrimeField, CIx1: ColumnIndexer, Env1: ColAccessCap, } } -impl<'a, F: PrimeField, CIx1: ColumnIndexer, Env1: ColWriteCap, L> - ColWriteCap for SubEnvLookup<'a, F, CIx1, Env1, L> +impl, Env1: ColWriteCap, L> ColWriteCap + for SubEnvLookup<'_, F, CIx1, Env1, L> { fn write_column(&mut self, ix: CIx1, value: &Self::Variable) { self.0.env.write_column(ix, value); } } -impl<'a, F: PrimeField, CIx1: ColumnIndexer, Env1: HybridCopyCap, L> - HybridCopyCap for SubEnvLookup<'a, F, CIx1, Env1, L> +impl, Env1: HybridCopyCap, L> + HybridCopyCap for SubEnvLookup<'_, F, CIx1, Env1, L> { fn hcopy(&mut self, x: &Self::Variable, ix: CIx1) -> Self::Variable { self.0.env.hcopy(x, ix) @@ -358,14 +352,13 @@ impl<'a, F: PrimeField, CIx1: ColumnIndexer, Env1: HybridCopyCap } impl< - 'a, F: PrimeField, CIx: ColumnIndexer, LT1: LookupTableID, LT2: LookupTableID, Env1: LookupCap, L: MPrism, - > LookupCap for SubEnvLookup<'a, F, CIx, Env1, L> + > LookupCap for SubEnvLookup<'_, F, CIx, Env1, L> { fn lookup(&mut self, lookup_id: LT2, value: Vec) { self.0.env.lookup(self.0.lens.re_get(lookup_id), value) @@ -379,14 +372,13 @@ impl< } impl< - 'a, F: PrimeField, CIx1: ColumnIndexer, CIx2: ColumnIndexer, LT: LookupTableID, Env1: LookupCap, L: MPrism, - > LookupCap for SubEnvColumn<'a, F, CIx1, Env1, L> + > LookupCap for SubEnvColumn<'_, F, CIx1, Env1, L> { fn lookup(&mut self, lookup_id: LT, value: Vec) { self.0.env.lookup(lookup_id, value) @@ -397,8 +389,8 @@ impl< } } -impl<'a, F: PrimeField, CIx: ColumnIndexer, Env1: MultiRowReadCap, L> - MultiRowReadCap for SubEnvLookup<'a, F, CIx, Env1, L> +impl, Env1: MultiRowReadCap, L> + MultiRowReadCap for SubEnvLookup<'_, F, CIx, Env1, L> { /// Read value from a (row,column) position. fn read_row_column(&mut self, row: usize, col: CIx) -> Self::Variable { @@ -416,8 +408,8 @@ impl<'a, F: PrimeField, CIx: ColumnIndexer, Env1: MultiRowReadCap } } -impl<'a, F: PrimeField, CIx: ColumnIndexer, Env1: DirectWitnessCap, L> - DirectWitnessCap for SubEnvLookup<'a, F, CIx, Env1, L> +impl, Env1: DirectWitnessCap, L> + DirectWitnessCap for SubEnvLookup<'_, F, CIx, Env1, L> { fn variable_to_field(value: Self::Variable) -> F { Env1::variable_to_field(value) diff --git a/msm/src/test/proof_system.rs b/msm/src/test/proof_system.rs index 491109c56d6..8594d5f89fc 100644 --- a/msm/src/test/proof_system.rs +++ b/msm/src/test/proof_system.rs @@ -1,5 +1,4 @@ /// Tests for the proof system itself, targeting prover and verifier. - #[cfg(test)] mod tests { diff --git a/o1vm/src/interpreters/keccak/column.rs b/o1vm/src/interpreters/keccak/column.rs index d283039cb80..e69f2cb555d 100644 --- a/o1vm/src/interpreters/keccak/column.rs +++ b/o1vm/src/interpreters/keccak/column.rs @@ -357,7 +357,6 @@ impl From for usize { pub type KeccakWitness = Witness; /// IMPLEMENTATIONS FOR COLUMN ALIAS - impl Index for KeccakWitness { type Output = T; diff --git a/o1vm/src/interpreters/keccak/interpreter.rs b/o1vm/src/interpreters/keccak/interpreter.rs index b1e06e4596d..faa0ba25d65 100644 --- a/o1vm/src/interpreters/keccak/interpreter.rs +++ b/o1vm/src/interpreters/keccak/interpreter.rs @@ -654,7 +654,6 @@ where /////////////////////////// /// SELECTOR OPERATIONS /// /////////////////////////// - /// Returns a degree-2 variable that encodes whether the current step is a /// sponge (1 = yes) fn is_sponge(&self, step: Steps) -> Self::Variable { @@ -753,7 +752,6 @@ where ///////////////////////// /// COLUMN OPERATIONS /// ///////////////////////// - /// This function returns the composed sparse variable from shifts of any /// correct length: /// - When the length is 400, two index configurations are possible: diff --git a/o1vm/src/pickles/lookup_columns.rs b/o1vm/src/pickles/lookup_columns.rs index 08b3201a02f..34b9e110991 100644 --- a/o1vm/src/pickles/lookup_columns.rs +++ b/o1vm/src/pickles/lookup_columns.rs @@ -158,7 +158,7 @@ impl std::fmt::Display for LookupChallengeTerm { } } -impl<'a> AlphaChallengeTerm<'a> for LookupChallengeTerm { +impl AlphaChallengeTerm<'_> for LookupChallengeTerm { const ALPHA: Self = Self::Alpha; } diff --git a/o1vm/src/pickles/lookup_prover.rs b/o1vm/src/pickles/lookup_prover.rs index f5b7133ac71..7a3992a550c 100644 --- a/o1vm/src/pickles/lookup_prover.rs +++ b/o1vm/src/pickles/lookup_prover.rs @@ -15,7 +15,6 @@ use rand::{CryptoRng, RngCore}; /// This prover takes one Public Input and one Public Output /// It then proves that the sum 1/(beta + table) = PI - PO /// where the table term are term from fixed lookup or RAMLookup - pub fn lookup_prove< G: KimchiCurve, EFqSponge: FqSponge + Clone, diff --git a/o1vm/src/pickles/main.rs b/o1vm/src/pickles/main.rs index 113eda4f28e..e269a69ad69 100644 --- a/o1vm/src/pickles/main.rs +++ b/o1vm/src/pickles/main.rs @@ -83,24 +83,26 @@ pub fn cannon_main(args: cli::cannon::RunArgs) { }; // Initialize the environments - let mut mips_wit_env = match configuration.host.clone() { + let (mut mips_wit_env, child_process) = match configuration.host.clone() { Some(host) => { let mut po = PreImageOracle::create(host); - let _child = po.start(); - mips_witness::Env::>::create( + let child = po.start(); + let env = mips_witness::Env::>::create( cannon::PAGE_SIZE as usize, state, Box::new(po), - ) + ); + (env, Some(child)) } None => { debug!("No preimage oracle provided 🤞"); // warning: the null preimage oracle has no data and will crash the program if used - mips_witness::Env::>::create( + let env = mips_witness::Env::>::create( cannon::PAGE_SIZE as usize, state, Box::new(NullPreImageOracle), - ) + ); + (env, None) } }; @@ -170,6 +172,11 @@ pub fn cannon_main(args: cli::cannon::RunArgs) { pad(&mips_wit_env, &mut curr_proof_inputs, &mut rng); prove_and_verify(domain_fp, &srs, &constraints, curr_proof_inputs, &mut rng); } + + // Wait for child process to finish if it exists + if let Some(mut child) = child_process { + let _ = child.wait(); + } } fn prove_and_verify( diff --git a/o1vm/src/test_preimage_read.rs b/o1vm/src/test_preimage_read.rs index be351afda79..e90252eb53e 100644 --- a/o1vm/src/test_preimage_read.rs +++ b/o1vm/src/test_preimage_read.rs @@ -20,7 +20,7 @@ pub fn main(args: cli::cannon::RunArgs) -> ExitCode { if let Some(preimage_key_dir) = preimage_db_dir { let host_program = configuration.host.expect("No host program specified"); let mut po = PreImageOracle::create(host_program); - let _child = po.start(); + let mut child = po.start(); debug!("Let server start"); std::thread::sleep(std::time::Duration::from_secs(5)); @@ -69,6 +69,9 @@ pub fn main(args: cli::cannon::RunArgs) -> ExitCode { assert_eq!(expected, got); } + + // Wait for child process to finish + let _ = child.wait(); ExitCode::SUCCESS } else { error!("Unset command-line argument --preimage-db-dir. Cannot run test. Please set parameter and rerun."); diff --git a/plonk-wasm/src/rayon.rs b/plonk-wasm/src/rayon.rs index 5127f1e7262..d79f26b0f37 100644 --- a/plonk-wasm/src/rayon.rs +++ b/plonk-wasm/src/rayon.rs @@ -25,6 +25,7 @@ where OP: FnOnce() -> R + Send, R: Send, { + #[allow(static_mut_refs)] let pool = unsafe { THREAD_POOL.as_ref().unwrap() }; pool.install(op) } diff --git a/plonk-wasm/src/wasm_ocaml_serde/de.rs b/plonk-wasm/src/wasm_ocaml_serde/de.rs index e66b7d611db..f24f0edc9db 100644 --- a/plonk-wasm/src/wasm_ocaml_serde/de.rs +++ b/plonk-wasm/src/wasm_ocaml_serde/de.rs @@ -59,7 +59,7 @@ impl From for Deserializer { // Ideally this would be implemented for `JsValue` instead, but we can't because // of the orphan rule. -impl<'de> IntoDeserializer<'de, Error> for Deserializer { +impl IntoDeserializer<'_, Error> for Deserializer { type Deserializer = Self; fn into_deserializer(self) -> Self::Deserializer { diff --git a/poly-commitment/Cargo.toml b/poly-commitment/Cargo.toml index 09478e6897f..1e579f60f6a 100644 --- a/poly-commitment/Cargo.toml +++ b/poly-commitment/Cargo.toml @@ -9,6 +9,9 @@ readme = "../README.md" edition = "2021" license = "Apache-2.0" +[lints] +workspace = true + [dependencies] ark-ec.workspace = true ark-ff.workspace = true diff --git a/poly-commitment/src/commitment.rs b/poly-commitment/src/commitment.rs index 47b28e90dde..cb7e7ef308a 100644 --- a/poly-commitment/src/commitment.rs +++ b/poly-commitment/src/commitment.rs @@ -269,7 +269,7 @@ where } } -impl<'a, 'b, C: AffineRepr> Add<&'a PolyComm> for &'b PolyComm { +impl<'a, C: AffineRepr> Add<&'a PolyComm> for &PolyComm { type Output = PolyComm; fn add(self, other: &'a PolyComm) -> PolyComm { @@ -290,7 +290,7 @@ impl<'a, 'b, C: AffineRepr> Add<&'a PolyComm> for &'b PolyComm { } } -impl<'a, 'b, C: AffineRepr + Sub> Sub<&'a PolyComm> for &'b PolyComm { +impl<'a, C: AffineRepr + Sub> Sub<&'a PolyComm> for &PolyComm { type Output = PolyComm; fn sub(self, other: &'a PolyComm) -> PolyComm { diff --git a/poly-commitment/src/ipa.rs b/poly-commitment/src/ipa.rs index 62882175e84..b456268abd1 100644 --- a/poly-commitment/src/ipa.rs +++ b/poly-commitment/src/ipa.rs @@ -891,7 +891,7 @@ impl SRS { // polynomial commitments, we obtain a chunked commitment to the L_i // polynomials. let srs_size = self.g.len(); - let num_elems = (n + srs_size - 1) / srs_size; + let num_elems = n.div_ceil(srs_size); let mut chunks = Vec::with_capacity(num_elems); // For each chunk diff --git a/poly-commitment/src/utils.rs b/poly-commitment/src/utils.rs index 01237964438..544ea40ebfc 100644 --- a/poly-commitment/src/utils.rs +++ b/poly-commitment/src/utils.rs @@ -33,7 +33,7 @@ impl ScaledChunkedPolynomial { } } -impl<'a, F: Field> ScaledChunkedPolynomial { +impl ScaledChunkedPolynomial { /// Compute the resulting scaled polynomial. /// Example: /// Given the two polynomials `1 + 2X` and `3 + 4X`, and the scaling diff --git a/poly-commitment/tests/ipa_commitment.rs b/poly-commitment/tests/ipa_commitment.rs index a109b391b77..686c522d698 100644 --- a/poly-commitment/tests/ipa_commitment.rs +++ b/poly-commitment/tests/ipa_commitment.rs @@ -96,7 +96,7 @@ fn test_offset_chunked_lagrange_commitments() { srs.get_lagrange_basis(domain); // Is this even taken into account?... - let num_chunks = (domain.size() + srs.g.len() - 1) / srs.g.len(); + let num_chunks = domain.size().div_ceil(srs.g.len()); assert!(num_chunks == 2); let expected_lagrange_commitments: Vec<_> = (0..n) diff --git a/poseidon/Cargo.toml b/poseidon/Cargo.toml index 1f6fe10788c..853895eca8b 100644 --- a/poseidon/Cargo.toml +++ b/poseidon/Cargo.toml @@ -9,6 +9,9 @@ readme = "README.md" edition = "2021" license = "Apache-2.0" +[lints] +workspace = true + [lib] path = "src/lib.rs" diff --git a/rust-toolchain.toml b/rust-toolchain.toml index 4cef0b738ff..9db33c0e40d 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,2 +1,2 @@ [toolchain] -channel = "1.81" +channel = "1.84" diff --git a/saffron/src/utils.rs b/saffron/src/utils.rs index 7456d33257a..df23b6926ea 100644 --- a/saffron/src/utils.rs +++ b/saffron/src/utils.rs @@ -243,8 +243,8 @@ pub mod test_utils { pub fn min_encoding_chunks>(domain: &D, xs: &[u8]) -> usize { let m = encoding_size::(); let n = xs.len(); - let num_field_elems = (n + m - 1) / m; - (num_field_elems + domain.size() - 1) / domain.size() + let num_field_elems = n.div_ceil(m); + num_field_elems.div_ceil(domain.size()) } pub fn chunk_size_in_bytes>(domain: &D) -> usize { diff --git a/turshi/src/runner.rs b/turshi/src/runner.rs index fe7664ddb98..98d8337ebd3 100644 --- a/turshi/src/runner.rs +++ b/turshi/src/runner.rs @@ -259,7 +259,7 @@ pub struct CairoStep<'a, F> { pub vars: CairoContext, } -impl<'a, F: Field> CairoStep<'a, F> { +impl CairoStep<'_, F> { /// Creates a new Cairo execution step from a step index, a Cairo word, and current pointers pub fn new(mem: &mut CairoMemory, ptrs: CairoState) -> CairoStep { CairoStep { @@ -501,7 +501,7 @@ pub struct CairoProgram<'a, F> { pub trace: Vec>, } -impl<'a, F: Field> CairoProgram<'a, F> { +impl CairoProgram<'_, F> { /// Creates a Cairo execution from the public information (memory and initial pointers) pub fn new(mem: &mut CairoMemory, pc: u64) -> CairoProgram { let ap = mem.len(); diff --git a/utils/src/chunked_polynomial.rs b/utils/src/chunked_polynomial.rs index 86f64a6b3cf..7bc8a575c3c 100644 --- a/utils/src/chunked_polynomial.rs +++ b/utils/src/chunked_polynomial.rs @@ -42,7 +42,7 @@ impl ChunkedPolynomial { scale *= zeta_n; } - while coeffs.last().map_or(false, |c| c.is_zero()) { + while coeffs.last().is_some_and(|c| c.is_zero()) { coeffs.pop(); } diff --git a/utils/src/math.rs b/utils/src/math.rs index b7781fdccf4..7705fb4c346 100644 --- a/utils/src/math.rs +++ b/utils/src/math.rs @@ -19,5 +19,5 @@ pub fn ceil_log2(d: usize) -> usize { /// This function is bound to be stable soon. See pub fn div_ceil(a: usize, b: usize) -> usize { - (a + b - 1) / b + a.div_ceil(b) } From b34edf8ef3e554f15903c2e113f9baaf0787b3d8 Mon Sep 17 00:00:00 2001 From: Danny Willems Date: Mon, 18 Aug 2025 16:46:04 +0200 Subject: [PATCH 2/3] CI: update to include 1.84 for all platforms --- .github/workflows/ci.yml | 78 ++++++++++++++++------------------------ 1 file changed, 30 insertions(+), 48 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 35bb72efc62..49cdffd2af5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -32,7 +32,8 @@ jobs: outputs: ocaml_version: ${{ steps.ocaml.outputs.version }} node: ${{ steps.node.outputs.version }} - matrix: ${{ steps.matrix.outputs.value }} + rust_version: ${{ steps.rust.outputs.version }} + os: ${{ steps.os.outputs.version }} default_rust_version: ${{ steps.defaults.outputs.rust_version }} default_os: ${{ steps.defaults.outputs.os }} steps: @@ -43,32 +44,21 @@ jobs: run: echo 'version=["4.14.2"]' >> "$GITHUB_OUTPUT" - id: node run: echo 'version=["20"]' >> "$GITHUB_OUTPUT" + - id: rust + run: echo 'version=["1.81", "1.82", "1.84"]' >> "$GITHUB_OUTPUT" + - id: os + run: echo 'version=["ubuntu-latest", "ubuntu-24.04-arm", "macos-latest"]' >> "$GITHUB_OUTPUT" - id: defaults run: | echo 'rust_version=1.81' >> "$GITHUB_OUTPUT" echo 'os=ubuntu-latest' >> "$GITHUB_OUTPUT" - - id: matrix - run: | - # NOTE: This custom matrix configuration is needed to use Rust 1.84 specifically for macOS. - # When https://github.com/o1-labs/proof-systems/issues/3254 is fixed, - # this can be simplified to use a standard matrix configuration. - cat > matrix.json << 'EOF' - { - "include": [ - {"rust_toolchain_version": "1.81", "os": "ubuntu-latest"}, - {"rust_toolchain_version": "1.82", "os": "ubuntu-latest"}, - {"rust_toolchain_version": "1.81", "os": "ubuntu-24.04-arm"}, - {"rust_toolchain_version": "1.82", "os": "ubuntu-24.04-arm"}, - {"rust_toolchain_version": "1.84", "os": "macos-latest"} - ] - } - EOF - echo "value=$(cat matrix.json | jq -c .)" >> "$GITHUB_OUTPUT" refresh-cache: needs: ['define-matrix'] strategy: - matrix: ${{ fromJSON(needs.define-matrix.outputs.matrix) }} + matrix: + rust_toolchain_version: ${{ fromJSON(needs.define-matrix.outputs.rust_version) }} + os: ${{ fromJSON(needs.define-matrix.outputs.os) }} runs-on: ${{ matrix.os }} steps: # if 'workflow_run' @@ -78,7 +68,7 @@ jobs: - uses: ./.github/actions/toolchain-shared if: ${{ github.event_name == 'workflow_run' }} with: - rust_toolchain_version: ${{ matrix.rust_and_os.rust_toolchain_version }} + rust_toolchain_version: ${{ matrix.rust_toolchain_version }} - name: start-fresh if: ${{ github.event_name == 'workflow_run' }} shell: bash @@ -95,14 +85,11 @@ jobs: needs: ['define-matrix', 'refresh-cache'] strategy: matrix: - rust_and_os: ${{ fromJSON(needs.define-matrix.outputs.matrix).include }} + rust_toolchain_version: ${{ fromJSON(needs.define-matrix.outputs.rust_version) }} + os: ${{ fromJSON(needs.define-matrix.outputs.os) }} ocaml_version: ${{ fromJSON(needs.define-matrix.outputs.ocaml_version) }} node: ${{ fromJSON(needs.define-matrix.outputs.node) }} - exclude: - # Skip Rust 1.84 due to linting issues - remove when - # https://github.com/o1-labs/proof-systems/pull/3245 is fixed - - rust_and_os: {rust_toolchain_version: '1.84', os: 'macos-latest'} - runs-on: ${{ matrix.rust_and_os.os }} + runs-on: ${{ matrix.os }} steps: - name: Checkout repository uses: actions/checkout@v5 @@ -117,7 +104,7 @@ jobs: - name: Use shared Rust toolchain setting up steps uses: ./.github/actions/toolchain-shared with: - rust_toolchain_version: ${{ matrix.rust_and_os.rust_toolchain_version }} + rust_toolchain_version: ${{ matrix.rust_toolchain_version }} - name: Use shared OCaml setting up steps uses: ./.github/actions/ocaml-shared @@ -178,8 +165,8 @@ jobs: if: >- github.event_name == 'push' && github.ref == 'refs/heads/master' && - matrix.rust_and_os.rust_toolchain_version == needs.define-matrix.outputs.default_rust_version && - matrix.rust_and_os.os == needs.define-matrix.outputs.default_os + matrix.rust_toolchain_version == needs.define-matrix.outputs.default_rust_version && + matrix.os == needs.define-matrix.outputs.default_os run: | eval $(opam env) RUSTDOCFLAGS="--enable-index-page -Zunstable-options" cargo +nightly doc --all-features --no-deps --workspace --exclude xtask @@ -190,8 +177,8 @@ jobs: if: >- github.event_name == 'push' && github.ref == 'refs/heads/master' && - matrix.rust_and_os.rust_toolchain_version == needs.define-matrix.outputs.default_rust_version && - matrix.rust_and_os.os == needs.define-matrix.outputs.default_os + matrix.rust_toolchain_version == needs.define-matrix.outputs.default_rust_version && + matrix.os == needs.define-matrix.outputs.default_os with: github_token: ${{ secrets.GITHUB_TOKEN }} publish_dir: ./book/book/html @@ -200,14 +187,11 @@ jobs: needs: ['define-matrix', 'refresh-cache'] strategy: matrix: - rust_and_os: ${{ fromJSON(needs.define-matrix.outputs.matrix).include }} + rust_toolchain_version: ${{ fromJSON(needs.define-matrix.outputs.rust_version) }} + os: ${{ fromJSON(needs.define-matrix.outputs.os) }} ocaml_version: ${{ fromJSON(needs.define-matrix.outputs.ocaml_version) }} node: ${{ fromJSON(needs.define-matrix.outputs.node) }} - exclude: - # Skip Rust 1.84 due to linting issues - remove when - # https://github.com/o1-labs/proof-systems/pull/3245 is fixed - - rust_and_os: {rust_toolchain_version: '1.84', os: 'macos-latest'} - runs-on: ${{ matrix.rust_and_os.os }} + runs-on: ${{ matrix.os }} steps: - name: Checkout repository uses: actions/checkout@v5 @@ -217,7 +201,7 @@ jobs: - name: Use shared Rust toolchain setting up steps uses: ./.github/actions/toolchain-shared with: - rust_toolchain_version: ${{ matrix.rust_and_os.rust_toolchain_version }} + rust_toolchain_version: ${{ matrix.rust_toolchain_version }} - name: Use shared OCaml setting up steps uses: ./.github/actions/ocaml-shared @@ -236,10 +220,11 @@ jobs: needs: ['define-matrix', 'refresh-cache'] strategy: matrix: - rust_and_os: ${{ fromJSON(needs.define-matrix.outputs.matrix).include }} + rust_toolchain_version: ${{ fromJSON(needs.define-matrix.outputs.rust_version) }} + os: ${{ fromJSON(needs.define-matrix.outputs.os) }} ocaml_version: ${{ fromJSON(needs.define-matrix.outputs.ocaml_version) }} node: ${{ fromJSON(needs.define-matrix.outputs.node) }} - runs-on: ${{ matrix.rust_and_os.os }} + runs-on: ${{ matrix.os }} steps: - name: Checkout repository uses: actions/checkout@v5 @@ -249,7 +234,7 @@ jobs: - name: Use shared Rust toolchain setting up steps uses: ./.github/actions/toolchain-shared with: - rust_toolchain_version: ${{ matrix.rust_and_os.rust_toolchain_version }} + rust_toolchain_version: ${{ matrix.rust_toolchain_version }} - name: Use shared OCaml setting up steps uses: ./.github/actions/ocaml-shared @@ -268,14 +253,11 @@ jobs: needs: ['define-matrix', 'refresh-cache'] strategy: matrix: - rust_and_os: ${{ fromJSON(needs.define-matrix.outputs.matrix).include }} + rust_toolchain_version: ${{ fromJSON(needs.define-matrix.outputs.rust_version) }} + os: ${{ fromJSON(needs.define-matrix.outputs.os) }} ocaml_version: ${{ fromJSON(needs.define-matrix.outputs.ocaml_version) }} node: ${{ fromJSON(needs.define-matrix.outputs.node) }} - exclude: - # Skip Rust 1.84 due to linting issues - remove when - # https://github.com/o1-labs/proof-systems/pull/3245 is fixed - - rust_and_os: {rust_toolchain_version: '1.84', os: 'macos-latest'} - runs-on: ${{ matrix.rust_and_os.os }} + runs-on: ${{ matrix.os }} steps: - name: Checkout repository uses: actions/checkout@v5 @@ -285,7 +267,7 @@ jobs: - name: Use shared Rust toolchain setting up steps uses: ./.github/actions/toolchain-shared with: - rust_toolchain_version: ${{ matrix.rust_and_os.rust_toolchain_version }} + rust_toolchain_version: ${{ matrix.rust_toolchain_version }} components: llvm-tools-preview - name: Use shared OCaml setting up steps From f71b0c7308a03faed718e70be513259fcd94d1cc Mon Sep 17 00:00:00 2001 From: Danny Willems Date: Tue, 19 Aug 2025 08:19:22 +0200 Subject: [PATCH 3/3] CHANGELOG: add description for patch 3320 --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0d35078a39a..33150084e70 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - CI: add support for macos-latest with Rust 1.84 ([#3131](https://github.com/o1-labs/proof-systems/pull/3131)) +- CI: add support for 1.84 for all platforms, fixing linter for Rust 1.84, and + add missing build section for dylib on MacOS + ([#3320](https://github.com/o1-labs/proof-systems/pull/3320)) ### [arrabbiata](./arrabbiata)