Trait Encoder 

pub trait Encoder<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool>: Sized {
    const HEADER_SIZE: usize;
    const IS_DYNAMIC: bool;

    // Required methods
    fn encode(
        &self,
        buf: &mut BytesMut,
        offset: usize,
    ) -> Result<(), CodecError>;
    fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>;
    fn partial_decode(
        buf: &impl Buf,
        offset: usize,
    ) -> Result<(usize, usize), CodecError>;

    // Provided method
    fn size_hint(&self) -> usize { ... }
}

Trait for encoding and decoding values with specific byte order, alignment, and mode.

Type Parameters

• B: The byte order used for encoding/decoding.
• ALIGN: The alignment requirement for the encoded data.
• SOL_MODE: A boolean flag indicating whether Solidity-compatible mode is enabled.
• IS_STATIC: A boolean flag indicating whether the encoded data is static (used for SolidityPackedABI).

Required Associated Constants

const HEADER_SIZE: usize

Returns the header size for this encoder.

const IS_DYNAMIC: bool

Required Methods

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

Encodes the value into the given buffer at the specified offset.

Arguments

• buf - The buffer to encode into.
• offset - The starting offset in the buffer for encoding.

Returns

Ok(()) if encoding was successful, or an error if encoding failed.

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

Decodes a value from the given buffer starting at the specified offset.

Arguments

• buf - The buffer to decode from.
• offset - The starting offset in the buffer for decoding.

Returns

The decoded value if successful, or an error if decoding failed.

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

Partially decodes the header to determine the length and offset of the encoded data.

Arguments

• buf - The buffer to decode from.
• offset - The starting offset in the buffer for decoding.

Returns

A tuple (data_offset, data_length) if successful, or an error if decoding failed.

Provided Methods

fn size_hint(&self) -> usize

Calculates the number of bytes needed to encode the value.

This includes the header size and any additional space needed for alignment. The default implementation aligns the header size to the specified alignment.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, false, false> for String

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = true

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, false, false> for Bytes

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

Encode the bytes into the buffer. First, we encode the header and write it to the given offset. After that, we encode the actual data and write it to the end of the buffer.

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

Decode the bytes from the buffer. Reads the header to get the data offset and size, then read the actual data.

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

Partially decode the bytes from the buffer. Returns the data offset and size without reading the actual data.

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = true

impl<B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, true, false> for String

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = true

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, true, false> for Bytes

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

Encode the bytes into the buffer for Solidity mode. First, we encode the header and write it to the given offset. After that, we encode the actual data and write it to the end of the buffer.

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

Decode the bytes from the buffer for Solidity mode. Reads the header to get the data offset and size, then reads the actual data.

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

Partially decode the bytes from the buffer for Solidity mode. Returns the data offset and size without reading the actual data.

const HEADER_SIZE: usize = 32

const IS_DYNAMIC: bool = true

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool> Encoder<B, ALIGN, false, IS_STATIC> for Address

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

Encode the fixed bytes into the buffer. Writes the fixed bytes directly to the buffer at the given offset.

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

Decode the fixed bytes from the buffer. Reads the fixed bytes directly from the buffer at the given offset.

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

Partially decode the fixed bytes from the buffer. Returns the data offset and size without reading the actual data.

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool> Encoder<B, ALIGN, true, IS_STATIC> for Address

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

Encode the fixed bytes into the buffer for Solidity mode. Writes the fixed bytes directly to the buffer at the given offset, zero-padding to 32 bytes.

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

Decode the fixed bytes from the buffer for Solidity mode. Reads the fixed bytes directly from the buffer at the given offset, assuming 32-byte alignment.

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

Partially decode the fixed bytes from the buffer for Solidity mode. Returns the data offset and size without reading the actual data.

const HEADER_SIZE: usize = 32

