Crate solabi

Solidity ABI encoding and decoding implementation.

At a high level, this crate provides Solidity ABI encode()-ing and decode()-ing implementations for a collection of primitive types, as well as generic implementations for various collections and tuple types.

let encoded = solabi::encode(&(42_i32, true, Bytes::borrowed(&[0, 1, 2, 3])));
let (a, b, c): (i32, bool, Bytes<Vec<u8>>) = solabi::decode(&encoded).unwrap();
assert_eq!(a, 42);
assert_eq!(b, true);
assert_eq!(c.as_bytes(), [0, 1, 2, 3]);

Encoders

Furthermore, this library provides encoders for various Solidity ABI items:

• Functions (FunctionEncoder and ConstructorEncoder).
• Events (EventEncoder and AnonymousEventEncoder).
• Errors (ErrorEncoder).

These encoders provide a type-safe interface for Solidity encoding and decoding their parameters.

const TRANSFER: FunctionEncoder<(Address, U256), (bool,)> =
    FunctionEncoder::new(selector!("transfer(address,uint256)"));

let call = TRANSFER.encode_params(&(
    address!("0x0101010101010101010101010101010101010101"),
    uint!("4_200_000_000_000_000_000"),
));

Dynamic Values

The value::Value type provides dynamic Solidity values. This allows Solidity ABI encoding and decoding when types are not known at compile-time.

let event = abi::EventDescriptor::parse_declaration(
    "event Transfer(address indexed to, address indexed from, uint256 value)",
)
.unwrap();
let encoder = value::EventEncoder::new(&event).unwrap();
let log = encoder
    .encode(&[
        Value::Address(address!("0x0101010101010101010101010101010101010101")),
        Value::Address(address!("0x0202020202020202020202020202020202020202")),
        Value::Uint(value::Uint::new(256, uint!("4_200_000_000_000_000_000")).unwrap()),
    ])
    .unwrap();

Custom Encoding Implementation

It can be useful to define custom types that encode and decode to the Solidity ABI. This can be done by implementing the encode::Encode and decode::Decode traits.

use solabi::{
    encode::{Encode, Encoder, Size},
    decode::{Decode, DecodeError, Decoder},
};

#[derive(Debug, Eq, PartialEq)]
struct MyStruct {
    a: u64,
    b: String,
}

impl Encode for MyStruct {
    fn size(&self) -> Size {
        (self.a, self.b.as_str()).size()
    }

    fn encode(&self, encoder: &mut Encoder) {
        (self.a, self.b.as_str()).encode(encoder);
    }
}

impl Decode for MyStruct {
    fn is_dynamic() -> bool {
        <(u64, String)>::is_dynamic()
    }

    fn decode(decoder: &mut Decoder) -> Result<Self, DecodeError> {
        let (a, b) = Decode::decode(decoder)?;
        Ok(Self { a, b })
    }
}

let my_struct = MyStruct {
    a: 42,
    b: "The Answer to Life the Universe and Everything".to_string(),
};

let encoded = solabi::encode(&my_struct);
let decoded = solabi::decode(&encoded).unwrap();

assert_eq!(my_struct, decoded);

There are plans to provide Encode and Decode procedural macros to automatically implement these traits in the future.

Re-exports

pub use self::decode::decode;

pub use self::decode::decode_with_prefix;

pub use self::decode::decode_with_selector;

pub use self::encode::encode;

pub use self::encode::encode_to;

pub use self::encode::encode_with_prefix;

pub use self::encode::encode_with_selector;

pub use ethprim;

pub use self::prelude::*;

Modules

abi

Solidity ABI descriptors.

bytes

Solidity bytes type.

constructor

Solidity ABI constructor encoding.

decode

Solidity ABI decoding.

encode

Module implementing ABI encoding.

error

Solidity ABI error encoding.

event

Module containing Solidity event related traits and logic.

function

Solidity ABI function pointer type.

keccak

A const fn Keccak-256 implementation.

log

Module implementing an EVM log datatype.

prelude

The solabi prelude.

primitive

Solidity primitive type trait and implementations.

value

Module containing dynamic Solidity value.

Macros

address

Macro to create Ethereum public address values from string literals that get verified at compile time. A compiler error will be generated if an invalid address is specified.

digest

Macro to create Ethereum digest values from string literals that get parsed at compile time. A compiler error will be generated if an invalid digest is specified.

int

Macro for 256-bit signed integer literal.

keccak

Macro to create Ethereum digest values for compile-time hashed input.

selector

Macro for creating a compile-time computed function selector.

uint

Macro for 256-bit unsigned integer literal.