strict-types/strict-encoding

Protobufs for functional programming

Strict encoding

Protobufs for functional programming

This is a set of libraries for deterministic binary serialization using strict types – type system made with category theory which ensures provable properties and bounds for the in-memory and serialized type representation.

The development of the libraries is performed by UBIDECO Institute.

Overview

Strict types is a formal notation for defining and serializing generalized algebraic data types (GADT) in a deterministic and confined way. It is developed with type theory in mind.

Strict Types are:

• schema-based (with the schema being strict encoding notation),
• semantic, i.e. defines types not just as they are layed out in memory, but also depending on their meaning,
• deterministic, i.e. produces the same result for a given type,
• portabile, i.e. can run on ahy hardware architecture and OS, including low-performant embedded systems,
• confined, i.e. provides guarantees and static analysis on a maximum size of the typed data,
• formally verifiable.

Strict Encoding is set of libraries for serializing / deserializing data types in binary formats.

Libraries

Language	Source code	Package
Rust	./rust
Python	Planned	n/a
TypeScript	Planned	n/a
Swift	Planned	n/a
Kotlin	Planned	n/a

Contributing

CONTRIBUTING.md

License

The libraries are distributed on the terms of Apache 2.0 license.

strict-encoding's Issues

Use `e: &mut E` instead of `mut e: E` encoder/decoder arguments

This reduces boilerplate in method implementation and avoids rust compiler crashes due to recursions in generic resolution

Downgrade Ascii to Std library from embedded types

Add strict_check method to StrictDecode

For checking internal data consistency upon decoding operation

impl<const VERSION: u8> StrictDecode for ___ {
  fn strict_check(&self) -> Result<(), DecodeError> {
    // ...
  }
}

The method should have a default implementation which should not error.

Derive strict_check

Allow deriving custom strict_check via providing a method to call.

Add #[strict_encoding(with_confined)] field-level macro

TLV must be present only in top-level structures

TLV stream has to be the last data item in any message. This wouldn't be the case if a message has fields which are in turn structures with TLV fields, as was discovered by @crisdut in LNP-WG/lnp-node#66

Derive macro has somehow to prevent that from happening (not clear how though...).

Implement AsRef<str> on identity string types

InvalidChar may be confusing in some instances

The InvalidRString::InvalidChar error contains the character that has been found to be invalid, but it may not match the character in the original string.

As an example, trying to issue an asset using a Unicode character in the ticker or name trigger this issue.

More specifically, issuing a NIA asset with name name with ℧nicode characters throws the error:

string 'name with ℧nicode characters' contains invalid character 'â'

This probably happens because the string is parsed 1 byte at a time and the 1st byte of the Unicode character happens to correspond to the â ASCII character, and this may lead do confusion.

Since the invalid character cannot be correctly interpreted in some cases, it may be better to omit it and just report the string that failed, or report the position of the invalid character in the string (which I think should always be correct) instead of its ASCII representation.

Large int types are displayed in invalid way

For instance u256 is replaced with U16

Inherit all encodings from confined_encoding

• Introduce strategy::AsConfined
• Implement it for all types which has confined encoding

Move network address uniform encoding (LNPBP-47) to a crate in internet2 repo

Add type system reflection

`--no-default-features` on `strict-encoding` not taking effect

Here is the output of cargo build -p strict_encoding -v --no-default-features:

rustc --crate-name strict_encoding --edition=2021 rust/src/lib.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --diagnostic-width=181 --crate-type lib --emit=dep-info,metadata,link -C embed-bitcode=no -C split-debuginfo=unpacked -C debuginfo=2 --cfg 'feature="default"' --cfg 'feature="derive"' --cfg 'feature="strict_encoding_derive"' -C metadata=e188277cae2a4737 -C extra-filename=-e188277cae2a4737 --out-dir /Users/yudaikiyofuji/IdeaProjects/strict-encoding/target/debug/deps -C incremental=/Users/yudaikiyofuji/IdeaProjects/strict-encoding/target/debug/incremental -L dependency=/Users/yudaikiyofuji/IdeaProjects/strict-encoding/target/debug/deps --extern amplify=/Users/yudaikiyofuji/IdeaProjects/strict-encoding/target/debug/deps/libamplify-be50d4e6df4ec592.rmeta --extern strict_encoding_derive=/Users/yudaikiyofuji/IdeaProjects/strict-encoding/target/debug/deps/libstrict_encoding_derive-627116894db1dd46.dylib

You can see the feature default is unexpectedly activated. This is likely because we have a dev-dependency strict_encoding_test which is circularly dependent on strict-encoding.

Use Box<&dyn Error> in `Error::DataIntegrityError` type

Fix Variant PartialEq implementation

Provide manual PartialEq implementation which ensures that both tag and name for all variants are distinct