Cairo contracts support three types of variables, each serving a different purpose:
  1. Local Variables
    • Temporary variables within functions
    • Exist only during function execution
    • Not stored on the blockchain
  2. Storage Variables
    • Defined in the contract’s Storage
    • Persist between contract executions
    • Stored on the blockchain
  3. Global Variables
    • Provide blockchain context and information
    • Accessible anywhere in the contract
    • Read-only system variables

​
Local Variables

Local variables are temporary variables that exist only within their defined scope (a function or code block). Key characteristics:
  • Stored in memory, not on the blockchain
  • Used for intermediate calculations and temporary data
  • Available only during function execution
  • Help improve code readability by naming values
Here’s an example demonstrating local variable scope: 
#[starknet::contract]
mod LocalVariablesContract {
    #[storage]
    struct Storage {}

    pub fn do_something(value: u32) -> u32 {
        // This variable is local to the current block.
        // It can't be accessed once it goes out of scope.
        let increment = 10;

        {
            // The scope of a code block allows for local variable declaration
            // We can access variables defined in higher scopes.
            let sum = value + increment;
            sum
        }
        // We can't access the variable `sum` here, as it's out of scope.
    }
}}

​
Storage Variables

Storage variables provide persistent state for your contract on the blockchain. They have these properties:
  • Persist between contract executions
  • Can be read for free (no transaction needed)
  • Require a transaction to write to them
  • Must be defined in the contract’s Storage struct
Here’s an example showing storage variable usage: 
#[starknet::interface]
trait IStorageVariable<TContractState> {
    fn set(ref self: TContractState, value: u32);
    fn get(self: @TContractState) -> u32;
}

#[starknet::contract]
mod StorageVariablesContract {
    // You need to import these storage functions to read and write to storage variables
    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
    use super::IStorageVariable;

    // All storage variables are contained in a struct called Storage
    // annotated with the `#[storage]` attribute
    #[storage]
    struct Storage {
        // Storage variable holding a number
        value: u32,
    }

    #[abi(embed_v0)]
    impl StorageVariables of IStorageVariable<ContractState> {
        // Write to storage variables by sending a transaction
        // that calls an external function
        fn set(ref self: ContractState, value: u32) {
            self.value.write(value);
        }

        // Read from storage variables without sending transactions
        fn get(self: @ContractState) -> u32 {
            self.value.read()
        }
    }
}
Reading is a free operation, with no transaction needed.Writing requires a transaction and costs gas.

​
Global Variables

Global variables provide access to blockchain context and system information. In Starknet:
  • Accessed through core library functions
  • Available anywhere in the contract
  • Provide critical blockchain context (e.g., caller address, block info)
Example using global variables: 
#[starknet::contract]
pub mod GlobalVariablesContract {
    // import the required functions from the starknet core library
    use starknet::get_caller_address;

    #[storage]
    struct Storage {}

    pub fn foo(ref self: ContractState) {
        // Call the get_caller_address function to get the sender address
        let _caller = get_caller_address();
        // ...
    }
}