Add is_some and is_none to Option type.

Description

The is_some and is_none methods return true if the Option is Some or None, respectively.
See https://doc.rust-lang.org/std/option/#querying-the-variant for the description of those functions.

Proposition

Proposed signature for is_some():

fn is_some() -> bool

Proposed signature for is_none():

fn is_none() -> bool

Less verbose/cheaper struct storage updates

Description

To read single attribute full struct needs to be read into memory, to update single struct attribute full struct needs to be rewritten. It is both more verbose than necessary and probably (depending on implementation) inefficient. More in depth problem description is here: https://hackmd.io/@RoboTeddy/BJZFu56wF#Concisely-update-large-structs.

Automaticaly generate trivial view functions for storage variables

Description

Trivial storage related view functions take a lot of space and make contracts diffucult to read and understand. It should be possible to mark storage variables as public (similar to Solidity public modifier). As a result a view function should be generated.

Proposition

Instead of:

struct Storage { 
 value: felt,
}
#[view]
fn value() -> felt {
 value::read()
}

use public 'modifier':

struct Storage { 
 #[public]
 value: felt,
}

bytes32 equivalent

Description

When working on cross chain apps, Cairo short strings are very inconvenient. Felt based short strings and their solidity counterpart bytes32 are of diffrent lenght(251 vs 256) and of different encoding (left vs right padding). There is no easy conversion between the two.

Proposition

There should be a bytes32 equivalent type available in Cairo. The usual operations: comparison, bit operators, shift operators, index access should be available.

See: https://docs.soliditylang.org/en/v0.8.17/types.html#fixed-size-byte-arrays

I would love to have /* */ multi-line commenting as I often need to add large blocks of text to contextualize the code I write.

Support structs as l1_handler parameters

Description

Currently when, for example Uint256 is send from l1 to l2 it needs to be manually converted to the desired type:

@l1_handler
func handle_deposit{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 from_address: felt,
 amount_low: felt,
 amount_high: felt,
 sender_address: felt,
) {
 let amount = Uint256(low=amount_low, high=amount_high);

When there are more than one struct the code gets noisy.

Proposition

When structs are supported as l1_handler parameters, above would be more readble:

@l1_handler
func handle_deposit{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
 from_address: felt,
 amount: Uint256,
 sender_address: felt,
) {

It would be nice if we can have a float type. I know it's not as easy as people think to create but it would help a lot programmers 🚀

It's functionality can be improve

It would be awesome to have a cairo plugin for Intellij.

StarkNet Cairo should allow function overloading. To make this possible, we will need to modify the function selector calculation to include the input types and the function name.
This change will affect type-checking and remote contract calls from the language perspective. However, resolving these is easy because we can statically determine which instance of the function is being used.
Since we can statically resolve function overloading, it doesn't introduce any performance overhead.

Adding an is_empty() fn on Array Trait could be very handy
(I know I could do arr.len() == 0_usize, but isn't arr.is_empty() way more readable?)

add address type

Description

Currently felt type is used to represent contract addreses, e.g.:

 fn transfer_from(sender: felt, recipient: felt, amount: u256)

Proposition

There should be an address type to represent contract addresses:

 fn transfer_from(sender: address, recipient: address, amount: u256)

Optimize usage of storage

Let's assume I have a struct:
struct { some_field1: u8, some_field2: u32, some_field3: u64 }

It should underneath be all contained in one felt rather than 3 separate felts to use the less possible storage on L1.

What do you think about providing access the contract context inside of starknets StorageAccess trait? I'm not sure exactly how that would look. Perhaps it is easier once we have the new contract syntax.

It would allow us to add access control directly at the storage level, which seems much more robust and less error prone.

One approach could be a Ownable<T> struct that wraps values but that would duplicate the owner state for each variable.

Support for get_blockhash

Arrays can be defined in the constant pool and support initialization data.

Description

We are using Cairo to rewrite a Solidity ERC721 contract. This contract defines five arrays, each containing 30 to 60 different short strings. In the contract functions, a random string from each array is selected and concatenated to form a complete name. In Cairo, we cannot define and initialize arrays directly in the contract. Currently, we are manually writing indexes using LegacyMap to achieve this.

21693301815_ pic
31693301850_ pic
41693301884_ pic

Proposition

We want to directly define string array data in the contract.

I want a map-like data structure (Array or Dict) that supports multiple levels of nesting, random write and can be used in memory, without relying on LegacyMap structures in storage.

I want '<<' and '>>' Operators. They provide left shift and right shift features with less gas cost.

In solidity contract, we can user block.number to get current block number, but i do not know how to get block number in cairo contract.

I know i can use get_caller_address() to get like msg.sender. but how can i get msg.value in cairo?

how can i remove a element in Array by index? I can not find this method.

if we write legacyMap use the same key, whether will replace the value??

Proof verification within a cairo program would be a massive step forward in building fully decentralized state machines!

I want Base64 utils that could support type like Array<felt252>

i wanna deploy contract on remix easily

Make it possible to store functions inside variables.

This will make it possible to, among other things, support more functional programming paradigms:

• Pass functions as parameters to other functions - e.g. will allow to define map, filter, reduce etc. on Arrays. Will allow iterator-related methods.
• Return functions as results from other functions
• Define scoped (local) functions inside other functions

Big DEV QOL improvement would be the possibility to make mutation testing.
You'd run the tool, it would make some tweak in the code (for example changing a <= to a <) and expect a test to fail.
This could be a big improvement for checking some edge cases that are not correctly tested or detect a big if the tests are correct.
Existing tools are:

• https://github.com/nfurfaro/hunter
• https://github.com/JoranHonig/vertigo

Hey guys! Does the VSCode extension works on Windows? I'm struggling to make it work on Windows but it doesn't work. Someone use it on Windows?

1. Yep, my scarb is running in PowerShell.
   image

2. I changed manually the path to scarb in my VSCode configuration:

image

This notification appeared on the screen:
image

In the output this is the error message:
image