use std::sync::Arc;
use starknet::core::types::Felt;
use super::abi::{FunctionDef, ParsedAbi};
use crate::utils::{felt_to_u64, felt_to_usize_checked};
#[derive(Debug, Clone)]
pub struct DecodedCall {
pub contract_address: Felt,
pub function_name: Option<String>,
pub function_def: Option<FunctionDef>,
pub selector: Felt,
}
pub fn decode_function_selector(selector: &Felt, abi: Option<&ParsedAbi>) -> Option<String> {
abi.and_then(|a| a.get_function(selector))
.map(|f| f.name.clone())
}
pub fn parse_multicall(calldata: &[Felt]) -> Vec<RawCall> {
if calldata.is_empty() {
return Vec::new();
}
if let Some(calls) = try_parse_inline_calls(calldata) {
return calls;
}
if let Some(calls) = try_parse_legacy_call_array(calldata) {
return calls;
}
let num_calls = felt_to_u64(&calldata[0]) as usize;
parse_call_array(calldata, 1, num_calls).0
}
fn try_parse_inline_calls(calldata: &[Felt]) -> Option<Vec<RawCall>> {
let num_calls = felt_to_usize_checked(&calldata[0])?;
let mut calls = Vec::with_capacity(num_calls.min(calldata.len() / 3));
let mut offset = 1usize;
for _ in 0..num_calls {
if offset + 3 > calldata.len() {
return None;
}
let contract_address = calldata[offset];
let selector = calldata[offset + 1];
let data_len = felt_to_usize_checked(&calldata[offset + 2])?;
offset += 3;
let end = offset.checked_add(data_len)?;
if end > calldata.len() {
return None;
}
calls.push(RawCall::new(
contract_address,
selector,
calldata[offset..end].to_vec(),
));
offset = end;
}
(offset == calldata.len()).then_some(calls)
}
fn try_parse_legacy_call_array(calldata: &[Felt]) -> Option<Vec<RawCall>> {
let num_calls = felt_to_usize_checked(&calldata[0])?;
let blob_len_idx = num_calls.checked_mul(4)?.checked_add(1)?;
let blob_start = blob_len_idx.checked_add(1)?;
if blob_start > calldata.len() {
return None;
}
let blob_len = felt_to_usize_checked(&calldata[blob_len_idx])?;
if blob_start.checked_add(blob_len)? != calldata.len() {
return None;
}
let blob = &calldata[blob_start..];
let mut calls = Vec::with_capacity(num_calls);
for i in 0..num_calls {
let base = 1 + i * 4;
let data_offset = felt_to_usize_checked(&calldata[base + 2])?;
let data_len = felt_to_usize_checked(&calldata[base + 3])?;
let end = data_offset.checked_add(data_len)?;
if end > blob_len {
return None;
}
calls.push(RawCall::new(
calldata[base],
calldata[base + 1],
blob[data_offset..end].to_vec(),
));
}
Some(calls)
}
pub fn parse_call_array(
calldata: &[Felt],
mut offset: usize,
num_calls: usize,
) -> (Vec<RawCall>, usize) {
let remaining = calldata.len().saturating_sub(offset);
let max_possible = remaining / 3;
let num_calls = num_calls.min(max_possible);
let mut calls = Vec::with_capacity(num_calls);
for _ in 0..num_calls {
if offset + 2 >= calldata.len() {
break;
}
let contract_address = calldata[offset];
let selector = calldata[offset + 1];
let data_len = felt_to_u64(&calldata[offset + 2]) as usize;
offset += 3;
let data = match offset.checked_add(data_len) {
Some(end) if end <= calldata.len() => calldata[offset..end].to_vec(),
_ => calldata[offset..].to_vec(),
};
offset = offset.saturating_add(data_len);
calls.push(RawCall::new(contract_address, selector, data));
}
(calls, offset)
}
#[derive(Debug, Clone)]
pub struct RawCall {
pub contract_address: Felt,
pub selector: Felt,
pub data: Vec<Felt>,
pub function_name: Option<String>,
pub function_def: Option<FunctionDef>,
pub contract_abi: Option<Arc<ParsedAbi>>,
}
impl RawCall {
fn new(contract_address: Felt, selector: Felt, data: Vec<Felt>) -> Self {
Self {
contract_address,
selector,
data,
function_name: None,
function_def: None,
contract_abi: None,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_call_array_huge_num_calls() {
let data = vec![
Felt::from(1u64),
Felt::from(2u64),
Felt::from(0u64), Felt::from(3u64),
Felt::from(4u64),
Felt::from(0u64), ];
let (calls, _offset) = parse_call_array(&data, 0, usize::MAX);
assert!(calls.len() <= 2);
}
fn f(v: u64) -> Felt {
Felt::from(v)
}
#[test]
fn test_parse_multicall_huge_data_len_does_not_panic() {
let cd = vec![
f(1),
f(0xAA1),
f(0xBB1),
Felt::from_hex("0xFFFFFFFFFFFFFFFF").unwrap(), ];
assert!(try_parse_inline_calls(&cd).is_none());
assert!(try_parse_legacy_call_array(&cd).is_none());
let calls = parse_multicall(&cd);
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].contract_address, f(0xAA1));
assert!(calls[0].data.is_empty());
}
#[test]
fn test_parse_call_array_huge_data_len_offset_saturates() {
let cd = vec![
f(0xAA1),
f(0xBB1),
Felt::from_hex("0xFFFFFFFFFFFFFFFF").unwrap(),
f(0xD1),
];
let (calls, offset) = parse_call_array(&cd, 0, 1);
assert_eq!(calls.len(), 1);
assert!(
offset > cd.len(),
"offset must not wrap below the input len"
);
}
fn legacy_calldata(entries: &[(u64, u64, u64, u64)], blob_len: u64) -> Vec<Felt> {
let mut cd = vec![f(entries.len() as u64)];
for &(to, sel, off, len) in entries {
cd.extend([f(to), f(sel), f(off), f(len)]);
}
cd.push(f(blob_len));
cd.extend((0..blob_len).map(|i| f(0xD00 + i)));
cd
}
#[test]
fn test_parse_multicall_legacy_cairo0_layout() {
let entries = [
(0xAA1, 0xBB1, 0, 3),
(0xAA1, 0xBB2, 3, 3),
(0xAA2, 0xBB3, 6, 11),
(0xAA2, 0xBB4, 17, 1),
(0xAA2, 0xBB5, 18, 3),
];
let cd = legacy_calldata(&entries, 21);
assert_eq!(cd.len(), 43, "1 + 5*4 + 1 + 21");
let calls = parse_multicall(&cd);
assert_eq!(calls.len(), 5);
for (call, &(to, sel, off, len)) in calls.iter().zip(&entries) {
assert_eq!(call.contract_address, f(to));
assert_eq!(call.selector, f(sel));
assert_eq!(call.data.len(), len as usize);
assert_eq!(call.data[0], f(0xD00 + off));
}
assert!(calls.iter().all(|c| c.contract_address != f(3)));
}
#[test]
fn test_parse_multicall_inline_wins_over_legacy() {
let cd = vec![
f(2),
f(0xAA1),
f(0xBB1),
f(0), f(0xAA2),
f(0xBB2),
f(2),
f(0xD1),
f(0xD2),
];
let calls = parse_multicall(&cd);
assert_eq!(calls.len(), 2);
assert_eq!(calls[0].contract_address, f(0xAA1));
assert!(calls[0].data.is_empty());
assert_eq!(calls[1].contract_address, f(0xAA2));
assert_eq!(calls[1].data, vec![f(0xD1), f(0xD2)]);
assert!(try_parse_legacy_call_array(&cd).is_none());
}
#[test]
fn test_legacy_allows_overlapping_offsets() {
let cd = legacy_calldata(&[(0xAA1, 0xBB1, 0, 3), (0xAA1, 0xBB2, 0, 3)], 3);
let calls = parse_multicall(&cd);
assert_eq!(calls.len(), 2);
assert_eq!(calls[0].data, calls[1].data);
}
#[test]
fn test_legacy_rejects_truncating_length_felt() {
let mut cd = legacy_calldata(&[(0xAA1, 0xBB1, 0, 3)], 3);
cd[4] = Felt::from_hex("0x10000000000000003").unwrap();
assert!(try_parse_legacy_call_array(&cd).is_none());
}
#[test]
fn test_parse_multicall_truncated_falls_back() {
let cd = vec![
f(2),
f(0xAA1),
f(0xBB1),
f(0),
f(0xAA2),
f(0xBB2),
f(5),
f(0xD1),
];
assert!(try_parse_inline_calls(&cd).is_none());
assert!(try_parse_legacy_call_array(&cd).is_none());
let calls = parse_multicall(&cd);
assert_eq!(calls.len(), 2);
assert_eq!(calls[0].contract_address, f(0xAA1));
assert_eq!(calls[1].contract_address, f(0xAA2));
}
#[test]
fn test_parse_multicall_normal() {
let data = vec![
Felt::from(1u64), Felt::from(0xAu64), Felt::from(0xBu64), Felt::from(2u64), Felt::from(0xCu64),
Felt::from(0xDu64),
];
let calls = parse_multicall(&data);
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].contract_address, Felt::from(0xAu64));
assert_eq!(calls[0].selector, Felt::from(0xBu64));
assert_eq!(calls[0].data.len(), 2);
}
}