use starknet::core::types::Felt;
use super::functions::{RawCall, parse_call_array};
use crate::utils::felt_to_u64;
pub const ANY_CALLER: Felt = Felt::from_hex_unchecked("0x414e595f43414c4c4552");
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OutsideExecutionVersion {
V1,
V2,
V3,
PrivateSponsored,
}
impl OutsideExecutionVersion {
pub fn short(&self) -> &'static str {
match self {
Self::V1 => "v1",
Self::V2 => "v2",
Self::V3 => "v3",
Self::PrivateSponsored => "p1",
}
}
pub fn verbose(&self) -> &'static str {
match self {
Self::V1 => "v1",
Self::V2 => "v2",
Self::V3 => "v3",
Self::PrivateSponsored => "private-sponsored",
}
}
}
impl std::fmt::Display for OutsideExecutionVersion {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.short())
}
}
#[derive(Debug, Clone)]
pub struct OutsideExecutionInfo {
pub intender: Felt,
pub caller: Felt,
pub nonce: Felt,
pub execute_after: u64,
pub execute_before: u64,
pub inner_calls: Vec<RawCall>,
pub signature: Vec<Felt>,
pub version: OutsideExecutionVersion,
}
pub fn is_outside_execution(function_name: &str) -> Option<OutsideExecutionVersion> {
match function_name {
"execute_from_outside" => Some(OutsideExecutionVersion::V1),
"execute_from_outside_v2" => Some(OutsideExecutionVersion::V2),
"execute_from_outside_v3" => Some(OutsideExecutionVersion::V3),
"execute_private_sponsored" => Some(OutsideExecutionVersion::PrivateSponsored),
_ => None,
}
}
pub const EXECUTE_PRIVATE_SPONSORED_SELECTOR: Felt =
Felt::from_hex_unchecked("0x3bd4b5033e788e9cc450fefa99ea20e3bed0fa358c8b280c0488f0c4647472e");
pub fn looks_like_outside_execution(call: &RawCall) -> bool {
if call.data.len() < 6 {
return false;
}
if call.data[0] != ANY_CALLER {
return false;
}
try_parse_with_nonce_size(&call.data, 1).is_some()
|| try_parse_with_nonce_size(&call.data, 2).is_some()
}
pub fn looks_like_private_sponsored(call: &RawCall) -> bool {
call.selector == EXECUTE_PRIVATE_SPONSORED_SELECTOR
}
pub fn parse_private_sponsored(call: &RawCall) -> Option<OutsideExecutionInfo> {
let data = &call.data;
if data.len() < 4 {
return None;
}
let num_inner_calls = felt_to_u64(&data[0]) as usize;
if num_inner_calls > 100 {
return None;
}
let (inner_calls, _offset_after) = parse_call_array(data, 1, num_inner_calls);
if inner_calls.len() != num_inner_calls {
return None;
}
Some(OutsideExecutionInfo {
intender: call.contract_address,
caller: Felt::ZERO,
nonce: Felt::ZERO,
execute_after: 0,
execute_before: u64::MAX,
inner_calls,
signature: Vec::new(),
version: OutsideExecutionVersion::PrivateSponsored,
})
}
pub fn parse_outside_execution(
call: &RawCall,
version: OutsideExecutionVersion,
) -> Option<OutsideExecutionInfo> {
let data = &call.data;
if data.len() < 5 {
return None;
}
let caller = data[0];
let (nonce, nonce_size) = if let Some(parsed) = try_parse_with_nonce_size(data, 1) {
(data[1], parsed)
} else if let Some(parsed) = try_parse_with_nonce_size(data, 2) {
(data[1], parsed)
} else {
return None;
};
let header_size = 1 + nonce_size + 2 + 1; let execute_after = felt_to_u64(&data[1 + nonce_size]);
let execute_before = felt_to_u64(&data[1 + nonce_size + 1]);
let num_inner_calls = felt_to_u64(&data[header_size - 1]) as usize;
let (inner_calls, offset_after_calls) = parse_call_array(data, header_size, num_inner_calls);
let signature = if offset_after_calls < data.len() {
let sig_len = felt_to_u64(&data[offset_after_calls]) as usize;
let sig_start = offset_after_calls + 1;
match sig_start.checked_add(sig_len) {
Some(end) if end <= data.len() => data[sig_start..end].to_vec(),
_ => data[sig_start..].to_vec(),
}
} else {
Vec::new()
};
Some(OutsideExecutionInfo {
intender: call.contract_address,
caller,
nonce,
execute_after,
execute_before,
inner_calls,
signature,
version,
})
}
fn try_parse_with_nonce_size(data: &[Felt], nonce_size: usize) -> Option<usize> {
let header_size = 1 + nonce_size + 2 + 1;
if data.len() < header_size {
return None;
}
let num_inner_calls = felt_to_u64(&data[header_size - 1]) as usize;
if num_inner_calls > 100 {
return None;
}
let remaining_after_header = data.len().saturating_sub(header_size);
if num_inner_calls > 0 && remaining_after_header < 3 {
return None;
}
let (inner_calls, offset_after_calls) = parse_call_array(data, header_size, num_inner_calls);
if inner_calls.len() != num_inner_calls {
return None;
}
if offset_after_calls < data.len() {
let sig_len = felt_to_u64(&data[offset_after_calls]) as usize;
match (offset_after_calls + 1).checked_add(sig_len) {
Some(expected_end) if expected_end == data.len() => {}
_ => return None,
}
} else if offset_after_calls != data.len() {
return None;
}
Some(nonce_size)
}
const AVNU_FORWARDER_ADDRESSES: &[Felt] = &[Felt::from_hex_unchecked(
"0x127021a1b5a52d3174c2ab077c2b043c80369250d29428cee956d76ee51584f",
)];
pub fn is_avnu_forwarder(address: &Felt) -> bool {
AVNU_FORWARDER_ADDRESSES.contains(address)
}
pub fn parse_forwarder_call(call: &RawCall) -> Option<OutsideExecutionInfo> {
let data = &call.data;
if data.len() < 8 {
return None;
}
let account_address = data[0]; let _entrypoint = data[1]; let calldata_len = felt_to_u64(&data[2]) as usize;
if calldata_len == 0 || 3 + calldata_len > data.len() {
return None;
}
let inner_data: Vec<Felt> = data[3..3 + calldata_len].to_vec();
let inner_call = RawCall {
contract_address: account_address, selector: data[1],
data: inner_data,
function_name: None,
function_def: None,
contract_abi: None,
};
parse_outside_execution(&inner_call, OutsideExecutionVersion::V2)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DetectionMethod {
Name,
Heuristic,
AvnuForwarder,
}
pub fn detect_outside_execution(
call: &RawCall,
function_name: Option<&str>,
) -> Option<(OutsideExecutionInfo, DetectionMethod)> {
if let Some(name) = function_name
&& let Some(version) = is_outside_execution(name)
{
let parsed = if matches!(version, OutsideExecutionVersion::PrivateSponsored) {
parse_private_sponsored(call)
} else {
parse_outside_execution(call, version)
};
if let Some(oe) = parsed {
return Some((oe, DetectionMethod::Name));
}
}
if looks_like_private_sponsored(call)
&& let Some(oe) = parse_private_sponsored(call)
{
return Some((oe, DetectionMethod::Name));
}
if is_avnu_forwarder(&call.contract_address) {
if let Some(oe) = parse_forwarder_call(call) {
return Some((oe, DetectionMethod::AvnuForwarder));
}
return None;
}
if looks_like_outside_execution(call)
&& let Some(oe) = parse_outside_execution(call, OutsideExecutionVersion::V2)
{
return Some((oe, DetectionMethod::Heuristic));
}
None
}
pub fn is_any_caller(caller: &Felt) -> bool {
*caller == ANY_CALLER
}
pub fn format_caller(caller: &Felt) -> String {
if is_any_caller(caller) {
"ANY_CALLER".to_string()
} else {
format!("{:#x}", caller)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn felt(hex: &str) -> Felt {
Felt::from_hex(hex).unwrap()
}
#[test]
fn test_is_outside_execution() {
assert_eq!(
is_outside_execution("execute_from_outside"),
Some(OutsideExecutionVersion::V1)
);
assert_eq!(
is_outside_execution("execute_from_outside_v2"),
Some(OutsideExecutionVersion::V2)
);
assert_eq!(
is_outside_execution("execute_from_outside_v3"),
Some(OutsideExecutionVersion::V3)
);
assert_eq!(
is_outside_execution("execute_private_sponsored"),
Some(OutsideExecutionVersion::PrivateSponsored)
);
assert_eq!(is_outside_execution("transfer"), None);
assert_eq!(is_outside_execution("execute"), None);
}
#[test]
fn test_parse_outside_execution_basic() {
let intender = felt("0xabc");
let caller = ANY_CALLER;
let nonce = felt("0x42");
let execute_after = Felt::from(1000u64);
let execute_before = Felt::from(2000u64);
let inner_to = felt("0xdef");
let inner_selector = felt("0x123");
let inner_data_len = Felt::from(2u64);
let inner_data_0 = Felt::from(1u64);
let inner_data_1 = Felt::from(2u64);
let sig_len = Felt::from(2u64);
let sig_0 = felt("0xfeed");
let sig_1 = felt("0xbeef");
let data = vec![
caller,
nonce,
execute_after,
execute_before,
Felt::from(1u64), inner_to,
inner_selector,
inner_data_len,
inner_data_0,
inner_data_1,
sig_len,
sig_0,
sig_1,
];
let call = RawCall {
contract_address: intender,
selector: felt("0x999"),
data,
function_name: Some("execute_from_outside_v2".into()),
function_def: None,
contract_abi: None,
};
let oe = parse_outside_execution(&call, OutsideExecutionVersion::V2).unwrap();
assert_eq!(oe.intender, intender);
assert_eq!(oe.caller, ANY_CALLER);
assert_eq!(oe.nonce, nonce);
assert_eq!(oe.execute_after, 1000);
assert_eq!(oe.execute_before, 2000);
assert_eq!(oe.version, OutsideExecutionVersion::V2);
assert_eq!(oe.inner_calls.len(), 1);
assert_eq!(oe.inner_calls[0].contract_address, inner_to);
assert_eq!(oe.inner_calls[0].selector, inner_selector);
assert_eq!(oe.inner_calls[0].data.len(), 2);
assert_eq!(oe.signature.len(), 2);
}
#[test]
fn test_parse_outside_execution_huge_sig_len_does_not_panic() {
let data = vec![
ANY_CALLER,
Felt::from(1u64), Felt::from(0u64), Felt::from(9999u64), Felt::from(1u64), felt("0xdef"), felt("0x123"), Felt::from(0u64), Felt::from_hex("0xFFFFFFFFFFFFFFFF").unwrap(), ];
let call = RawCall {
contract_address: felt("0xabc"),
selector: felt("0x999"),
data,
function_name: Some("execute_from_outside_v2".into()),
function_def: None,
contract_abi: None,
};
assert!(parse_outside_execution(&call, OutsideExecutionVersion::V2).is_none());
}
#[test]
fn test_parse_outside_execution_multiple_inner_calls() {
let data = vec![
ANY_CALLER,
Felt::from(1u64), Felt::from(0u64), Felt::from(9999u64), Felt::from(2u64), felt("0x10"),
felt("0x20"),
Felt::from(0u64),
felt("0x30"),
felt("0x40"),
Felt::from(1u64),
felt("0x50"),
Felt::from(0u64),
];
let call = RawCall {
contract_address: felt("0xabc"),
selector: felt("0x999"),
data,
function_name: None,
function_def: None,
contract_abi: None,
};
let oe = parse_outside_execution(&call, OutsideExecutionVersion::V3).unwrap();
assert_eq!(oe.inner_calls.len(), 2);
assert_eq!(oe.inner_calls[0].contract_address, felt("0x10"));
assert_eq!(oe.inner_calls[0].data.len(), 0);
assert_eq!(oe.inner_calls[1].contract_address, felt("0x30"));
assert_eq!(oe.inner_calls[1].data, vec![felt("0x50")]);
assert!(oe.signature.is_empty());
}
#[test]
fn test_parse_outside_execution_too_short() {
let call = RawCall {
contract_address: felt("0xabc"),
selector: felt("0x999"),
data: vec![Felt::from(1u64), Felt::from(2u64)], function_name: None,
function_def: None,
contract_abi: None,
};
assert!(parse_outside_execution(&call, OutsideExecutionVersion::V2).is_none());
}
#[test]
fn test_any_caller() {
assert!(is_any_caller(&ANY_CALLER));
assert!(!is_any_caller(&Felt::from(123u64)));
}
#[test]
fn test_parse_outside_execution_garbage_num_calls() {
let data = vec![
felt("0x414e595f43414c4c4552"), Felt::from(1u64), Felt::from(1000u64), Felt::from(2000u64), felt("0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7"),
Felt::from(42u64),
Felt::from(43u64),
];
let call = RawCall {
contract_address: felt("0xabc"),
selector: felt("0x999"),
data,
function_name: Some("execute_from_outside_v2".into()),
function_def: None,
contract_abi: None,
};
assert!(parse_outside_execution(&call, OutsideExecutionVersion::V2).is_none());
}
#[test]
fn test_parse_outside_execution_no_room_for_calls() {
let data = vec![
ANY_CALLER,
Felt::from(1u64), Felt::from(0u64), Felt::from(9999u64), Felt::from(5u64), ];
let call = RawCall {
contract_address: felt("0xabc"),
selector: felt("0x999"),
data,
function_name: None,
function_def: None,
contract_abi: None,
};
assert!(parse_outside_execution(&call, OutsideExecutionVersion::V2).is_none());
}
#[test]
fn test_parse_outside_execution_argent_v3_two_felt_nonce() {
let data = vec![
ANY_CALLER, felt("0x4874fad70d602bc5306439d34b1d8c54555f852d3366695ca45c7fdc1c553b6"), Felt::from(1u64), Felt::from(0u64), Felt::from(1776060058u64), Felt::from(2u64), felt("0xaaa"),
felt("0xbbb"),
Felt::from(1u64),
Felt::from(1u64),
felt("0xccc"),
felt("0xddd"),
Felt::from(0u64),
Felt::from(3u64),
felt("0x111"),
felt("0x222"),
felt("0x333"),
];
let call = RawCall {
contract_address: felt(
"0x4fc0fc0cc69761d6bc13e57f6e6839ea180ac27189e9f90466abf53c25dc327",
),
selector: felt("0x3dbc508ba4afd040c8dc4ff8a61113a7bcaf5eae88a6ba27b3c50578b3587e3"),
data,
function_name: None, function_def: None,
contract_abi: None,
};
assert!(looks_like_outside_execution(&call));
let oe = parse_outside_execution(&call, OutsideExecutionVersion::V2).unwrap();
assert_eq!(
oe.intender,
felt("0x4fc0fc0cc69761d6bc13e57f6e6839ea180ac27189e9f90466abf53c25dc327")
);
assert_eq!(oe.caller, ANY_CALLER);
assert_eq!(oe.execute_after, 0);
assert_eq!(oe.execute_before, 1776060058);
assert_eq!(oe.inner_calls.len(), 2);
assert_eq!(oe.inner_calls[0].contract_address, felt("0xaaa"));
assert_eq!(oe.inner_calls[1].contract_address, felt("0xccc"));
assert_eq!(oe.signature.len(), 3);
}
#[test]
fn test_heuristic_rejects_non_outside_execution() {
let call = RawCall {
contract_address: felt("0xabc"),
selector: felt("0x999"),
data: vec![
ANY_CALLER,
Felt::from(42u64),
Felt::from(100u64),
Felt::from(200u64),
Felt::from(1u64), felt("0xdef"),
felt("0x123"),
Felt::from(0u64),
Felt::from(999u64),
Felt::from(888u64),
],
function_name: None,
function_def: None,
contract_abi: None,
};
assert!(!looks_like_outside_execution(&call));
}
#[test]
fn test_parse_avnu_forwarder_call() {
let forwarder = felt("0x127021a1b5a52d3174c2ab077c2b043c80369250d29428cee956d76ee51584f");
let intender = felt("0x643130c3b10cbd7a1e2ea3cda084606d3d03971376780d1ae5a65c06cd26604");
let entrypoint = felt("0x34cc13b274446654ca3233ed2c1620d4c5d1d32fd20b47146a3371064bdc57d");
let inner_calldata = vec![
forwarder, felt("0x19337909"), Felt::from(1u64), Felt::from(1776181022u64), Felt::from(1u64), felt("0x377c2d65debb3978ea81904e7d59740da1f07412e30d01c5ded1c5d6f1ddc43"),
felt("0x2f0b3c5710379609eb5495f1ecd348cb28167711b73609fe565a72734550354"),
Felt::from(3u64), felt("0xaa"),
felt("0xbb"),
felt("0xcc"),
Felt::from(2u64),
felt("0xfeed"),
felt("0xbeef"),
];
let mut data = vec![
intender, entrypoint, Felt::from(inner_calldata.len() as u64), ];
data.extend_from_slice(&inner_calldata);
data.push(Felt::from(1u64)); data.push(felt("0xabcd"));
let call = RawCall {
contract_address: forwarder,
selector: felt("0x3d82f059"), data,
function_name: None,
function_def: None,
contract_abi: None,
};
assert!(is_avnu_forwarder(&forwarder));
let oe = parse_forwarder_call(&call).unwrap();
assert_eq!(oe.intender, intender);
assert_eq!(oe.caller, forwarder); assert_eq!(oe.execute_after, 1);
assert_eq!(oe.execute_before, 1776181022);
assert_eq!(oe.inner_calls.len(), 1);
assert_eq!(
oe.inner_calls[0].contract_address,
felt("0x377c2d65debb3978ea81904e7d59740da1f07412e30d01c5ded1c5d6f1ddc43")
);
assert_eq!(oe.inner_calls[0].data.len(), 3);
assert_eq!(oe.signature.len(), 2);
}
#[test]
fn test_parse_private_sponsored_basic() {
let forwarder = felt("0x127021a1b5a52d3174c2ab077c2b043c80369250d29428cee956d76ee51584f");
let pool = felt("0x40337b1af3c663e86e333bab5a4b28da8d4652a15a69beee2b677776ffe812a");
let apply_actions =
felt("0x246333a752c1ac637ff1591c5c885e27d56060d241a29aad8475072da0777db");
let inner_data = vec![
Felt::from(0xAAu64),
Felt::from(0xBBu64),
Felt::from(0xCCu64),
];
let mut data = vec![
Felt::from(1u64), pool,
apply_actions,
Felt::from(inner_data.len() as u64),
];
data.extend_from_slice(&inner_data);
data.extend_from_slice(&[Felt::from(0x1u64), felt("0xdeadbeef")]);
let call = RawCall {
contract_address: forwarder,
selector: EXECUTE_PRIVATE_SPONSORED_SELECTOR,
data,
function_name: Some("execute_private_sponsored".into()),
function_def: None,
contract_abi: None,
};
assert!(looks_like_private_sponsored(&call));
let oe = parse_private_sponsored(&call).expect("should parse");
assert_eq!(oe.intender, forwarder);
assert_eq!(oe.version, OutsideExecutionVersion::PrivateSponsored);
assert_eq!(oe.inner_calls.len(), 1);
assert_eq!(oe.inner_calls[0].contract_address, pool);
assert_eq!(oe.inner_calls[0].selector, apply_actions);
assert_eq!(oe.inner_calls[0].data, inner_data);
assert_eq!(oe.caller, Felt::ZERO);
assert_eq!(oe.nonce, Felt::ZERO);
assert_eq!(oe.signature.len(), 0);
}
#[test]
fn test_parse_private_sponsored_too_short() {
let call = RawCall {
contract_address: felt("0xabc"),
selector: EXECUTE_PRIVATE_SPONSORED_SELECTOR,
data: vec![Felt::from(1u64)], function_name: None,
function_def: None,
contract_abi: None,
};
assert!(parse_private_sponsored(&call).is_none());
}
}