A peer signs the multiset of call results and canon results it has produced.
New field signatures, a map from peer public key to signature, is added to the interpreter data.
Signatures verification is yet to be done.
* `ValueAggregate` refactoring
0. Service results, canon results and literals are constructed as
separate types that are further wrapped with `ValueAggregate`.
1. `ValueAggregate` is enum that contains all the provenance info.
2. Construction methods get provenance information as well.
* Rename CID state field
Prepare to adding a canon CID field: rename `canon_tracker`/`canon_store`
to `canon_element_tracker`/`canon_element_store`.
* Add canon result store/tracker
* Rename some structs that have CIDs inside
Reflect explicitly that they contain CIDs inside:
`CanonResultAggregate` -> `CanonResultCidAggregate`
`ServiceResultAggregate` -> `ServiceResultCidAggregate`
---------
Co-authored-by: Mike Voronov <michail.vms@gmail.com>
* fix(air): Fold-over-scalar values had wrong lambda
Previously, iterator values in fold over scalar inherited tetraplet from
the scalar. But for security guarantees, they should have `.[N]` lambda
added, where N is an element index.
When fold iterates over canon or stream, elements keep their original
tetraplet; tests for that is added.
BREAKING CHANGE:
1. Call values in the trace have CID references to structures that have call arguments' hash and CID references to values and tetraplets.
2. If call value is unused, it is serialized with `Unused` variant, and CID references are not stored.
Previous data scheme was (Scalar as an example, other cases are similar):
```
Scalar(CID<JValue>) ---<value_store>----> JValue
```
New data scheme is much more sophisticated:
```
Scalar(CID<ServiceResultAggregate>) ---+
|
+----<service_result_store>----------+
|
+-------> ServiceResultAggregate:
value_cid ------------<value_store>----> JValue
tetraplet_cid --------<tetraplet_store>----> SecurityTetraplet
argument_hash: String
```
`Stream` variant is similar, however, `Unused` is different: it has value CID only, but the value is not stored into the `value_store`:
```
Unused(Rc<CID<JValue>>) ---> X
```
Co-authored-by: Mike Voronov <michail.vms@gmail.com>
* feat(tools): merge some tools into the `air` CLI tool
`air-beautify` and `air-trace` are merged into a single `air` tool. Its
crate name is `fluence-air-cli` as otherwise it confilicts with `air`
interpreter crate. The tool has subcommands `beautify`, `run`
and `stats`.
* Add one-letter aliases to `air` CLI subcommands
+ `air beautify` => `air b`
+ `air run` => `air r`
+ `air stats` => `air s`
---------
Co-authored-by: Mike Voronov <michail.vms@gmail.com>
Remove `UncatchableError::ApResultNotCorrespondToInstr`
This transformation is valid only if `MergerApResult` has only two
variants mentioned in previos version.
Co-authored-by: Ivan Boldyrev <ivan@fluence.one>
chore(execution-engine): Some stream-related LambdaError are unjoinable b/c: canon stream replaces normal stream, when canon stream is used, it is materialized and its size is known
fold over a stream was not convergent when errors are produced inside a fold body. After iteration, it produces if there were several errors, only the last one is bubbled up. But on the same peer, there could different last (and first) errors, and it'll become non-convergent and moreover non-deterministic.
After this PR fold won't bubble any errors to make execution convergent and deterministic. To obtain errors from a fold body one should wrap this body into xor and push errors into some stream. Then fold over this stream and handle errors.
* Use CID values for tetraplets and `canon` vectors.
* Rename `cid_store` to `value_store`
It is consistent with the new `tetraplet_store` and `canon_store`
fields.
* Make canon data more typeful
The `CanonResult` doesn't take a JSON value anymore that is further
deserialized elsewhere, but is a struct that has all data deserialized.
* Typeful `CID` type
The `CID` type has a phantom type paramter defining its value's type.
* Group cid stores and trackers
Group cid stores into `CidInfo` struct, and trackers into `ExecutionCidState` struct.
This PR intended to reduce stream usage scope in order to make AquaVM truly deterministic.
Refs: #297.
Co-authored-by: Ivan Boldyrev <ivan@fluence.one>
Co-authored-by: Anatoly Laskaris <github_me@nahsi.dev>
The current peer ID is passed as a new field of `TestRunParameters` named
`current_peer_id: String`, instead of creating an AVM with peer ID.
This is a breaking API change of `avm-interface` and `avm-server`.
1. Network can be shared between several execution, being used by an Rc-handle.
2. The neighborhood is just network's all peers with removed/inserted hosts delta with respect to network.
3. An AIR script is transformed into a separate value of type `TransformedAirScript`. It allows running several
particles on the same parsed AIR script, sharing state.
4. `TestExecutor` was renamed to `AirScriptExecutor`. It also has a constructor that accepts a `TransformedAirScript`.
* seq_result` -> `seq_ok`; add `seq_err`
`seq_ok` and `seq_err` are consistent with `ok` and `err`, but produce
results sequentially.
* Accept `;;` and longer comments in the sexp parser
Currently they are just dropped, and resulting AIR has different
character positions in the error messages.
* Add "map" assertion
Lookup result in a map by service's first argument.
Validator checks that stream used in `canon` is populated by a value in a supplied script. This PR removes this check, because it's useful for code generation.
At the moment `Ap` state contains vector of generations, although the ap instruction itself allow to specify only one stream. It was done to support several streams in a result position in a future. But the current realization allows to handle empty vector that was implemented to support states for scalars and it turned out (for more info see #326) that states for scalars aren't actually needed.
Closes#355.
This PR refactors call merger of `TraceHandler`. Previously it requires `CallOutputValue` to determine a type of call output value (stream or scalar). And internally it checked correspondence between data result and call output type and return a error if they are not equal. Although execution engine component also had a match over these values and does nothing if they are not matched since `TraceHandler` did this job. This PR eliminate such behaviour and improve isolation of AquaVM modules.
feat(execution-engine): change behaviour of fold over streams
Change behaviour of fold over streams to make it more similar to pi-calculus channels/names (for more info see #333).
Closes#333.
BREAKING CHANGE:
The new stream behaviour is not compatible with old one, such as
```
(fold $stream iterator
(seq
(call ...)
(next iterator)))
```
will never end after this change (for more info again see #333).
Testing framework for AquaVM
Its primary features are:
1. It generates services declaratively by annotation in the comments inserted just after calls.
2. Ephemeral network keeps each node's data and incoming data queue. The network can be also generated based on peer IDs featured in the script.
3. One can explicitly add additional peers and services.
The example of the script annotations:
```
(seq
(call "peer_1" ("service" "func") [] var) ; ok=42
(call "peer_2" ("service" "func") [var]) ; err={"ret_code": 1, "result":"no towel"}
)
```
Passing this script to `air_test_framework::TestExecutor::new(...)` will create a virtual network with peers "peer_1" and "peer_2" (and any peer you provide in the `TestRunParameters`), and the particular calls will return respective values.
Please note that autogenerated services use modified service name as a side channel for finding a correct value: "..{N}" is added to each service name (two dots and serial number). Be careful with service names taken from a variable.
