Support spans in data transformer (#3163)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #3136

## Introduced changes

<!-- A brief description of the changes -->

- Added support for using Spans in data transformer through
`array![...].span()`.

## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [x] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [x] Added changes to `CHANGELOG.md`

---------

Co-authored-by: ksew1 <[email protected]>

Author: cptartur

CHANGELOG.md

@@ -19,6 +19,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Cast
 
+#### Added
+
+- Support for `array![].span()` in `--arguments` command
+
 #### Changed
 
 - `verify` command now supports the `--class-hash` for Walnut verification

crates/data-transformer/src/sierra_abi/binary.rs

@@ -0,0 +1,62 @@
+use crate::sierra_abi::SupportedCalldataKind;
+use crate::sierra_abi::data_representation::AllowedCalldataArgument;
+use anyhow::{Result, bail, ensure};
+use cairo_lang_parser::utils::SimpleParserDatabase;
+use cairo_lang_syntax::node::ast::{
+    BinaryOperator, Expr, ExprBinary, ExprFunctionCall, PathSegment,
+};
+use cairo_lang_syntax::node::{Terminal, TypedSyntaxNode};
+use starknet::core::types::contract::AbiEntry;
+
+impl SupportedCalldataKind for ExprBinary {
+    fn transform(
+        &self,
+        expected_type: &str,
+        abi: &[AbiEntry],
+        db: &SimpleParserDatabase,
+    ) -> Result<AllowedCalldataArgument> {
+        let op = self.op(db);
+        let lhs = self.lhs(db);
+        let rhs = self.rhs(db);
+
+        if !matches!(op, BinaryOperator::Dot(_)) {
+            let op = op.as_syntax_node().get_text_without_trivia(db);
+            bail!(r#"Invalid operator, expected ".", got "{op}""#)
+        }
+
+        let Expr::InlineMacro(lhs) = lhs else {
+            let lhs = lhs.as_syntax_node().get_text_without_trivia(db);
+            bail!(r#"Only "array![]" is supported as left-hand side of "." operator, got "{lhs}""#);
+        };
+
+        let Expr::FunctionCall(rhs) = rhs else {
+            let rhs = rhs.as_syntax_node().get_text_without_trivia(db);
+            bail!(r#"Only calling ".span()" on "array![]" is supported, got "{rhs}""#);
+        };
+
+        assert_is_span(&rhs, db)?;
+        let expected_type = expected_type.replace("Span", "Array");
+        lhs.transform(&expected_type, abi, db)
+    }
+}
+
+fn assert_is_span(expr: &ExprFunctionCall, db: &SimpleParserDatabase) -> Result<()> {
+    match expr
+        .path(db)
+        .elements(db)
+        .last()
+        .expect("Function call must have a name")
+    {
+        PathSegment::Simple(simple) => {
+            let function_name = simple.ident(db).text(db);
+            ensure!(
+                function_name == "span",
+                r#"Invalid function name, expected "span", got "{function_name}""#
+            );
+            Ok(())
+        }
+        PathSegment::WithGenericArgs(_) => {
+            bail!("Invalid path specified: generic args in function call not supported")
+        }
+    }
+}

crates/data-transformer/src/sierra_abi/mod.rs

@@ -4,6 +4,7 @@ use cairo_lang_syntax::node::ast::Expr;
 use data_representation::AllowedCalldataArgument;
 use starknet::core::types::contract::AbiEntry;
 
+mod binary;
 mod complex_types;
 pub(super) mod data_representation;
 mod literals;
@@ -40,8 +41,8 @@ pub(super) fn build_representation(
         Expr::FunctionCall(item) => item.transform(expected_type, abi, db),
         Expr::InlineMacro(item) => item.transform(expected_type, abi, db),
         Expr::Tuple(item) => item.transform(expected_type, abi, db),
+        Expr::Binary(item) => item.transform(expected_type, abi, db),
         Expr::Parenthesized(_)
-        | Expr::Binary(_)
         | Expr::Block(_)
         | Expr::Match(_)
         | Expr::If(_)

crates/data-transformer/tests/data/data_transformer/Scarb.toml

@@ -0,0 +1,23 @@
+[package]
+name = "data_transformer_contract"
+version = "0.1.0"
+edition = "2024_07"
+
+# See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
+
+[dependencies]
+starknet = "2.10.0"
+alexandria_data_structures = "0.4.0"
+
+[dev-dependencies]
+snforge_std = "0.39.0"
+assert_macros = "2.10.0"
+
+[[target.starknet-contract]]
+sierra = true
+
+[scripts]
+test = "snforge test"
+
+[tool.scarb]
+allow-prebuilt-plugins = ["snforge_std"]

crates/data-transformer/tests/data/data_transformer/src/lib.cairo

@@ -0,0 +1,105 @@
+#[derive(Serde, Drop)]
+pub struct SimpleStruct {
+    a: felt252,
+}
+
+#[derive(Serde, Drop)]
+pub struct NestedStructWithField {
+    a: SimpleStruct,
+    b: felt252,
+}
+
+#[derive(Serde, Drop)]
+pub enum Enum {
+    One: (),
+    Two: u128,
+    Three: NestedStructWithField,
+}
+
+#[derive(Serde, Drop)]
+pub struct ComplexStruct {
+    a: NestedStructWithField,
+    b: felt252,
+    c: u8,
+    d: i32,
+    e: Enum,
+    f: ByteArray,
+    g: Array<felt252>,
+    h: u256,
+    i: (i128, u128),
+}
+
+#[derive(Serde, Drop)]
+pub struct BitArray {
+    bit: felt252,
+}
+
+#[starknet::interface]
+pub trait IDataTransformer<TContractState> {
+    fn simple_fn(ref self: TContractState, a: felt252);
+    fn u256_fn(ref self: TContractState, a: u256);
+    fn signed_fn(ref self: TContractState, a: i32);
+    fn unsigned_fn(ref self: TContractState, a: u32);
+    fn tuple_fn(ref self: TContractState, a: (felt252, u8, Enum));
+    fn complex_fn(
+        ref self: TContractState,
+        arr: Array<Array<felt252>>,
+        one: u8,
+        two: i16,
+        three: ByteArray,
+        four: (felt252, u32),
+        five: bool,
+        six: u256,
+    );
+    fn simple_struct_fn(ref self: TContractState, a: SimpleStruct);
+    fn nested_struct_fn(ref self: TContractState, a: NestedStructWithField);
+    fn enum_fn(ref self: TContractState, a: Enum);
+    fn complex_struct_fn(ref self: TContractState, a: ComplexStruct);
+    fn external_struct_fn(
+        ref self: TContractState, a: BitArray, b: alexandria_data_structures::bit_array::BitArray,
+    );
+    fn span_fn(ref self: TContractState, a: Span<felt252>);
+}
+
+#[starknet::contract]
+mod DataTransformer {
+    use super::*;
+    use core::starknet::ContractAddress;
+
+    #[storage]
+    struct Storage {
+        balance: felt252,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, init_owner: ContractAddress) {}
+
+    #[abi(embed_v0)]
+    impl DataTransformerImpl of super::IDataTransformer<ContractState> {
+        fn simple_fn(ref self: ContractState, a: felt252) {}
+        fn u256_fn(ref self: ContractState, a: u256) {}
+        fn signed_fn(ref self: ContractState, a: i32) {}
+        fn unsigned_fn(ref self: ContractState, a: u32) {}
+        fn tuple_fn(ref self: ContractState, a: (felt252, u8, Enum)) {}
+        fn complex_fn(
+            ref self: ContractState,
+            arr: Array<Array<felt252>>,
+            one: u8,
+            two: i16,
+            three: ByteArray,
+            four: (felt252, u32),
+            five: bool,
+            six: u256,
+        ) {}
+        fn simple_struct_fn(ref self: ContractState, a: SimpleStruct) {}
+        fn nested_struct_fn(ref self: ContractState, a: NestedStructWithField) {}
+        fn enum_fn(ref self: ContractState, a: Enum) {}
+        fn complex_struct_fn(ref self: ContractState, a: ComplexStruct) {}
+        fn external_struct_fn(
+            ref self: ContractState,
+            a: BitArray,
+            b: alexandria_data_structures::bit_array::BitArray,
+        ) {}
+        fn span_fn(ref self: ContractState, a: Span<felt252>) {}
+    }
+}

crates/data-transformer/tests/integration.rs

@@ -13,9 +13,9 @@ use test_case::test_case;
 use tokio::sync::OnceCell;
 use url::Url;
 
-// https://sepolia.starkscan.co/class/0x02a9b456118a86070a8c116c41b02e490f3dcc9db3cad945b4e9a7fd7cec9168#code
+// Deployment of contract from /tests/data/data_transformer
 const TEST_CLASS_HASH: Felt =
-    Felt::from_hex_unchecked("0x02a9b456118a86070a8c116c41b02e490f3dcc9db3cad945b4e9a7fd7cec9168");
+    Felt::from_hex_unchecked("0x032e6763d5e778f153e5b6ea44200d94ec89aac7b42a0aef0e4e0caac8dafdab");
 
 static CLASS: OnceCell<ContractClass> = OnceCell::const_new();
 
@@ -435,6 +435,113 @@ async fn test_happy_case_nested_struct_function_cairo_expression_input() -> anyh
     Ok(())
 }
 
+#[tokio::test]
+async fn test_happy_case_span_function_cairo_expression_input() -> anyhow::Result<()> {
+    let contract_class = CLASS.get_or_init(init_class).await.to_owned();
+
+    let input = String::from("array![1, 2, 3].span()");
+
+    let result = Calldata::new(input)
+        .serialized(contract_class, &get_selector_from_name("span_fn").unwrap())?;
+
+    let expected_output = [
+        Felt::from_hex_unchecked("0x3"),
+        Felt::from_hex_unchecked("0x1"),
+        Felt::from_hex_unchecked("0x2"),
+        Felt::from_hex_unchecked("0x3"),
+    ];
+
+    assert_eq!(result, expected_output);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_happy_case_empty_span_function_cairo_expression_input() -> anyhow::Result<()> {
+    let contract_class = CLASS.get_or_init(init_class).await.to_owned();
+
+    let input = String::from("array![].span()");
+
+    let result = Calldata::new(input)
+        .serialized(contract_class, &get_selector_from_name("span_fn").unwrap())?;
+
+    let expected_output = [Felt::from_hex_unchecked("0x0")];
+
+    assert_eq!(result, expected_output);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_span_function_array_input() {
+    let contract_class = CLASS.get_or_init(init_class).await.to_owned();
+
+    let input = String::from("array![1, 2, 3]");
+
+    let result = Calldata::new(input)
+        .serialized(contract_class, &get_selector_from_name("span_fn").unwrap());
+
+    result
+        .unwrap_err()
+        .assert_contains(r#"Expected "core::array::Span::<core::felt252>", got array"#);
+}
+
+#[tokio::test]
+async fn test_span_function_unsupported_method() {
+    let contract_class = CLASS.get_or_init(init_class).await.to_owned();
+
+    let input = String::from("array![1, 2, 3].into()");
+
+    let result = Calldata::new(input)
+        .serialized(contract_class, &get_selector_from_name("span_fn").unwrap());
+
+    result
+        .unwrap_err()
+        .assert_contains(r#"Invalid function name, expected "span", got "into""#);
+}
+
+#[tokio::test]
+async fn test_span_function_unsupported_operator() {
+    let contract_class = CLASS.get_or_init(init_class).await.to_owned();
+
+    let input = String::from("array![1, 2, 3]*span()");
+
+    let result = Calldata::new(input)
+        .serialized(contract_class, &get_selector_from_name("span_fn").unwrap());
+
+    result
+        .unwrap_err()
+        .assert_contains(r#"Invalid operator, expected ".", got "*""#);
+}
+
+#[tokio::test]
+async fn test_span_function_unsupported_right_hand_side() {
+    let contract_class = CLASS.get_or_init(init_class).await.to_owned();
+
+    let input = String::from("array![1, 2, 3].span");
+
+    let result = Calldata::new(input)
+        .serialized(contract_class, &get_selector_from_name("span_fn").unwrap());
+
+    result
+        .unwrap_err()
+        .assert_contains(r#"Only calling ".span()" on "array![]" is supported, got "span""#);
+}
+
+#[tokio::test]
+async fn test_span_function_unsupported_left_hand_side() {
+    let contract_class = CLASS.get_or_init(init_class).await.to_owned();
+
+    let input = String::from("(1, 2, 3).span");
+
+    let result = Calldata::new(input)
+        .serialized(contract_class, &get_selector_from_name("span_fn").unwrap());
+
+    result.unwrap_err().assert_contains(
+        r#"Only "array![]" is supported as left-hand side of "." operator, got "(1, 2, 3)""#,
+    );
+}
+
 #[tokio::test]
 async fn test_happy_case_enum_function_empty_variant_cairo_expression_input() -> anyhow::Result<()>
 {
@@ -451,6 +558,7 @@ async fn test_happy_case_enum_function_empty_variant_cairo_expression_input() ->
 
     Ok(())
 }
+
 #[tokio::test]
 async fn test_happy_case_enum_function_one_argument_variant_cairo_expression_input()
 -> anyhow::Result<()> {

docs/src/starknet/calldata-transformation.md

@@ -73,6 +73,7 @@ Cast supports most important Cairo corelib types:
 * `EthAddress`
 * `bytes31`
 * `Array` - using `array![]` macro
+* `Span` - using `array![].span()` macro and function call
 
 Numeric types (primitives and `felt252`) can be paseed with type suffix specified for example `--arguments 420_u64`.