* limit the number of StatementTmpl in CustomPredicate:
- add constructor method for CustomPredicate
- make size checks at the CustomPredicate creation, so that once instantiated we can assume that contains valid data
This resolves#79
* Update tests to use new interface
---------
Co-authored-by: Ahmad <root@ahmadafuni.com>
* Organize docs: front and back end; custom predicates.
* Whoops forgot to hit save before git commit last time -- delete stuff moved out of values.md
* Update book/src/values.md
---------
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
At the middleware we were defining some types that actually are dependant on the
backend no matter how we define them in the middleware.
For example, we were hardcoding the `Hash` and `Value` types and their related
behaviour (eg. `.to_fields()`) to be based on the length of 4 field elements,
but that's not a choice of the middleware, and in fact this is determined by the
backend itself. On the same time, those types and related methods do not belong
to the backend, since conceptually they are part of the middleware reasoning.
The intention of this PR is not to prematurely abstract the library, but to
avoid inconsistencies where a type or parameter is defined in the middleware to
have certain carachteristic and later in the backend it gets used differently.
The idea is that those types and parameters (eg. lengths) have a single source
of truth in the code; and in the case of the "base types" (hash, value, etc)
this is determined by the backend being used under the hood, not by a choice of
the middleware parameters.
The idea with this approach, is that the frontend & middleware should not need
to import the proving library used by the backend (eg. plonky2, plonky3, etc).
As mentioned earlier, the `Hash` and `Value` types are types belonging at the
middleware, and is the middleware who reasons about them, but depending on the
backend being used, the `Hash` and `Value` types will have different sizes. So
it's the backend being used who actually defines their nature under the hood.
For example with a plonky2 backend, these types will have a length of 4 field
elements, whereas with a plonky3 backend they will have a length of 8 field
eleements.
Note that his approach does not introduce new traits or abstract code, just
makes use of rust features to define 'base types' that are being used in the
middleware.
* Print pods from SignedPodBuilder
* Add additional print to test printing SignedPodBuilder
* Mock-prove and print MainPod
* Implement ToFields for custom predicates and dependencies
* Test: print serialization of a recursive batch
* Rearrange serialization of CustomPredicate so args_len is always in the same position
* Serialize predicates with first entry nonzero to avoid collision with padding
* Off by one error in ethdos test BatchSelf(2)
* cargo fmt
* not a typo
* Typos, trying again
* add comments detailing logic, migrate middleware::custom::tests to frontend::custom
* simplify custom predicate's frontend interfaces, making it less verbose to define Statement Template arguments
The main idea is that when defining the arguments at a statement
template, it can be done from 3 different inputs:
i. `(&str, literal)`: this is to set a POD and a field, ie. `(POD, literal("field")`)
ii. `(&str, &str)`: this is to define a origin-key wildcard pair, ie. `(src_origin, src_dest)`
iii. `Value`: this is to define a literal value, ie. `0`
* Merge changes to docs
* Fix typo
* Correct SUMMARY so it compiles; update .gitignore
* Clean up statements.md
Make syntax and notation consistent with Rust source code.
* Fix statements for Merkle trees and compound types
* First draft of custom statements and small updates to signedpod.md
* Update book/src/merkletree.md
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
* merklestatements correct typo
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
* add todo for gadget ids
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
* Separate out custom statements version 1
* More details on custom statements version 1
* new file custom2
* Partial draft of version 2
* First draft of version 2 spec, it's kind of a mess
* Another version of the custom predicates spec
* Update book/src/custom2.md
Co-authored-by: Eduard S. <eduardsanou@posteo.net>
* Simple example of deduction rule applied in circuit
* Implement Edu's comments on custom predicates
* Backend predicates must be defined in groups
* Add more examples
* Two diff statements using same constant
* Remove deprecated example
---------
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
Co-authored-by: Eduard S. <eduardsanou@posteo.net>
* wip
* prototype custom predicates 1b
* feat: implement custom pred recursion
* files reorg, add github CI for rustfmt checks
* start sparsemerkletree. impl add_leaf method, initial Leaf & Intermediate types with methods
* mt: add hash computation of all the nodes in the tree, add method to print the tree to visualize it as a graphviz
* mt: add (till the leaf) method which is used by get,contains,prove methods
* mt: add verify (of inclusion) method
* mt: update 'down' method to reuse siblings, update get,contains,prove methods (the three use 'down' under the hood)
* Add nonexistence proofs and iterator
* Add iterator test
* migrate usage of old merkletree to the new merkletree impl in POD2 code
---------
Co-authored-by: Eduard S. <eduardsanou@posteo.net>
Co-authored-by: Ahmad <root@ahmadafuni.com>
* Experiment with statement & op enums
* Clean-up & fixes
* More clean-up
* Add argument length checks
* More clean-up
* Place statement and operation logic in submodules
* Implement Containers (Dictionary,Set,Array) on top of MerkleTree. And restructure the code.
- Reorganize the code grouping backends, middleware, frontend, (crypto) primitives.
- Add types Dictionary,Set,Array at the middleware layer, so that
it can be used both by the backend and frontend. The Dictionary, Set,
Array use the merkletree differently as specified at
f2575d1524/book/src/values.md (dictionary-array-set)
- The containers introduce the trait Container, which has the
method 'cm()'. At the current version this uses a merkletree
under the hood, and the method 'cm' returns the merkle root.
- Ideally neither frontend nor backend use the MerkleTree type, and they
use the wrappers {Dictionary,Set,Array}. Note that the current commit
the MerkleTree is used at the mock-backend to check internal values, but
not at the struct types.
- updated the spec's merkletree section updating the defined interface
- add github ci to run the tests
---------
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
Co-authored-by: Eduard S. <eduardsanou@posteo.net>
* Progress towards mock MainPod verification
* add MockMainPod.pub_statements logic so that when originid==SELF it is replaced by self.id()
* Basic op checking for mock MainPOD
* More op checking
* wip
* feat: add great boy example
* feat: put examples under cfg(test)
---------
Co-authored-by: Ahmad <root@ahmadafuni.com>
Co-authored-by: arnaucube <git@arnaucube.com>
* Progress towards mock MainPod verification
* add MockMainPod.pub_statements logic so that when originid==SELF it is replaced by self.id()
* Basic op checking for mock MainPOD
* More op checking
* Add TODO notes
---------
Co-authored-by: arnaucube <git@arnaucube.com>
* Merge changes to docs
* Fix typo
* Correct SUMMARY so it compiles; update .gitignore
* Clean up statements.md
Make syntax and notation consistent with Rust source code.
* Fix statements for Merkle trees and compound types
* First draft of custom statements and small updates to signedpod.md
* Update book/src/merkletree.md
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
* merklestatements correct typo
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
* add todo for gadget ids
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
* Remove custom statements, will do on separate branch
* Restore Merkle examples and statements table
---------
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
Reasoning: till now we're only compiling it when the changes land at the
`main` branch, which allows invalid changes to the mdbook to pass the PR
check. With the update at this commit we ensure that the new PRs pass
the mdbook compilation check.
Migrate fmt to use Display trait to simplify the usage of it.
Also with this, in the same snipped of code we can print types from
backend, middleware and frontend; which before needed to import the two
different `Printer` structs (frontend::Printer and mock_main::Printer).
Before:
```
let printer = mock_main::Printer { skip_none: false };
let mut w = io::stdout();
printer.fmt_mock_main_pod(&mut w, &pod).unwrap();
let printer = frontend::Printer { skip_none: false };
printer.fmt_main_pod_builder(&mut w, &pod_builder).unwrap();
```
now:
```
println!("{:#}", pod);
println!("{:#}", pod_builder);
```
And the equivalent to the old `skip_none: true`, now is done by just
using `println!("{}", pod);
* compute MainPod.id from pub_statements; and introduce the trait `ToFields`
Compute MainPod.id from pub_statements hash; for it, introduce the trait
`ToFields` at the middleware and implement it for the Statement related
types.
* cleaner statements tofield iter
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
---------
Co-authored-by: Ahmad Afuni <root@ahmadafuni.com>
Extend merkletree spec, init SignedPod section, add typos checker in CI
- extend merkletree spec, converting old hand-drawn diagrams to drawio
diagrams, and adding new diagrams (related: #6)
- init SignedPod section (related: #2)
- initial draft of the types dictionary, set, array (related: #26)
- add typos checker in CI (and correct the ones that were detected)
Note on drawio diagrams: each image file contains the metadata to edit the diagram in the draw.io website.
- Add SignerPod.id computation (integrate kvs with MerkleTree).
- Updates frontend::SignerPod to be a wrapper on top of
backend::SignerPod with extra metadata (a keymap between hashes and
their strings).
- Get's rid of SignerPod.compile() since now the frontend::SignerPod
uses the method `::new()` which internally calls
backend::SignerPod::new which constructs the merkletree to use it's root
as PodID.
Add initial MerkleTree implementation, which is a wrapper on top of
Plonky2's MerkleTree, with the idea that the future iteration will
replace it by the MerkleTree specified at
https://0xparc.github.io/pod2/merkletree.html .
