Crate ark_scale

Arkworks serialization wrapped in Parity SCALE codec

ArkScale(T) can be serialized or deserialized using parity-scale-codec, provided T can be serialized or deserialized using ark-serialize.

Arkworks serializes via the std::io::{Read,Write} traits, or its no_std fork of those traits, as do other zcash sapling derivatives. At its core, Parity SCALE codec also consists of traits {Input,Output} analogous to std::io::{Read,Write} respectively, as well as traits {Decode,Encode} also quite similar to ark-serialize::{CanonicalDeserialize,CanonicalSerialize}. We simply translate between these extremely similar traits, including wrapping and unwrapping errors appropriately.

ArkScale cannot easily implement MaxEncodedLen or ConstEncodedLen from SCALE, due to the orphan rules. You’ll need these if using weights in Frame, so you should usually create wrapper types around ArkScale. As a rule, anytime you choose curves then you’ll have a conditionanl ark-substrate dependence anyways, so wrapper types should not become too onerous, and they likely improve documentation, errors, etc anyways.

ArkScale panics if serialization fails because SCALE does not propogate serialization failures. As scale outputs cannot fail, and ark-scale-derive does not introduce failures, we therefore cannot trigger this panic except by some explicit impl CanonicalSerialize for T intrpducing a failure. ArkScale users should therefore be responcible for reviewing non-derived CanonicalSerialize in their dependencies. In particular, there are no fresh failures in arkworks/algebra:

git clone https://github.com/arkworks-rs/algebra
cd algebra
grep -r --include '*.rs' 'CanonicalSerialize for' -A 10 ff* ec* poly/ | less

This becomes slightly harder if Implementable trait aliases lands.

Re-exports

• pub use ark_serialize;
• pub use scale_codec as scale;

Modules

• rw

Macros

• impl_body_max_encode_len
  Implement body of scale::MaxEncodedLen by delegation to ark_std::Zero and CanonicalSerialize, usable from polymorphic code.
• impl_decode_via_ark
  Implement body of scale::Decode by delegation to ArkScale, usable from polymorphic code.
• impl_encode_via_ark
  Implement body of scale::Encode by delegation to ArkScale, usable from polymorphic code.
• impl_scale_via_ark
  Implement scale::{Encode,Decode} by delegation to ArkScale, but lacks support for polymorphic code.

Structs

• ArkScale
  Arkworks type wrapped for serialization by Scale
• ArkScaleLen
  Arkworks type wrapped for serialization by Scale
• ArkScaleRef

Constants

• HOST_CALL
  ArkScale usage which neither compresses nor validates inputs, only for usage in host calls and on-chain storage where the runtime already performed validation checks.
• WIRE
  ArkScale usage for typical wire formats, like block data and gossip messages. Always safe.

Traits

• ArkScaleMaxEncodedLen
  An orphan rules helper which provides impl scale::MaxEncodedLen for ArkScale<T,WIRE>
• MaxEncodedLen
  Items implementing MaxEncodedLen have a statically known maximum encoded size.

Functions

• is_compressed
• is_validated
• iter_ark_to_ark_bytes
  Arkworks’ CanonicalSerialize cannot consume Iterators directly, but iter_ark_to_ark_bytes serializes exactly like Vec<T>, &'a [T], or [T] do with CanonicalSerialize.
• iter_ark_to_scale_bytes
  Arkworks’ CanonicalSerialize cannot consume Iterators directly, but iter_ark_to_scale_bytes serializes exactly like ArkScale(Vec<T>), ArkScale(&'a [T]), or ArkScale([T]) do under parity_scale_codec::Encode.
• make_usage
  Arkworks’ serialization modes hack.

Type Aliases

• Usage
  Arkworks’ serialization modes, morally (Compress, Validate) but const generics only supports integers, bool and char right now.

Derive Macros

• MaxEncodedLen
  Derive parity_scale_codec::MaxEncodedLen for struct and enum.