Problem

Right now when we call new_caller or new_invoker, we pass provider ownership. Which cause us to recreate multiple providers when we initiate contract.

    let provider =
        AnyProvider::JsonRpcHttp(JsonRpcClient::new(HttpTransport::new(rpc_url.clone())));

    ...
    // Call.
    let contract_caller = MyContract::new_caller(contract_address, provider).await?;
    let val = contract_caller.get_val().await?;

    // Work in progress to avoid this duplication.
    let provider2 =
        AnyProvider::JsonRpcHttp(JsonRpcClient::new(HttpTransport::new(rpc_url.clone())));

    ...
    // Invoke.
    let contract_invoker =
        MyContract::new_invoker(contract_address, provider2, account_address, signer).await?;
    contract_invoker.set_val(FieldElement::TWO).await?;

Possible approach

Pass provider into reference so that we can use one provider for caller and invoker.

We might can create init struct like this and pass it.

ContractSetup {
   address,
   provider,
   Option<account_address>,
   Option<private_key>
}

#14

• signer / provider is all reference ( can reuse )
• use generic input ( P : Provider, A: Account )
• update abigen macro using builders pattern with_account

TODO

• if not use with_account, contract which accept generic P : Provider, A: Account, will return error bcs they don't know A's specific type. Current temporary solution is explicitly define P & A if not using with_account. Can open other issue

get function type abi as string and turn it's inputs and outputs into cairo-types

Abi string as input

{
    "type": "function",
    "name": "hello_world",
    "inputs": [
      {
        "name": "value",
        "type":"core::array::Array::<core::felt252>"
      }
    ],
    "outputs": [
      {
        "type": "core::array::Array::<core::felt252>"
      }
    ],
    "state_mutability": "view"
  },

AbiType for core::array::Array::<core::felt252>

AbiType::Nested(
            "array".to_string(),
            vec![AbiType::Nested(
                AbiType::Basic("core::felt252".to_string()),
            )],
        );
        

CairoType as output

fn hello_world(value : Vec<FieldElement>) -> Vec<FieldElement> 

• [ ] function string -> abiType -> tokenType::FunctionToken
• [ ] tokenType::FunctionToken -> turn into cairo-types

Create a folder with examples of expanded code for contracts:

• [X] Simple contract with only basic types (no struct, no enum, no array).
• [ ] ~Contract with array.~
• [X] Contract with tuples no generics.
• [X] Contract with tuples and generics.
• [X] Contract with enum only (and basics of course), with no generic.
• [X] Contract with enum and generic enums.
• [X] Contract with struct only (no generic).
• [X] Contract with struct and generic structs.

For all of these, we have to write a rust file for the expanded contract with:

// (If struct and enum)
// First, expand the types and their `CairoType` implementation as necessary.

struct ContractA {
...
}

impl ContractA {
   // Implement call and invoke using the types.
}

For now, tuples are only supported for size 2.

Write a macro that impl CairoType for several sizes.

If it's not easily possible, at least implement tuple until size 5.

For now, the abigen macro is expecting a string to be a file.

Modify this behavior to detect if:

1. One line is given (and ends with .json ?) -> it's a file.
2. Multiline -> directly consider the string value as the ABI to be parsed.

This will allow easy testing to avoid writing ABI files, but direclty in literal string in the code.

In this file the implementation of CairoType trait is done manually for each integer types.

Consider writing a macro to auto-generate those, and adding a file for each of the int types.

This issue is about uint8,16,..128 and int8,16....

Right now we use lowercase to 1) Cairo type representation in Rust 2) Original Rust type in uint, int, bool. But I think it's not good practice to have exact same name with original rust type. Maybe we can use remco/uint to Cairo type in Rust as uppercase struct ( Alloy did same approach ).

reference

https://github.com/alloy-rs/core/blob/main/crates/dyn-abi/src/resolve.rs

Consideration

Event, I might also use struct and enum expansion. If then, we cannot distinguish between struct & eventStruct and enum & eventEnum. The difference between those two is, event type have one more parameter which is kind.

      {
        "name": "user",
        "type": "core::starknet::contract_address::ContractAddress",
        "kind": "key"
      },

Right now not sure how we can use event if we could expand in macro. We can get event data from transaction recept, and the type of this is felt, so might be useful to have (de)serialization method for event.

So not sure kind is important or not. => Decided to implement independent expansion in event.rs, which will handle kind also.

Then later if we could find out that field is not using, can refactor using current expansion of struct and enum.

Goal

• Contract should be initialize with or without account. ( Builder pattern )
• Without account, we only provide Provider. With account, we provide Provider and Account both.
• We want to give flexibility of both Provider and Account, defined generic as P: Provider and A: Account.

Current Problem

• When we initialize without Account, because contract struct is already defined with 2 generic parameters, it returns error because we didn't specified A: Account generic's type.
• So our current code not use generic types for Provider and Account. But able to initialize with/without account.

 // Call.
let my_contract = MyContract::new(contract_address, &provider);
 // Invoke.
let mycontract = MyContract::new(contract_address, &provider).with_account(&account).await?;

Some inspirations

• ethers-rs approach : use different struct. Add different string to the name of contract and function

   abigen!(
        SimpleContract,
        r#"[
        struct Foo { uint256 x; }
        function foo(Foo memory x)
        function bar(uint256 x, uint256 y, address addr)
        yeet(uint256,uint256,address)
    ]"#,
        derives(serde::Deserialize, serde::Serialize)
    );
 let contract = SimpleContract::new(Address::default(), Arc::new(client));
 let call = BarCall { x: 1u64.into(), y: 0u64.into(), addr: Address::random() };
 let contract_call = SimpleContractCalls::Bar(call);

• alloy : use same struct for contract but different name for function.

// This is the same as:
sol! {
   interface MyJsonContract2 {
       struct MyStruct {
           bool[] a;
           bytes18[][] b;
       }

       function foo(uint256 bar, MyStruct baz) external view;
   }
}

#[test]
fn abigen() {
   assert_eq!(
       MyJsonContract1::fooCall::SIGNATURE,
       MyJsonContract2::fooCall::SIGNATURE,
   );
}

As in ethers-rs, a use may pass all the additional trait that may be derived automatically for a struct/enum.

abigen!(MyContract, "abi.json", [Serialize, Deserialize, ...])

Or do we want to, by default, implement them?

What's the best manner to generate the code emitted by the abigen macro?

1. Use a scope?
2. Create a module?
3. Export into a new file to allow code DRY?
4. Anonymous const?
5. Other?