Chapter 3: Cairo Starknet Programming- Memory and Data Structures

Cairo’s reminiscence version, with its immutability and non-determinism, is a key innovation that allows the green execution and verification of programs at the StarkNet blockchain. While it offers precise challenges for programmers, it also gives considerable blessings in terms of security, performance, and scalability.

Understanding the Cairo Memory Model

The Cairo memory model is a unique aspect of the Cairo programming language, designed for writing programs on the StarkNet blockchain. Here’s a breakdown:

Key Characteristics

• Immutable Memory:
  • The core principle is immutability. Once a memory location is written, its value cannot be directly modified.
  • To “modify” a variable, Cairo creates a new memory location with the updated value, effectively “shadowing” the old one.
• Write-Once Principle:
  • A memory location can only be written to once. This restriction is crucial for Cairo’s underlying proof system, which relies on the predictable nature of memory writes.
• Non-Deterministic Initialization:
  • The initial values of memory cells are not pre-defined. The prover (the entity verifying the program’s correctness) has some flexibility in choosing these initial values, as long as the chosen values do not contradict the program’s logic.

Implications

• Programming Style:
  • Programmers need to adapt to this immutable paradigm. Instead of modifying variables in place, they need to create new variables with updated values.
• Performance:
  • Memory’s write-once nature can influence performance outcomes. Unnecessary memory allocations should be avoided to optimize performance. Techniques like memory reuse and careful variable scoping are crucial for efficient memory management.
• Proof Generation:
  • Generating proofs of program correctness becomes easier with the immutable memory model. The prover can efficiently verify the program’s behavior without the need to track complex state changes.

Key Points to Remember:

• Immutability: The core concept, where values cannot be directly changed.
• Write-Once: Each memory location can be written only once.
• Non-Deterministic Initialization: Initial values are not fixed, providing flexibility for the prover.
• Programming Implications: Requires a different approach to variable modification.
• Performance Considerations: Optimize memory usage to avoid inefficiencies.
• Proof Generation: Simplifies the verification process.

Arrays in Cairo

• Ordered sequences containing elements that are of the same type.
• Fixed Size: The length of an array ought to be recognised at assemble time.
• Access: Using a zero-based index, elements are retrieved.

Example:

Code snippet

let my_array: felt252[5] = [1, 2, 3, 4, 5]; 
let first_element = my_array[0]; // Accessing the first element

Tuples in Cairo

• Ordered collections of elements that can be of different data types.
• Fixed Size: The size of a tuple is determined at compile time.
• Access: Elements are accessed using their zero-based position.

Example:

Code snippet

let my_tuple: (felt252, bool, String) = (10, true, "hello"); 
let first_element = my_tuple[0]; // Accessing the first element (felt252)

Key Differences

• Data Type: Arrays preserve elements of the same type, even as tuples can hold factors of different kinds.
• Flexibility: Arrays are more restrictive in phrases of statistics kind, at the same time as tuples offer greater flexibility.

Note:

• In Cairo, due to the immutable memory model, modifying elements within an array or tuple directly is not possible.
• To “modify” a value, you would typically create a new array or tuple with the updated values.

Structs in Cairo

• Custom Data Structures: Structs assist you to institution related records fields into a single unit.
• Benefits:
  • Improved Code Organization: Enhance code clarity and maintainability with the aid of grouping associated facts together.
  • Data Encapsulation: Encapsulate records inside a single unit, making it easier to manage and purpose about.
  • Reusability: Define reusable statistics systems that can be used at some stage in your code.

Example:

Code snippet

struct Point {
    x: felt252,
    y: felt252,
}

let origin: Point = Point { x: 0, y: 0 }; 

In this example:

• We define a struct named Point with two fields: x and y, both of type felt252.
• We create a new instance of the Point struct named origin and initialize its x and y coordinates to 0.

Accessing Struct Fields

To access a struct’s fields, you use the dot (.) operator.

Code snippet

let x_coordinate = origin.x; 

Nested Structs

Structs can also contain other structs as fields:

Code snippet

struct Rectangle {
    top_left: Point,
    bottom_right: Point,
}

Key Points

• Structs are a effective tool for organizing and handling records in Cairo.
• They contribute to clearer, greater maintainable, and reusable code.
• Structs can contain fields of various records sorts, along with different structs.

Hash Maps: A Key-Value Data Structure

