use std::collections::BTreeMap;
use borsh::{BorshDeserialize, BorshSerialize};
use crate::error::SdkError;
use crate::types::{Address, ParamAbi, ParamType};
#[derive(Clone, Debug, PartialEq)]
pub enum Value {
U8(u8),
U16(u16),
U32(u32),
U64(u64),
U128(u128),
I8(i8),
I16(i16),
I32(i32),
I64(i64),
I128(i128),
Bool(bool),
Address(Address),
Bytes(Vec<u8>),
String(String),
FixedBytes(Vec<u8>),
Vec(Vec<Value>),
Map(Vec<(Value, Value)>),
Option(Option<Box<Value>>),
Custom(Vec<u8>),
}
impl Value {
#[must_use]
pub fn map(entries: BTreeMap<Value, Value>) -> Self {
Self::Map(entries.into_iter().collect())
}
}
impl Eq for Value {}
impl PartialOrd for Value {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Value {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
let a = borsh_encode(self).unwrap_or_default();
let b = borsh_encode(other).unwrap_or_default();
a.cmp(&b)
}
}
pub fn encode_value(param_type: &ParamType, value: &Value) -> Result<Vec<u8>, SdkError> {
let mut buf = Vec::new();
write_value(param_type, value, &mut buf)?;
Ok(buf)
}
pub fn encode_calldata(params: &[ParamAbi], args: &[Value]) -> Result<Vec<u8>, SdkError> {
if args.len() != params.len() {
return Err(SdkError::InvalidArgument(format!(
"expected {} args, got {}",
params.len(),
args.len()
)));
}
let mut buf = Vec::new();
for (param, arg) in params.iter().zip(args.iter()) {
write_value(¶m.ty, arg, &mut buf)?;
}
Ok(buf)
}
fn write_value(ty: &ParamType, value: &Value, out: &mut Vec<u8>) -> Result<(), SdkError> {
use ParamType as P;
use Value as V;
match (ty, value) {
(P::U8, V::U8(v)) => borsh_write(v, out),
(P::U16, V::U16(v)) => borsh_write(v, out),
(P::U32, V::U32(v)) => borsh_write(v, out),
(P::U64, V::U64(v)) => borsh_write(v, out),
(P::U128, V::U128(v)) => borsh_write(v, out),
(P::I8, V::I8(v)) => borsh_write(v, out),
(P::I16, V::I16(v)) => borsh_write(v, out),
(P::I32, V::I32(v)) => borsh_write(v, out),
(P::I64, V::I64(v)) => borsh_write(v, out),
(P::I128, V::I128(v)) => borsh_write(v, out),
(P::Bool, V::Bool(v)) => borsh_write(v, out),
(P::Address, V::Address(addr)) => {
out.extend_from_slice(addr.as_bytes());
Ok(())
}
(P::Bytes, V::Bytes(b)) => borsh_write(b, out),
(P::String, V::String(s)) => borsh_write(s, out),
(P::FixedBytes(len), V::FixedBytes(b)) => {
if b.len() as u32 != *len {
return Err(SdkError::InvalidArgument(format!(
"FixedBytes({len}) length mismatch: got {} bytes",
b.len()
)));
}
out.extend_from_slice(b);
Ok(())
}
(P::Vec(inner), V::Vec(items)) => {
borsh_write(&(items.len() as u32), out)?;
for item in items {
write_value(inner, item, out)?;
}
Ok(())
}
(P::Map { key, value: vt }, V::Map(pairs)) => {
borsh_write(&(pairs.len() as u32), out)?;
for (k, v) in pairs {
write_value(key, k, out)?;
write_value(vt, v, out)?;
}
Ok(())
}
(P::Option(inner), V::Option(opt)) => match opt {
None => {
out.push(0x00);
Ok(())
}
Some(v) => {
out.push(0x01);
write_value(inner, v, out)
}
},
(P::Custom(_), V::Custom(bytes)) => {
out.extend_from_slice(bytes);
Ok(())
}
(ty, value) => Err(SdkError::InvalidArgument(format!(
"type mismatch: {ty:?} cannot encode {value:?}"
))),
}
}
fn borsh_write<T: BorshSerialize>(v: &T, out: &mut Vec<u8>) -> Result<(), SdkError> {
v.serialize(out)
.map_err(|e| SdkError::InvalidArgument(format!("borsh encode: {e}")))
}
fn borsh_encode(v: &Value) -> Result<Vec<u8>, SdkError> {
fn b<T: BorshSerialize>(x: &T) -> Result<Vec<u8>, SdkError> {
borsh::to_vec(x).map_err(|e| SdkError::Other(format!("borsh encode: {e}")))
}
match v {
Value::U8(x) => b(x),
Value::U16(x) => b(x),
Value::U32(x) => b(x),
Value::U64(x) => b(x),
Value::U128(x) => b(x),
Value::I8(x) => b(x),
Value::I16(x) => b(x),
Value::I32(x) => b(x),
Value::I64(x) => b(x),
Value::I128(x) => b(x),
Value::Bool(x) => b(x),
Value::Address(a) => Ok(a.as_bytes().to_vec()),
Value::Bytes(b) | Value::FixedBytes(b) | Value::Custom(b) => Ok(b.clone()),
Value::String(s) => b(s),
Value::Vec(items) => {
let mut out = b(&(items.len() as u32))?;
for item in items {
out.extend_from_slice(&borsh_encode(item)?);
}
Ok(out)
}
Value::Map(pairs) => {
let mut out = b(&(pairs.len() as u32))?;
for (k, v) in pairs {
out.extend_from_slice(&borsh_encode(k)?);
out.extend_from_slice(&borsh_encode(v)?);
}
Ok(out)
}
Value::Option(opt) => match opt {
None => Ok(vec![0]),
Some(v) => {
let mut out = vec![1];
out.extend_from_slice(&borsh_encode(v)?);
Ok(out)
}
},
}
}
pub fn decode_value(param_type: &ParamType, bytes: &[u8]) -> Result<Value, SdkError> {
let mut slice = bytes;
let v = read_value(param_type, &mut slice)?;
if !slice.is_empty() {
return Err(SdkError::InvalidResponse(format!(
"trailing {} bytes after decoding {param_type:?}",
slice.len()
)));
}
Ok(v)
}
pub fn decode_value_inplace(param_type: &ParamType, slice: &mut &[u8]) -> Result<Value, SdkError> {
read_value(param_type, slice)
}
pub fn decode_return(returns: &Option<ParamType>, bytes: &[u8]) -> Result<Option<Value>, SdkError> {
match returns {
None => {
if !bytes.is_empty() {
return Err(SdkError::InvalidResponse(format!(
"function returns (), but got {} bytes of return data",
bytes.len()
)));
}
Ok(None)
}
Some(ty) => decode_value(ty, bytes).map(Some),
}
}
fn read_value(ty: &ParamType, slice: &mut &[u8]) -> Result<Value, SdkError> {
use ParamType as P;
Ok(match ty {
P::U8 => Value::U8(read_borsh::<u8>(slice)?),
P::U16 => Value::U16(read_borsh::<u16>(slice)?),
P::U32 => Value::U32(read_borsh::<u32>(slice)?),
P::U64 => Value::U64(read_borsh::<u64>(slice)?),
P::U128 => Value::U128(read_borsh::<u128>(slice)?),
P::I8 => Value::I8(read_borsh::<i8>(slice)?),
P::I16 => Value::I16(read_borsh::<i16>(slice)?),
P::I32 => Value::I32(read_borsh::<i32>(slice)?),
P::I64 => Value::I64(read_borsh::<i64>(slice)?),
P::I128 => Value::I128(read_borsh::<i128>(slice)?),
P::Bool => Value::Bool(read_borsh::<bool>(slice)?),
P::Address => {
if slice.len() < 32 {
return Err(short_read(32, slice.len(), "Address"));
}
let mut arr = [0u8; 32];
arr.copy_from_slice(&slice[..32]);
*slice = &slice[32..];
Value::Address(Address(arr))
}
P::Bytes => Value::Bytes(read_borsh::<Vec<u8>>(slice)?),
P::String => Value::String(read_borsh::<String>(slice)?),
P::FixedBytes(len) => {
let len = *len as usize;
if slice.len() < len {
return Err(short_read(len, slice.len(), "FixedBytes"));
}
let bytes = slice[..len].to_vec();
*slice = &slice[len..];
Value::FixedBytes(bytes)
}
P::Vec(inner) => {
let count = decode_count(slice, "Vec")?;
let mut items = Vec::with_capacity(count);
for _ in 0..count {
items.push(read_value(inner, slice)?);
}
Value::Vec(items)
}
P::Map { key, value } => {
let count = decode_count(slice, "Map")?;
let mut pairs = Vec::with_capacity(count);
for _ in 0..count {
let k = read_value(key, slice)?;
let v = read_value(value, slice)?;
pairs.push((k, v));
}
Value::Map(pairs)
}
P::Option(inner) => {
let tag = read_borsh::<u8>(slice)?;
match tag {
0 => Value::Option(None),
1 => Value::Option(Some(Box::new(read_value(inner, slice)?))),
other => {
return Err(SdkError::InvalidResponse(format!(
"Option tag must be 0 or 1; got {other}"
)))
}
}
}
P::Custom(_) => {
let bytes = slice.to_vec();
*slice = &slice[slice.len()..];
Value::Custom(bytes)
}
})
}
pub const MAX_DECODE_ELEMENTS: usize = 1_000_000;
fn decode_count(slice: &mut &[u8], label: &str) -> Result<usize, SdkError> {
let raw = read_borsh::<u32>(slice)? as usize;
if raw > MAX_DECODE_ELEMENTS {
return Err(SdkError::InvalidResponse(format!(
"{label}: declared length {raw} exceeds MAX_DECODE_ELEMENTS \
({MAX_DECODE_ELEMENTS}) — refusing to allocate"
)));
}
Ok(raw)
}
fn read_borsh<T: BorshDeserialize>(slice: &mut &[u8]) -> Result<T, SdkError> {
T::deserialize(slice).map_err(|e| SdkError::InvalidResponse(format!("borsh decode: {e}")))
}
fn short_read(want: usize, got: usize, label: &str) -> SdkError {
SdkError::InvalidResponse(format!("{label}: need {want} bytes, have {got}"))
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
fn round_trip(ty: ParamType, value: Value) {
let bytes = encode_value(&ty, &value).unwrap();
let decoded = decode_value(&ty, &bytes).unwrap();
assert_eq!(decoded, value, "round-trip mismatch for {ty:?}");
}
#[test]
fn round_trip_primitives() {
round_trip(ParamType::U8, Value::U8(42));
round_trip(ParamType::U128, Value::U128(u128::MAX));
round_trip(ParamType::I64, Value::I64(-1));
round_trip(ParamType::Bool, Value::Bool(true));
round_trip(ParamType::Bool, Value::Bool(false));
}
#[test]
fn round_trip_address() {
round_trip(ParamType::Address, Value::Address(Address([0xAB; 32])));
}
#[test]
fn round_trip_bytes_and_string() {
round_trip(ParamType::Bytes, Value::Bytes(vec![1, 2, 3, 4]));
round_trip(ParamType::String, Value::String("hello".into()));
}
#[test]
fn round_trip_fixed_bytes() {
round_trip(
ParamType::FixedBytes(8),
Value::FixedBytes(vec![1, 2, 3, 4, 5, 6, 7, 8]),
);
}
#[test]
fn fixed_bytes_length_validated() {
let err =
encode_value(&ParamType::FixedBytes(8), &Value::FixedBytes(vec![1, 2])).unwrap_err();
assert!(matches!(err, SdkError::InvalidArgument(_)));
}
#[test]
fn round_trip_vec_and_map() {
round_trip(
ParamType::Vec(Box::new(ParamType::U32)),
Value::Vec(vec![Value::U32(1), Value::U32(2), Value::U32(3)]),
);
round_trip(
ParamType::Map {
key: Box::new(ParamType::String),
value: Box::new(ParamType::U64),
},
Value::Map(vec![
(Value::String("a".into()), Value::U64(1)),
(Value::String("b".into()), Value::U64(2)),
]),
);
}
#[test]
fn round_trip_option() {
round_trip(
ParamType::Option(Box::new(ParamType::U128)),
Value::Option(Some(Box::new(Value::U128(42)))),
);
round_trip(
ParamType::Option(Box::new(ParamType::Bool)),
Value::Option(None),
);
}
#[test]
fn calldata_concatenates_args() {
let params = vec![
ParamAbi {
name: "a".into(),
ty: ParamType::U64,
},
ParamAbi {
name: "b".into(),
ty: ParamType::String,
},
];
let args = vec![Value::U64(7), Value::String("ok".into())];
let bytes = encode_calldata(¶ms, &args).unwrap();
let expected = {
let mut v = encode_value(¶ms[0].ty, &args[0]).unwrap();
v.extend(encode_value(¶ms[1].ty, &args[1]).unwrap());
v
};
assert_eq!(bytes, expected);
}
#[test]
fn calldata_arity_mismatch() {
let params = vec![ParamAbi {
name: "x".into(),
ty: ParamType::U64,
}];
let err = encode_calldata(¶ms, &[]).unwrap_err();
assert!(matches!(err, SdkError::InvalidArgument(_)));
}
#[test]
fn type_mismatch_rejected() {
let err = encode_value(&ParamType::U32, &Value::U64(7)).unwrap_err();
assert!(matches!(err, SdkError::InvalidArgument(_)));
}
#[test]
fn decode_return_empty_for_unit_return() {
let v = decode_return(&None, &[]).unwrap();
assert!(v.is_none());
}
#[test]
fn decode_return_rejects_trailing_bytes() {
let err = decode_return(&None, &[1, 2, 3]).unwrap_err();
assert!(matches!(err, SdkError::InvalidResponse(_)));
}
#[test]
fn decode_return_typed() {
let bytes = encode_value(&ParamType::U64, &Value::U64(123)).unwrap();
let v = decode_return(&Some(ParamType::U64), &bytes).unwrap();
assert_eq!(v, Some(Value::U64(123)));
}
}