use std::collections::HashMap;
use serde::Deserialize;
use starknet::core::types::{
CompressedLegacyContractClass, ContractClass, Felt, FlattenedSierraClass,
LegacyContractAbiEntry,
};
use starknet::core::utils::get_selector_from_name;
use tracing::{debug, warn};
pub const ABI_SCHEMA_VERSION: u32 = 1;
#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct ParsedAbi {
#[serde(default)]
pub schema_version: u32,
pub functions: HashMap<FeltKey, FunctionDef>,
pub events: HashMap<FeltKey, EventDef>,
#[serde(default)]
pub structs: HashMap<String, AbiStructDef>,
#[serde(default)]
pub enums: HashMap<String, AbiEnumDef>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct FeltKey(pub Felt);
impl serde::Serialize for FeltKey {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&format!("{:#x}", self.0))
}
}
impl<'de> serde::Deserialize<'de> for FeltKey {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let s = String::deserialize(deserializer)?;
Felt::from_hex(&s)
.map(FeltKey)
.map_err(serde::de::Error::custom)
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct FunctionDef {
pub name: String,
pub inputs: Vec<(String, String)>, pub outputs: Vec<String>,
pub state_mutability: Option<String>,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct EventDef {
pub name: String,
pub keys: Vec<(String, String)>, pub data: Vec<(String, String)>,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct AbiStructDef {
pub name: String,
pub members: Vec<(String, String)>, }
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct AbiEnumDef {
pub name: String,
pub variants: Vec<(String, String)>, }
impl ParsedAbi {
pub fn is_empty(&self) -> bool {
self.functions.is_empty() && self.events.is_empty()
}
pub fn get_function(&self, selector: &Felt) -> Option<&FunctionDef> {
self.functions.get(&FeltKey(*selector))
}
pub fn get_event(&self, selector: &Felt) -> Option<&EventDef> {
self.events.get(&FeltKey(*selector))
}
}
pub fn parse_contract_class(class: &ContractClass) -> ParsedAbi {
match class {
ContractClass::Sierra(sierra) => parse_sierra_abi(sierra),
ContractClass::Legacy(legacy) => parse_legacy_abi(legacy),
}
}
fn parse_sierra_abi(class: &FlattenedSierraClass) -> ParsedAbi {
let mut abi = ParsedAbi::default();
let mut abi_json = std::borrow::Cow::Borrowed(class.abi.as_str());
while let Ok(inner) = serde_json::from_str::<String>(&abi_json) {
abi_json = inner.into();
}
let items: Vec<SierraAbiItem> = match serde_json::from_str(&abi_json) {
Ok(items) => items,
Err(e) => {
warn!(error = %e, "Failed to parse Sierra ABI JSON");
return abi;
}
};
for item in &items {
match item {
SierraAbiItem::Function(f) | SierraAbiItem::L1Handler(f) => {
if let Ok(selector) = get_selector_from_name(&f.name) {
abi.functions.insert(
FeltKey(selector),
FunctionDef {
name: f.name.clone(),
inputs: f
.inputs
.iter()
.map(|p| (p.name.clone(), p.r#type.clone()))
.collect(),
outputs: f.outputs.iter().map(|p| p.r#type.clone()).collect(),
state_mutability: f.state_mutability.clone(),
},
);
}
}
SierraAbiItem::Event(e) => {
let event_name = extract_event_name(&e.name);
if let Ok(selector) = get_selector_from_name(&event_name) {
let (keys, data) = e.keys_and_data();
abi.events.insert(
FeltKey(selector),
EventDef {
name: event_name,
keys,
data,
},
);
}
}
SierraAbiItem::Interface(iface) => {
for f in &iface.items {
if let SierraAbiItem::Function(func) | SierraAbiItem::L1Handler(func) = f
&& let Ok(selector) = get_selector_from_name(&func.name)
{
abi.functions.insert(
FeltKey(selector),
FunctionDef {
name: func.name.clone(),
inputs: func
.inputs
.iter()
.map(|p| (p.name.clone(), p.r#type.clone()))
.collect(),
outputs: func.outputs.iter().map(|p| p.r#type.clone()).collect(),
state_mutability: func.state_mutability.clone(),
},
);
}
}
}
SierraAbiItem::Struct(s) => {
abi.structs.insert(
s.name.clone(),
AbiStructDef {
name: s.name.clone(),
members: s
.members
.iter()
.map(|m| (m.name.clone(), m.r#type.clone()))
.collect(),
},
);
}
SierraAbiItem::Enum(e) => {
abi.enums.insert(
e.name.clone(),
AbiEnumDef {
name: e.name.clone(),
variants: e
.variants
.iter()
.map(|v| (v.name.clone(), v.r#type.clone()))
.collect(),
},
);
}
_ => {} }
}
abi.schema_version = ABI_SCHEMA_VERSION;
debug!(
functions = abi.functions.len(),
events = abi.events.len(),
structs = abi.structs.len(),
enums = abi.enums.len(),
"Parsed Sierra ABI"
);
abi
}
fn parse_legacy_abi(class: &CompressedLegacyContractClass) -> ParsedAbi {
let mut abi = ParsedAbi::default();
let entries = match &class.abi {
Some(entries) => entries,
None => return abi,
};
for entry in entries {
match entry {
LegacyContractAbiEntry::Function(f) => {
if let Ok(selector) = get_selector_from_name(&f.name) {
abi.functions.insert(
FeltKey(selector),
FunctionDef {
name: f.name.clone(),
inputs: f
.inputs
.iter()
.map(|p| (p.name.clone(), p.r#type.clone()))
.collect(),
outputs: f.outputs.iter().map(|p| p.r#type.clone()).collect(),
state_mutability: f
.state_mutability
.as_ref()
.map(|s| format!("{:?}", s)),
},
);
}
}
LegacyContractAbiEntry::Event(e) => {
if let Ok(selector) = get_selector_from_name(&e.name) {
abi.events.insert(
FeltKey(selector),
EventDef {
name: e.name.clone(),
keys: e
.keys
.iter()
.map(|p| (p.name.clone(), p.r#type.clone()))
.collect(),
data: e
.data
.iter()
.map(|p| (p.name.clone(), p.r#type.clone()))
.collect(),
},
);
}
}
LegacyContractAbiEntry::Struct(s) => {
abi.structs.insert(
s.name.clone(),
AbiStructDef {
name: s.name.clone(),
members: s
.members
.iter()
.map(|m| (m.name.clone(), m.r#type.clone()))
.collect(),
},
);
}
}
}
abi.schema_version = ABI_SCHEMA_VERSION;
debug!(
functions = abi.functions.len(),
events = abi.events.len(),
"Parsed legacy ABI"
);
abi
}
#[derive(Debug, Clone, Deserialize)]
#[serde(tag = "type")]
enum SierraAbiItem {
#[serde(rename = "function")]
Function(SierraFunctionDef),
#[serde(rename = "l1_handler")]
L1Handler(SierraFunctionDef),
#[serde(rename = "constructor")]
Constructor(SierraFunctionDef),
#[serde(rename = "event")]
Event(SierraEventDef),
#[serde(rename = "struct")]
Struct(SierraStructDef),
#[serde(rename = "enum")]
Enum(SierraEnumDef),
#[serde(rename = "interface")]
Interface(SierraInterfaceDef),
#[serde(rename = "impl")]
Impl(SierraImplDef),
}
#[derive(Debug, Clone, Deserialize)]
struct SierraFunctionDef {
name: String,
#[serde(default)]
inputs: Vec<SierraParam>,
#[serde(default)]
outputs: Vec<SierraOutput>,
state_mutability: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
struct SierraParam {
name: String,
r#type: String,
}
#[derive(Debug, Clone, Deserialize)]
struct SierraOutput {
r#type: String,
}
#[derive(Debug, Clone, Deserialize)]
struct SierraEventDef {
name: String,
#[serde(default)]
kind: String,
#[serde(default)]
members: Vec<SierraEventMember>,
#[serde(default)]
variants: Vec<SierraEventVariant>,
}
#[derive(Debug, Clone, Deserialize)]
struct SierraEventMember {
name: String,
r#type: String,
kind: String, }
#[derive(Debug, Clone, Deserialize)]
struct SierraEventVariant {
name: String,
r#type: String,
kind: String,
}
#[derive(Debug, Clone, Deserialize)]
struct SierraStructDef {
name: String,
#[serde(default)]
members: Vec<SierraParam>,
}
#[derive(Debug, Clone, Deserialize)]
struct SierraEnumDef {
name: String,
#[serde(default)]
variants: Vec<SierraParam>,
}
#[derive(Debug, Clone, Deserialize)]
struct SierraInterfaceDef {
name: String,
#[serde(default)]
items: Vec<SierraAbiItem>,
}
#[derive(Debug, Clone, Deserialize)]
struct SierraImplDef {
name: String,
interface_name: String,
}
fn extract_event_name(full_name: &str) -> String {
full_name
.rsplit("::")
.next()
.unwrap_or(full_name)
.to_string()
}
type NamedField = (String, String);
impl SierraEventDef {
fn keys_and_data(&self) -> (Vec<NamedField>, Vec<NamedField>) {
let mut keys = Vec::new();
let mut data = Vec::new();
for m in &self.members {
let pair = (m.name.clone(), m.r#type.clone());
match m.kind.as_str() {
"key" => keys.push(pair),
"data" => data.push(pair),
_ => data.push(pair),
}
}
(keys, data)
}
}
#[cfg(test)]
mod tests {
use super::*;
use starknet::core::types::EntryPointsByType;
fn sierra_with_abi(abi: String) -> FlattenedSierraClass {
FlattenedSierraClass {
sierra_program: vec![],
contract_class_version: "0.1.0".into(),
entry_points_by_type: EntryPointsByType {
constructor: vec![],
external: vec![],
l1_handler: vec![],
},
abi,
}
}
#[test]
fn parses_plain_and_multiply_encoded_sierra_abi() {
let abi = r#"[{"type":"function","name":"transfer","inputs":[],"outputs":[],"state_mutability":"external"}]"#;
let double = serde_json::to_string(abi).unwrap();
let triple = serde_json::to_string(&double).unwrap();
let selector = get_selector_from_name("transfer").unwrap();
for raw in [abi.to_string(), double, triple] {
let parsed = parse_sierra_abi(&sierra_with_abi(raw));
assert_eq!(parsed.get_function(&selector).unwrap().name, "transfer");
}
}
}