Hi,

I'm not sure to what `uint` is referring to. If you're referring to `uint256`, the "base" type of Solidity, then no, `felt` and `uint256` are not equivalent.

A `felt` corresponds to the size of the field on StarkNet, which is [2^251 + 17 * 2^192 + 1](https://starknet.io/docs/how_cairo_works/cairo_intro.html). You need to subtract `1` to this number to get biggest number that fits in a felt (since you need to account for the `0` number).

A `uint256` is 256 bits, i.e the biggest number that will fit in it will be `2^256 - 1` (again, subtracting 1 because of 0).

So to answer:

1.  
   
- `felt_max = 2^251 + 17 ^ 192 + 1 - 1
-  `uint256_max = 2^256 - 1

2. No they are not the same, `uint256_max > felt_max`


What is the maximum value a `uint` can store?

I need to understand a couple of things:

1. What is the maximum value `a felt` and `uint` can store?
2. Are the maximum values stored in felt and uint the same?

---
This question is participating in[ Newton Bounties | Incentivized Test Program](https://newtonso.notion.site/Newton-Bounties-Incentivized-Test-Program-94322ad48e7d40a3adcf36f6b26174cd) Every verified valid question gets $10 USDC (mainnet)

Newton

What is the maximum value an uint and felt can store in Cairo Language?

Since memory cannot be freed, what's the drawback of only using local variables (to avoid revoked refs)? What's the typical use case for tempvars?


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/512)_

Cairo: When do you use tempvar and when do you use local

heyy guys, running into a problem

I have this code :
```struct TokenLedger:
   member token_address : felt
   member drip_amount : Uint256
   member balance : Uint256
end

@storage_var
func tokens_ledger(index : felt) -> (tokenLedger : TokenLedger):
end```

```let (ledger : TokenLedger) = TokenLedger(token_address, drip_amount, balance)
tokens_ledger.write(index, ledger)```
But am getting this error :

```faucet.cairo:94:34: Unexpected '.' after '__main__.TokenLedger' which is struct.
let (ledger : TokenLedger)  = TokenLedger(token_detail.token_address, token_detail.drip_amount, curr_balance)
                                ^*********^

       Failed

Error in plugin Starknet: Failed compilation of 1 contract.```

How to write a struct in storage?

Why abi of warp compiled contract does not match original solidity abi?

Given a felt, I would like to get the sum of the digits. For example, 123 would be 1 + 2 + 3 = 6.


Test 1


Input(s): 123


Output(s): 6


Test 2


Input(s): 577


Output(s): 19


Test 3


Input(s): 88888


Output(s): 40


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/990)_

How to calculate the sum of the digits of a felt in Cairo?

Hey! I have a contract deployed on Testnet. Let's say its address is `0x1234`.

I want to get its ABI somehow, but I don't have the code of the contract, because it wasn't deployed by me.

I'm using StarkNet.py to interact with StarkNet.

Does anyone know the answer?

How to get the contract ABI using Starknet.Py?

I am working through [ex03](https://github.com/starknet-edu/starknet-cairo-101/blob/main/contracts/ex03.cairo) of starknet-cairo-101 and I noticed that I was not being charged a gas fee for calling `increment_counter` multiple times back to back, it only charged me once. Does anyone know why this is happening?


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/788)_

Did not have to pay gas fee when calling same function multiple times in Starknet?

Hello! This is day 13 of the 17 days of the Cairo Challenge. And I have no idea how to solve the [playground](https://www.cairo-lang.org/playground/) exercise “Pedersen Hash”.  Perhaps you can help me?

```
// The following code implements a Pedersen hash chain.
// Given the [Pedersen hash](https://docs.starkware.co/starkex-docs/crypto/pedersen-hash-function) function `H`, which
// takes two field elements and returns one representing their hash,
// a hash chain on inputs x_0, x_1, ..., x_n is the result of
// H(H(...H(H(x_0, x_1), x_2), ...,x_{n-1}), x_n)
// For example, the hash chain of (1, 2, 3, 4) is H(H(H(1, 2), 3), 4).
//
// Fix the function `hash_chain` to correctly implement the
// hash chain. Run your code to test it.
//
// Note: Don't use starkware.cairo.common.hash_chain (it computes the chain differently).

// Use the Pedersen builtin.
%builtins pedersen

from starkware.cairo.common.alloc import alloc
from starkware.cairo.common.cairo_builtins import HashBuiltin
from starkware.cairo.common.hash import hash2

// Computes the Pedersen hash chain on an array of size `length` starting from `data_ptr`.
func hash_chain{hash_ptr: HashBuiltin*}(data_ptr: felt*, length: felt) -> (result: felt) {
    if (length == 2) {
        let (result) = hash2(x=[data_ptr], y=[data_ptr + 1]);
        return (result=result);
    } else {
        // Fix here:
        return (result=123456);
    }
}

func main{pedersen_ptr: HashBuiltin*}() {
    alloc_locals;
    // Allocate a new array.
    let (local data_ptr: felt*) = alloc();
    // Fill the new array with field elements.
    assert [data_ptr] = 314;
    assert [data_ptr + 1] = 159;
    // Run the hash chain.
    let (result) = hash_chain{hash_ptr=pedersen_ptr}(data_ptr=data_ptr, length=2);
    // Check the result.
    assert result = 307958720726328212653290369969069617958360335228383070119367204176047090109;

    // Fill two more cells in the array.
    assert [data_ptr + 2] = 265;
    assert [data_ptr + 3] = 358;
    // Compute the hash chain on all four cells.
    let (result) = hash_chain{hash_ptr=pedersen_ptr}(data_ptr=data_ptr, length=4);
    assert result = 1828757374677754028678056220799392919487521050857166686061558043629802016816;
    return ();
}
```

---

> Answers to this question are a part of the ✨ 17 days of Cairo Lang with Playground & Newton. ✨
> 

*Vote for your favorite answer - the best answer will win a $10 award. A new day – a new reward! During the next 17 days, our goal is to attract more developers to the Cairo language and to systematize the knowledge of Cairo lang. [Read rules](https://www.notion.so/17-days-of-Cairo-Lang-with-Newton-550dfcda6a2d449ca468be293c776578)*

Popular tags

What is the maximum value an uint and felt can store in Cairo Language?

1 answers

Your answer

Related

You may find useful