const IS_DYNAMIC: bool = false

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4, T5)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>, T5: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4, T5)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>, T5: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4, T5, T6)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>, T5: Encoder<B, ALIGN, false, IS_STATIC>, T6: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4, T5, T6)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>, T5: Encoder<B, ALIGN, true, IS_STATIC>, T6: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>, T5: Encoder<B, ALIGN, false, IS_STATIC>, T6: Encoder<B, ALIGN, false, IS_STATIC>, T7: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>, T5: Encoder<B, ALIGN, true, IS_STATIC>, T6: Encoder<B, ALIGN, true, IS_STATIC>, T7: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>, T5: Encoder<B, ALIGN, false, IS_STATIC>, T6: Encoder<B, ALIGN, false, IS_STATIC>, T7: Encoder<B, ALIGN, false, IS_STATIC>, T8: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>, T5: Encoder<B, ALIGN, true, IS_STATIC>, T6: Encoder<B, ALIGN, true, IS_STATIC>, T7: Encoder<B, ALIGN, true, IS_STATIC>, T8: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8, T9> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>, T5: Encoder<B, ALIGN, false, IS_STATIC>, T6: Encoder<B, ALIGN, false, IS_STATIC>, T7: Encoder<B, ALIGN, false, IS_STATIC>, T8: Encoder<B, ALIGN, false, IS_STATIC>, T9: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8, T9> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>, T5: Encoder<B, ALIGN, true, IS_STATIC>, T6: Encoder<B, ALIGN, true, IS_STATIC>, T7: Encoder<B, ALIGN, true, IS_STATIC>, T8: Encoder<B, ALIGN, true, IS_STATIC>, T9: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>, T5: Encoder<B, ALIGN, false, IS_STATIC>, T6: Encoder<B, ALIGN, false, IS_STATIC>, T7: Encoder<B, ALIGN, false, IS_STATIC>, T8: Encoder<B, ALIGN, false, IS_STATIC>, T9: Encoder<B, ALIGN, false, IS_STATIC>, T10: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>, T5: Encoder<B, ALIGN, true, IS_STATIC>, T6: Encoder<B, ALIGN, true, IS_STATIC>, T7: Encoder<B, ALIGN, true, IS_STATIC>, T8: Encoder<B, ALIGN, true, IS_STATIC>, T9: Encoder<B, ALIGN, true, IS_STATIC>, T10: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>, T5: Encoder<B, ALIGN, false, IS_STATIC>, T6: Encoder<B, ALIGN, false, IS_STATIC>, T7: Encoder<B, ALIGN, false, IS_STATIC>, T8: Encoder<B, ALIGN, false, IS_STATIC>, T9: Encoder<B, ALIGN, false, IS_STATIC>, T10: Encoder<B, ALIGN, false, IS_STATIC>, T11: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>, T5: Encoder<B, ALIGN, true, IS_STATIC>, T6: Encoder<B, ALIGN, true, IS_STATIC>, T7: Encoder<B, ALIGN, true, IS_STATIC>, T8: Encoder<B, ALIGN, true, IS_STATIC>, T9: Encoder<B, ALIGN, true, IS_STATIC>, T10: Encoder<B, ALIGN, true, IS_STATIC>, T11: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Encoder<B, ALIGN, false, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T1: Encoder<B, ALIGN, false, IS_STATIC>, T2: Encoder<B, ALIGN, false, IS_STATIC>, T3: Encoder<B, ALIGN, false, IS_STATIC>, T4: Encoder<B, ALIGN, false, IS_STATIC>, T5: Encoder<B, ALIGN, false, IS_STATIC>, T6: Encoder<B, ALIGN, false, IS_STATIC>, T7: Encoder<B, ALIGN, false, IS_STATIC>, T8: Encoder<B, ALIGN, false, IS_STATIC>, T9: Encoder<B, ALIGN, false, IS_STATIC>, T10: Encoder<B, ALIGN, false, IS_STATIC>, T11: Encoder<B, ALIGN, false, IS_STATIC>, T12: Encoder<B, ALIGN, false, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Encoder<B, ALIGN, true, IS_STATIC> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T1: Encoder<B, ALIGN, true, IS_STATIC>, T2: Encoder<B, ALIGN, true, IS_STATIC>, T3: Encoder<B, ALIGN, true, IS_STATIC>, T4: Encoder<B, ALIGN, true, IS_STATIC>, T5: Encoder<B, ALIGN, true, IS_STATIC>, T6: Encoder<B, ALIGN, true, IS_STATIC>, T7: Encoder<B, ALIGN, true, IS_STATIC>, T8: Encoder<B, ALIGN, true, IS_STATIC>, T9: Encoder<B, ALIGN, true, IS_STATIC>, T10: Encoder<B, ALIGN, true, IS_STATIC>, T11: Encoder<B, ALIGN, true, IS_STATIC>, T12: Encoder<B, ALIGN, true, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for bool

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for i16

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for i32

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for i64

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for u8

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for u16

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for u32

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for u64

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for ()

const HEADER_SIZE: usize = 0

const IS_DYNAMIC: bool = false

fn encode(&self, _buf: &mut BytesMut, _offset: usize) -> Result<(), CodecError>

