Encoding/Decoding crate for the Solidity ABI. Used when making function calls and/or decoding function call responses.
```rust use serde::{ Deserialize, Serialize, }; use solidity::{ derive::{ Decode, Encode, }, Address, Builder, Bytes, Bytes10, Decode, Encode, Uint256, };
// Basic usage using the built in Encode derive macro.
// (Requires the derive feature.)
struct ContractCallEncode<'a> { pub name: &'a str, pub number: u128, pub bytes10: Bytes10, pub bytes: Bytes<'a>, }
// Basic usage using serde. (Requires the serde feature).
// Note: Serde only supports a subset of the types that Solidity supports.
// If you need to support more types you'll have to use the Encode derive
// macro, or use the solidity::Builder manually.
pub struct ContractCallSerde<'a> { // String is also supported, but it's recommened you use &str when possible. // pub name: String, pub name: &'a str, pub number: u128, pub bytes: Bytes<'a>, // Bytes10 cannot be serialized correctly using serde. // pub bytes: Bytes10, }
// Use the #[solidity(constructor)] attribute to declare a struct as a constructor.
// This is important because constructors do not have the function name prefix,
// unlike all other functions. Usually the struct name is used as the function
// name. To rename the function use the #[solidity(name = "<function_name>")]
// where <function_name> is the name of your function.
// ie. #[solidity(name = "transfer")].
struct ContractConstructorEncode<'a> { pub value: u128, pub string: &'a str, }
// Basic usage with the built in Decode derive macro.
// (Requires the derive feature.)
// Note: Uint256 and all other Int/Uint types are simple
// wrappers around [u8; 32]. The point of them is to support all
// int/uint Solidity types.
struct ContractCallResponse<'a> {
int: Uint256,
// Note: &'a [u8] is not the same as Bytes<'a>. The former is is uint8[] in solidity
// while the latter is bytes. The two types are encoded very differently so decoding
// bytes as uint8[] array will give you invalid data if not fail outright.
bytes: Bytes<'a>,
memo: &'a str,
address: Address,
}
// Basic usage with serde's Deserialize derive macro.
// (Requires the serde feature.)
// Note: Serde only supports a subset of the types that Solidity supports.
// If you need to support more types you'll have to use the Encode derive
// macro, or use the solidity::Builder manually.
struct ContractCallResponseSerde<'a> {
int: u128,
bytes: &'a [u8],
memo: &'a str,
// There is no way to read Address with serde.
// address: Address
}
// Support for composite types and Vec
struct ContractCallComposite<'a> { to: (&'a str, u128), memos: &'a [&'a str], matrix: &'a [&'a [&'a [u8]]], }
```
If you'd like support for num_bigint enable the bigint feature.
``rust
// Note: BigInt is variable sized and encodes toint256.
// To encode touint256use theBigUint` struct.
// Also, BigInt supports numbers larger than the max value a uint256 can store, so the value
// will be truncated to 32 bytes before it's encoded.
struct ContractTransfer<'a> { amount: BigInt, to: &'a str } ```