is `read_value_from_input` convoluted

[skaunov]

Is https://docs.rs/tasm-lib/latest/tasm_lib/data_type/enum.DataType.html#method.read_value_from_input quite misleading then? @jan-ferdinand

I mean will it then read just one word which I guess will the start of the encoding?

If I want to use the method for the following -- how do I do that?

        let to_be_call = DataType::StructRef(
            StructType{ name: "MmrAccumulator".into(), fields: vec!(
                ("leaf_count".into(), DataType::U64), ("peaks".into(), DataType::List(DataType::Digest.into()))
            ) }
        ).read_value_from_input(tasm_lib::io::InputSource::StdIn);

It seems to me that that method can only be used to read stack-based values (tuples, and primitive types like BFieldElement, Digest, u128 etc.).

Originally posted by @Sword-Smith in #163 (comment)

It looks to me as a refactoring candidate if the above is confirmed. Though I probably just missed a thing.

[Sword-Smith]

If I want to use the method for the following -- how do I do that?

I'd say you don't. If you want an MMR accumulator in memory, you initialize memory with it, such that it's there when you start program execution. If you want to prove that you're using a specific MMR accumulator, you hash it from memory (using bag_peaks) and verify that this hash matches the required hash.

I can't imagine a situation where you'd want to load an MMR accumulator from standard-in. Since values from standard-input are part of the claim, the verifier would need the whole MMR accumulator to verify the proof from this execution. Use non-deterministically initialized memory instead.

Maybe you're expecting too much from tasm-lib's type system? For example, in C,you cannot just do string_1 == string_2 since that will compare pointer values and not evaluate string equality. The "type system" in tasm-lib is mainly there to give type hints to the developer, not to provide tool that you might expect from high-level languages like Rust or C#.

Is your criticism that this method shouldn't exist? Maybe you're right then! Maybe calls to this method should just be replaced by its one-lined body input_source.read_words(self.stack_size()).

[skaunov]

I can't imagine a situation where you'd want to load an MMR accumulator from standard-in. Since values from standard-input are part of the claim, the verifier would need the whole MMR accumulator to verify the proof from this execution. Use non-deterministically initialized memory instead.

I thought there's usually no point to pay for succinctness when off-chain. I mean when it's public and doesn't end up on a chain then what's a problem to fetch the AOCL and feed it into a verifier?

And it would be easier for a prover as well: no need to commit to the starting memory state. Though I can imagine putting a public input into the memory can cost the same as commit it for a program start. (@Sword-Smith , How does it actually compares?)

[skaunov]

I'd like this to sound much more modest than criticism. I just wanted to say that the snippet I made works, but doesn't do what someone would expect from without delving too much. (If it does anything useful at all.) And I don't know what are best solutions to it. 🙌

[Sword-Smith]

I have the feeling that you have misunderstood something about Triton VM and that that is the cause for these questions.

no need to commit to the starting memory state

The prover does not need to cryptographically commit to the starting memory state. After all, the starting memory state is part of NonDetermism which the prover can pick to be whatever they want, without making any cryptographic commitment to it, other than what takes place in the TASM program.

I thought there's usually no point to pay for succinctness when off-chain. I mean when it's public and doesn't end up on a chain then what's a problem to fetch the AOCL and feed it into a verifier?

Maybe there isn't a problem with doing this? Not if you're not writing a consensus program at least. But if I was writing such a snippet I would

1. Initialize Triton VM with the required MMR accumulator in memory
2. Call bag_peaks with a pointer to the MMR struct
3. Read the correct MMR accumulator hash value from standard-in
4. Assert equality between the value read from standard-in and the result of bag_peaks
5. Prove whatever it is you want to prove about the MMR in memory.