fn decode(_buf: &impl Buf, _offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for PhantomData<B>

const HEADER_SIZE: usize = 0

const IS_DYNAMIC: bool = false

fn encode(&self, _buf: &mut BytesMut, _offset: usize) -> Result<(), CodecError>

fn decode(_buf: &impl Buf, _offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, _offset: usize, ) -> Result<(usize, usize), CodecError>

impl<K, V, B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, false, false> for HashMap<K, V>

where K: Default + Sized + Encoder<B, ALIGN, false, false> + Eq + Hash + Ord, V: Default + Sized + Encoder<B, ALIGN, false, false>,

Implement encoding for HashMap, SOL_MODE = false

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = true

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<K, V, B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, true, false> for HashMap<K, V>

where K: Debug + Default + Sized + Encoder<B, ALIGN, true, false> + Eq + Hash + Ord, V: Debug + Default + Sized + Encoder<B, ALIGN, true, false>,

Implement encoding for HashMap, SOL_MODE = true

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = true

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<T, B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, false, false> for Vec<T>

where T: Default + Sized + Encoder<B, ALIGN, false, false> + Debug,

We encode dynamic arrays as following:

• header
  • length: number of elements inside vector
  • offset: offset inside structure
  • size: number of encoded bytes
• body
  • raw bytes of the vector

For Solidity, we don’t have size:

• header
  • offset
• body
  • length
  • raw bytes of the vector

Implementation for non-Solidity mode

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = true

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<T, B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, false, false> for HashSet<T>

where T: Default + Sized + Encoder<B, ALIGN, false, false> + Eq + Hash + Ord,

Implement encoding for HashSet, SOL_MODE = false

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = true

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<T, B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, true, false> for Vec<T>

where T: Default + Sized + Encoder<B, ALIGN, true, false> + Debug,

const HEADER_SIZE: usize = 32

const IS_DYNAMIC: bool = true

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<T, B: ByteOrder, const ALIGN: usize> Encoder<B, ALIGN, true, false> for HashSet<T>

where T: Debug + Default + Sized + Encoder<B, ALIGN, true, false> + Eq + Hash + Ord,

Implement encoding for HashSet, SOL_MODE = true

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = true

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<T, B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for Option<T>

where T: Sized + Encoder<B, ALIGN, SOL_MODE, true> + Default,

Encodes and decodes Option<T> where T is an encoder. The encoded data is prefixed with a single byte that indicates whether the Option is Some or None. Single byte will be aligned to ALIGN.

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<T, B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for (T,)

where T: Encoder<B, ALIGN, SOL_MODE, IS_STATIC>,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = T::IS_DYNAMIC

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<T, B: ByteOrder, const ALIGN: usize, const SOL_MODE: bool, const N: usize, const IS_STATIC: bool> Encoder<B, ALIGN, SOL_MODE, IS_STATIC> for [T; N]

where T: Sized + Encoder<B, ALIGN, SOL_MODE, IS_STATIC> + Default + Copy,

const HEADER_SIZE: usize

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<const BITS: usize, const LIMBS: usize, B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool> Encoder<B, ALIGN, false, IS_STATIC> for Signed<BITS, LIMBS>

const HEADER_SIZE: usize = Self::BYTES

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<const BITS: usize, const LIMBS: usize, B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool> Encoder<B, ALIGN, false, IS_STATIC> for Uint<BITS, LIMBS>

const HEADER_SIZE: usize = Self::BYTES

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<const BITS: usize, const LIMBS: usize, B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool> Encoder<B, ALIGN, true, IS_STATIC> for Signed<BITS, LIMBS>

const HEADER_SIZE: usize = 32

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<const BITS: usize, const LIMBS: usize, B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool> Encoder<B, ALIGN, true, IS_STATIC> for Uint<BITS, LIMBS>

const HEADER_SIZE: usize = 32

const IS_DYNAMIC: bool = false

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

impl<const N: usize, B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool> Encoder<B, ALIGN, false, IS_STATIC> for FixedBytes<N>

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

Encode the fixed bytes into the buffer. Writes the fixed bytes directly to the buffer at the given offset.

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

Decode the fixed bytes from the buffer. Reads the fixed bytes directly from the buffer at the given offset.

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

Partially decode the fixed bytes from the buffer. Returns the data offset and size without reading the actual data.

const HEADER_SIZE: usize = N

const IS_DYNAMIC: bool = false

impl<const N: usize, B: ByteOrder, const ALIGN: usize, const IS_STATIC: bool> Encoder<B, ALIGN, true, IS_STATIC> for FixedBytes<N>

fn encode(&self, buf: &mut BytesMut, offset: usize) -> Result<(), CodecError>

Encode the fixed bytes into the buffer for Solidity mode. Writes the fixed bytes directly to the buffer at the given offset, zero-padding to 32 bytes.

fn decode(buf: &impl Buf, offset: usize) -> Result<Self, CodecError>

Decode the fixed bytes from the buffer for Solidity mode. Reads the fixed bytes directly from the buffer at the given offset, assuming 32-byte alignment.

fn partial_decode( _buf: &impl Buf, offset: usize, ) -> Result<(usize, usize), CodecError>

Partially decode the fixed bytes from the buffer for Solidity mode. Returns the data offset and size without reading the actual data.

const HEADER_SIZE: usize = 32

const IS_DYNAMIC: bool = false

Implementors