• Core Concept: The storage method in hash maps is based on key-value pairs.
  • Key: A unique identifier for each piece of data.
  • Value: The associated data itself.
• Efficient Retrieval:
  • Hash maps use a hash function to map keys to specific locations (indices) within the underlying data structure (often an array).
  • This allows for fast lookups of values based on their keys, typically in constant time (O(1)) on average.

Collision Handling

• Collisions: When two different keys hash to the same index, it’s called a collision.
• Common Techniques:
  • Separate Chaining: Each index in the array holds a linked list to store multiple key-value pairs that hash to the same index.
  • Open Addressing: When a collision occurs, the hash map probes for an empty slot to store the new value.

Applications of Hash Maps

• Dictionaries:
  • Implementing dictionaries where you can quickly look up definitions or translations based on words.
• Caching:
  • Storing frequently accessed data (like function results or database queries) for faster retrieval.
• Indexing:
  • Creating efficient data structures for searching and sorting large datasets.
• Symbol Tables:
  • In compilers and interpreters, used to store and quickly look up variables and their associated values.
• Routing Tables:
  • In networking, used by routers to efficiently route packets based on destination addresses.
• Database Indexing:
  • Used to create indexes on database tables to speed up data retrieval queries.

In Summary

Hash maps are a fundamental data structure with numerous applications due to their efficient key-based retrieval.They are widely used in various domains, from programming languages and databases to networking and caching systems.

Storage Patterns in Cairo

• Cairo’s Storage:
  • Persistent: Data stored in Cairo’s storage is persistent across function calls. This means that the data remains available even after the function that wrote it has finished executing.
  • Key-Value Store: Cairo utilizes a key-value store for its storage. You store data associated with a unique key, and you can later retrieve that data by providing the key.
• Common Storage Patterns:
  • Storing Account Data:
    • Keys: Account addresses (unique identifiers for each account on the blockchain).
    • Values:
      • Account balances
      • Nonces are utilized to avoid replay attacks.
      • Other relevant account information
  • Storing Smart Contract State:
    • Keys: Can vary depending on the specific needs of the contract. For example:
      • A unique identifier for a particular piece of data within the contract.
      • An index or counter.
    • Values:
      • Contract variables
      • Data structures used by the contract
  • Storing Off-Chain Data:
    • Hashing: Hash the off-chain data (e.g., a document, an image).
    • Storing the Hash: Store only the hash of the off-chain data on-chain.
    • Benefits:
      • Verifies the integrity of the off-chain data without storing the entire data on-chain (which can be expensive).
      • Reduces storage costs.

Key Considerations:

• Storage Costs: Storing information on-chain has associated expenses. Consider the dimensions of the statistics and the frequency of updates whilst finding out what to keep on-chain.
• Data Security: Ensure the security of your data by carefully choosing keys and implementing appropriate access control mechanisms.
• Gas Costs: Storing and retrieving data from storage incurs gas costs (the fees for executing transactions on the blockchain). Reduce storage usage to lower gas costs.

Note:

• This is a general overview. Specific storage patterns and best practices will vary depending on the requirements of your Cairo program.

FAQ

• Memory Allocation for Arrays:
  • Arrays in Cairo have a fixed size.
  • If you need a dynamically sized collection, use libraries that implement lists or vectors.
• Accessing Tuple Elements:
  • Access elements in a tuple using their zero-based position.
• Advantages of Structs:
  • Enhanced structure of the code, better data encapsulation, and improved reusability.
• Hash Collisions in Cairo:
  • Cairo libraries often provide hash map implementations with built-in collision resolution mechanisms.
• Costs of Storing Data On-Chain:
  • Storage costs on the Cairo blockchain can vary.
  • Consider the dimensions of the records and the frequency of updates while finding out what to store on-chain.

FAQ:

• How do I allocate reminiscence for an array in Cairo?
  • Arrays in Cairo typically have a fixed size. If you need a dynamically sized collection, consider using a library that implements lists or vectors.
• How do I access elements in a tuple?
  • Access elements in a tuple using their position (index), starting from 0.
• What are the advantages of using structs?
  • Improved the organization of the code, encapsulation of data, and overall reusability.
• How do I handle hash collisions in Cairo?
  • Cairo libraries often provide implementations of hash maps with built-in collision resolution mechanisms.
• What are the costs of storing data on-chain?
  • Storage charges at the Cairo blockchain can range. Consider the size of the information and the frequency of updates while determining what to store on-chain.