willemolding

null;
var Module = typeof Module !== "undefined" ? Module : {};
var moduleOverrides = {};
var key;
for (key in Module) {
  if (Module.hasOwnProperty(key)) {
    moduleOverrides[key] = Module[key];
  }
}
var arguments_ = [];

willemolding

Hey, I'm willemolding-6880154 and I have contributed to the Citrea Risc0 to BitVM Circuit MPC Phase2 Trusted Setup ceremony.
The following are my contribution signatures:

Circuit # 1 (verify_for_guest)
Contributor # 13
Contribution Hash: fc0ea637 a3064b9b 2e787836 d03a4d33
		441a1049 c0ee503d b2bad3d1 829347da
		b4f9833f 4237aca7 6c21c2a4 5c854caf
		dce8b9f5 50e6649c a1ce18ff 26408690

willemolding

Hey, I'm willemolding-6880154 and I have contributed to the RISC Zero STARK-to-SNARK Prover MPC Phase2 Trusted Setup ceremony.
The following are my contribution signatures:

Circuit # 1 (stark_verify)
Contributor # 71
Contribution Hash: 5950eda2 565207cd afcd21ba a33e4375
		2ba6c9aa a4709e74 4bd94c5f 547a9542
		b21e058b f95a7d65 a0ac88aa d0ba2f85
		4cfb63fc f50ae185 fefb485b 39a52173

willemolding

Keybase proof

I hereby claim:

• I am willemolding on github.
• I am willemolding (https://keybase.io/willemolding) on keybase.
• I have a public key ASBMQvdXACpvkHS6WV6NcL_q9v_qWILp3wRJAftGWzLAdAo

To claim this, I am signing this object:

willemolding

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct SimplePartialType {
    first: u8,
    second: Value,
    third: bool,
}

let mut de = Deserializer::from_reader_with_layout(example.as_slice(), &rule);
let result: SimplePartialType = Deserialize::deserialize(&mut de).unwrap();

willemolding

const SIMPLE_RULE: &str = r#"
[
  "Record",
  [
    { "field_name": "first", "field_rule": ["Int"] },
    { "field_name": "second", "field_rule": ["Record", [{ "field_name": "inner", "field_rule": ["Bool"] }] ] },
    { "field_name": "third", "field_rule": ["Bool"] }
  ]
]
"#;

willemolding

impl<'de, 'a, R: Read> de::Deserializer<'de> for &'a mut Deserializer<R> {
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        match self.layout_iter.next() {
            Some(rule) => {
                match rule {
                    BinProtRule::Unit => {
                        self.rdr.bin_read_unit()?;

willemolding

pub struct Deserializer<R: Read> {
    pub rdr: BufReader<R>,
    pub layout_iter: BinProtRuleIterator,
}

impl<R: Read> Deserializer<R> {
    pub fn from_reader_with_layout(rdr: R, layout: &BinProtRule) -> Self {
        Self {
            rdr: BufReader::new(rdr),
            layout_iter: layout.into_iter(),

willemolding

pub enum Value {
    Unit,
    Nat0(u32),
    Bool(bool),
    String(Vec<u8>),
    Char(u8),
    Int(i64),
    Float(f64),
    Option(Option<Box<Value>>),
    Record(Vec<(String, Value)>),

willemolding

[
  "Record",
  [
    { "field_name": "first", "field_rule": ["Int"] },
    { "field_name": "second", "field_rule": [
        "Record", [{ "field_name": "inner", "field_rule": ["Bool"] }] 
    ]},
    { "field_name": "third", "field_rule": [
      "Sum",
      [