DA compression for fuel-tx types

CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- [#670](https://github.com/FuelLabs/fuel-vm/pull/670): Add DA compression functionality to `Transaction` and any types within
+
+### Changed
+
+#### Breaking
+
+- [#670](https://github.com/FuelLabs/fuel-vm/pull/670): The `predicate` field of `fuel_tx::input::Coin` is now a wrapper struct `PredicateCode`.
+
 ## [Version 0.56.0]
 
 ### Added

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
     "fuel-asm",
+    "fuel-compression",
     "fuel-crypto",
     "fuel-merkle",
     "fuel-storage",
@@ -22,6 +23,7 @@ version = "0.56.0"
 [workspace.dependencies]
 fuel-asm = { version = "0.56.0", path = "fuel-asm", default-features = false }
 fuel-crypto = { version = "0.56.0", path = "fuel-crypto", default-features = false }
+fuel-compression = { version = "0.56.0", path = "fuel-compression", default-features = false }
 fuel-derive = { version = "0.56.0", path = "fuel-derive", default-features = false }
 fuel-merkle = { version = "0.56.0", path = "fuel-merkle", default-features = false }
 fuel-storage = { version = "0.56.0", path = "fuel-storage", default-features = false }

README.md

@@ -13,6 +13,7 @@ and [the Sway compiler](https://github.com/FuelLabs/sway/).
 | Crate        | Version                                                                                             | Description                                                                                                                                                                                                                        | 
 |--------------|-----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| 
 | fuel-asm     | [![crates.io](https://img.shields.io/crates/v/fuel-asm)](https://crates.io/crates/fuel-asm)         | Contains the FuelVM instruction set - opcodes used by the Sway and VM.                                                                                                                                                             | 
+| fuel-compression | [![crates.io](https://img.shields.io/crates/v/fuel-compression)](https://crates.io/crates/fuel-compression)   | DA-layer compression of Fuel transaction types | 
 | fuel-crypto  | [![crates.io](https://img.shields.io/crates/v/fuel-crypto)](https://crates.io/crates/fuel-crypto)   | Cryptographic primitives used across Fuel Rust based projects.                                                                                                                                                                     | 
 | fuel-merkle  | [![crates.io](https://img.shields.io/crates/v/fuel-merkle)](https://crates.io/crates/fuel-merkle)   | Implementations of the Merkle Tree used by the `fuel-core` to fulfill fraud proofs requirements, and `fuel-tx` to validate transaction validity.                                                                                   | 
 | fuel-storage | [![crates.io](https://img.shields.io/crates/v/fuel-storage)](https://crates.io/crates/fuel-storage) | Storage abstraction is used to connect FuelVM, `fuel-merkle`, and `fuel-core` together without direct access.                                                                                                                      | 

fuel-asm/Cargo.toml

@@ -13,7 +13,7 @@ description = "Atomic types of the FuelVM."
 [dependencies]
 arbitrary = { version = "1.1", features = ["derive"], optional = true }
 bitflags = { workspace = true }
-fuel-types = { workspace = true }
+fuel-types = { workspace = true, default-features = false }
 serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
 strum = { version = "0.24", default-features = false, features = ["derive"] }
 wasm-bindgen = { version = "0.2.88", optional = true }

fuel-compression/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "fuel-compression"
+version = { workspace = true }
+authors = { workspace = true }
+categories = ["cryptography::cryptocurrencies"]
+edition = { workspace = true }
+homepage = { workspace = true }
+keywords = ["blockchain", "cryptocurrencies", "fuel-compression"]
+license = { workspace = true }
+repository = { workspace = true }
+description = "Compression and decompression of Fuel blocks for DA storage."
+
+[dependencies]
+fuel-derive = { workspace = true }
+fuel-types = { workspace = true }
+serde = { version = "1.0", features = ["derive"] }

fuel-compression/src/impls.rs

@@ -0,0 +1,176 @@
+//! Trait impls for Rust types
+
+use super::traits::*;
+use crate::RegistryKey;
+use core::mem::MaybeUninit;
+use fuel_types::{
+    Address,
+    AssetId,
+    BlobId,
+    BlockHeight,
+    Bytes32,
+    ContractId,
+    Nonce,
+    Salt,
+};
+
+macro_rules! identity_compaction {
+    ($t:ty) => {
+        impl Compressible for $t {
+            type Compressed = Self;
+        }
+
+        impl<Ctx, E> CompressibleBy<Ctx, E> for $t
+        where
+            Ctx: ?Sized,
+        {
+            async fn compress(&self, _: &mut Ctx) -> Result<Self, E> {
+                Ok(*self)
+            }
+        }
+
+        impl<Ctx, E> DecompressibleBy<Ctx, E> for $t
+        where
+            Ctx: ?Sized,
+        {
+            async fn decompress(c: &Self::Compressed, _: &Ctx) -> Result<Self, E> {
+                Ok(*c)
+            }
+        }
+    };
+}
+
+identity_compaction!(u8);
+identity_compaction!(u16);
+identity_compaction!(u32);
+identity_compaction!(u64);
+identity_compaction!(u128);
+
+identity_compaction!(BlockHeight);
+identity_compaction!(BlobId);
+identity_compaction!(Bytes32);
+identity_compaction!(Salt);
+identity_compaction!(Nonce);
+
+macro_rules! array_types_compaction {
+    ($t:ty, $compressed_t:ty) => {
+        impl Compressible for $t {
+            type Compressed = $compressed_t;
+        }
+
+        impl<Ctx, E> CompressibleBy<Ctx, E> for $t
+        where
+            Ctx: CompressionContext<$t, Error = E>,
+            Ctx: ?Sized,
+        {
+            async fn compress(&self, ctx: &mut Ctx) -> Result<$compressed_t, E> {
+                ctx.compress(self).await
+            }
+        }
+
+        impl<Ctx, E> DecompressibleBy<Ctx, E> for $t
+        where
+            Ctx: DecompressionContext<$t, Error = E>,
+            Ctx: ?Sized,
+        {
+            async fn decompress(value: &Self::Compressed, ctx: &Ctx) -> Result<$t, E> {
+                ctx.decompress(value).await
+            }
+        }
+    };
+}
+
+array_types_compaction!(Address, RegistryKey);
+array_types_compaction!(ContractId, RegistryKey);
+array_types_compaction!(AssetId, RegistryKey);
+
+impl<const S: usize, T> Compressible for [T; S]
+where
+    T: Compressible,
+{
+    type Compressed = [T::Compressed; S];
+}
+
+impl<const S: usize, T, Ctx, E> CompressibleBy<Ctx, E> for [T; S]
+where
+    T: CompressibleBy<Ctx, E>,
+{
+    #[allow(unsafe_code)]
+    async fn compress(&self, ctx: &mut Ctx) -> Result<Self::Compressed, E> {
+        // SAFETY: we are claiming to have initialized an array of `MaybeUninit`s,
+        // which do not require initialization.
+        let mut tmp: [MaybeUninit<T::Compressed>; S] =
+            unsafe { MaybeUninit::uninit().assume_init() };
+
+        // Dropping a `MaybeUninit` does nothing, so we can just overwrite the array.
+        // TODO: Handle the case of the error. Currently it will cause a memory leak.
+        //  https://github.com/FuelLabs/fuel-vm/issues/811
+        for (v, empty) in self.iter().zip(tmp.iter_mut()) {
+            unsafe {
+                core::ptr::write(empty.as_mut_ptr(), v.compress(ctx).await?);
+            }
+        }
+
+        // SAFETY: Every element is initialized.
+        let result = tmp.map(|v| unsafe { v.assume_init() });
+        Ok(result)
+    }
+}
+
+impl<const S: usize, T, Ctx, E> DecompressibleBy<Ctx, E> for [T; S]
+where
+    T: DecompressibleBy<Ctx, E> + Clone,
+{
+    #[allow(unsafe_code)]
+    async fn decompress(c: &Self::Compressed, ctx: &Ctx) -> Result<Self, E> {
+        // SAFETY: we are claiming to have initialized an array of `MaybeUninit`s,
+        // which do not require initialization.
+        let mut tmp: [MaybeUninit<T>; S] = unsafe { MaybeUninit::uninit().assume_init() };
+
+        // Dropping a `MaybeUninit` does nothing, so we can just overwrite the array.
+        // TODO: Handle the case of the error. Currently it will cause a memory leak.
+        //  https://github.com/FuelLabs/fuel-vm/issues/811
+        for (v, empty) in c.iter().zip(tmp.iter_mut()) {
+            unsafe {
+                core::ptr::write(empty.as_mut_ptr(), T::decompress(v, ctx).await?);
+            }
+        }
+
+        // SAFETY: Every element is initialized.
+        let result = tmp.map(|v| unsafe { v.assume_init() });
+        Ok(result)
+    }
+}
+
+impl<T> Compressible for Vec<T>
+where
+    T: Compressible + Clone,
+{
+    type Compressed = Vec<T::Compressed>;
+}
+
+impl<T, Ctx, E> CompressibleBy<Ctx, E> for Vec<T>
+where
+    T: CompressibleBy<Ctx, E> + Clone,
+{
+    async fn compress(&self, ctx: &mut Ctx) -> Result<Self::Compressed, E> {
+        let mut result = Vec::with_capacity(self.len());
+        for item in self {
+            result.push(item.compress(ctx).await?);
+        }
+        Ok(result)
+    }
+}
+
+impl<T, Ctx, E> DecompressibleBy<Ctx, E> for Vec<T>
+where
+    T: DecompressibleBy<Ctx, E> + Clone,
+{
+    async fn decompress(c: &Self::Compressed, ctx: &Ctx) -> Result<Self, E> {
+        let mut result = Vec::with_capacity(c.len());
+        for item in c {
+            result.push(T::decompress(item, ctx).await?);
+        }
+        Ok(result)
+    }
+}

fuel-compression/src/key.rs

@@ -0,0 +1,69 @@
+use serde::{
+    Deserialize,
+    Serialize,
+};
+
+/// Untyped key pointing to a registry table entry.
+/// The last key (all bits set) is reserved for the default value and cannot be written
+/// to.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct RegistryKey([u8; Self::SIZE]);
+impl RegistryKey {
+    /// Key mapping to default value for the table type.
+    pub const DEFAULT_VALUE: Self = Self([u8::MAX; Self::SIZE]);
+    /// Maximum writable key.
+    pub const MAX_WRITABLE: Self = Self([u8::MAX, u8::MAX, u8::MAX - 1]);
+    /// Size of the key, in bytes.
+    pub const SIZE: usize = 3;
+    /// Zero key.
+    pub const ZERO: Self = Self([0; Self::SIZE]);
+
+    /// Convert to u32, big-endian.
+    pub fn as_u32(self) -> u32 {
+        u32::from_be_bytes([0, self.0[0], self.0[1], self.0[2]])
+    }
+
+    /// Wraps around just below max/default value.
+    /// Panics for max/default value.
+    pub fn next(self) -> Self {
+        if self == Self::DEFAULT_VALUE {
+            panic!("Max/default value has no next key");
+        }
+        let next_raw = self.as_u32() + 1u32;
+        if next_raw == Self::DEFAULT_VALUE.as_u32() {
+            Self::ZERO
+        } else {
+            Self::try_from(next_raw)
+                .expect("The procedure above always produces a valid key")
+        }
+    }
+}
+impl TryFrom<u32> for RegistryKey {
+    type Error = &'static str;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        let v = value.to_be_bytes();
+        if v[0] != 0 {
+            return Err("RegistryKey must be less than 2^24");
+        }
+
+        let mut bytes = [0u8; 3];
+        bytes.copy_from_slice(&v[1..]);
+        Ok(Self(bytes))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::RegistryKey;
+
+    #[test]
+    fn key_next() {
+        assert_eq!(RegistryKey::ZERO.next(), RegistryKey([0, 0, 1]));
+        assert_eq!(RegistryKey::ZERO.next().next(), RegistryKey([0, 0, 2]));
+        assert_eq!(RegistryKey([0, 0, 255]).next(), RegistryKey([0, 1, 0]));
+        assert_eq!(RegistryKey([0, 1, 255]).next(), RegistryKey([0, 2, 0]));
+        assert_eq!(RegistryKey([0, 255, 255]).next(), RegistryKey([1, 0, 0]));
+        assert_eq!(RegistryKey::MAX_WRITABLE.next(), RegistryKey::ZERO);
+    }
+}

fuel-compression/src/lib.rs

@@ -0,0 +1,19 @@
+//! Compression and decompression of fuel-types for the DA layer
+
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![warn(missing_docs)]
+#![deny(unsafe_code)]
+#![deny(unused_crate_dependencies)]
+#![deny(clippy::cast_possible_truncation)]
+
+mod impls;
+mod key;
+mod traits;
+
+pub use key::RegistryKey;
+pub use traits::*;
+
+pub use fuel_derive::{
+    Compress,
+    Decompress,
+};

fuel-compression/src/traits.rs

@@ -0,0 +1,62 @@
+#![allow(async_fn_in_trait)] // We control the implementation so this is fine
+
+/// This type can be compressed to a more compact form and back using
+/// `CompressibleBy` and `DecompressibleBy` traits.
+pub trait Compressible {
+    /// The compressed type.
+    type Compressed: Sized;
+}
+
+/// A context that can be used to compress a type.
+pub trait CompressionContext<Type>
+where
+    Type: Compressible,
+{
+    /// Error when compressing. Note that the compression itself is not faillible,
+    /// but the context may still do fallible operations.
+    type Error;
+
+    /// Perform compression, returning the compressed data and possibly modifying the
+    /// context. The context is mutable to allow for stateful compression.
+    /// For instance, it can be used to extract original data when replacing it with
+    /// references.
+    async fn compress(&mut self, value: &Type) -> Result<Type::Compressed, Self::Error>;
+}
+
+/// A context that can be used to decompress a type.
+pub trait DecompressionContext<Type>
+where
+    Type: Compressible,
+{
+    /// Error when compressing. Note that the compression itself is not faillible,
+    /// but the context may still do fallible operations.
+    type Error;
+
+    /// Perform decompression, returning the original data.
+    /// The context can be used to resolve references.
+    async fn decompress(&self, value: &Type::Compressed) -> Result<Type, Self::Error>;
+}
+
+/// This type can be compressed to a more compact form and back using
+/// `CompressionContext`.
+pub trait CompressibleBy<Ctx, E>: Compressible
+where
+    Ctx: ?Sized,
+{
+    /// Perform compression, returning the compressed data and possibly modifying the
+    /// context. The context is mutable to allow for stateful compression.
+    /// For instance, it can be used to extract original data when replacing it with
+    /// references.
+    async fn compress(&self, ctx: &mut Ctx) -> Result<Self::Compressed, E>;
+}
+
+/// This type can be decompressed using `CompressionContext`.
+pub trait DecompressibleBy<Ctx, E>: Compressible
+where
+    Ctx: ?Sized,
+    Self: Sized,
+{
+    /// Perform decompression, returning the original data.
+    /// The context can be used to resolve references.
+    async fn decompress(c: &Self::Compressed, ctx: &Ctx) -> Result<Self, E>;
+}