idk if you already read this ? [https://www.cairo-lang.org/docs/how_cairo_works/builtins.html#range-checks](https://www.cairo-lang.org/docs/how_cairo_works/builtins.html#range-checks)

the eternal question almost no one at starknet has been able to answer for months!

I have had eventually quite recently a definitive answer from Dan Carmon, copied here below:

it could have been possible to have the basic range_check call be for 250 bits, but that would have made it more expensive per call. If I'm not mistaken (which I may be), the actual basic range check is 16-bit, and a 128-bit range check is actually made of 8 16-bit range checks, already wrapped together by the builtin. To have a 250-bit range check you would need to use 16 16-bit range checks, which would mean that you could only fit half as many in the same number of steps. As Shahar said, you can simulate 250-bit range check with 3 128-bit ones, and 128-bit with 2 250-bit ones, so the decision of which is better depends mostly on what is more common. I believe our opinion was that in many use cases, 128 bits would be more than enough, and the cases where 250 bits are both necessary and sufficient would be relatively rarer, so using the slightly smaller range check would be better optimized for the common use case.

Bumped into rc_bound today and was wondering: where/how is it defined and why is it much smaller than the field prime?

Newton

Cairo: Where/how is it defined and why is it much smaller than the field prime?

How do I get the function selector or the hash from the function name in Cairo?


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

Cairo: Getting function selector

Hello! This is day 12 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 “Structs.  Perhaps you can help me?

```
// In this challenge you're going to implement a stack using a linked list.
//
// Add the missing code so that main() runs successfully.

from starkware.cairo.common.registers import get_fp_and_pc

struct Node {
    // A pointer to the next node in the stack.
    next: Node*,

    // The value of the node.
    value: felt,

    // The number of elements in the stack.
    size: felt,
}

// Returns an empty stack.
func empty_stack() -> (stack: Node*) {
    alloc_locals;
    local new_node: Node;
    assert new_node.next = cast(0, Node*);
    assert new_node.value = 0;
    assert new_node.size = 0;

    // The usage of get_fp_and_pc() here is necessary in order
    // to access the address of a local variable (&new_node).
    // You can read more about get_fp_and_pc() [here](https://cairo-lang.org/docs/how_cairo_works/functions.html#retrieving-registers).
    let (local __fp__, _) = get_fp_and_pc();
    return (stack=&new_node);
}

// Adds a node to the top of the stack.
// Returns the updated stack (since Cairo is immutable, you can still use the
// old copy of the stack).
func push(stack: Node*, value: felt) -> (stack: Node*) {
    alloc_locals;
    local new_node: Node;
    // Fix and uncomment below.
    // assert new_node.next = ...
    // assert new_node.value = ...
    // assert new_node.size = ...

    let (__fp__, _) = get_fp_and_pc();
    return (stack=&new_node);
}

// Removes the top element of the stack.
// Returns the updated stack and the element that was removed.
func pop(stack: Node*) -> (stack: Node*, value: felt) {
    return (stack=stack.next, value=stack.value);
}

// Returns the value of the n-th element from the top of the stack.
func stack_at(stack: Node*, n: felt) -> (value: felt) {
    if (n == 0) {
        // Add your code here.
    }

    // Add your code here.
}

func main() -> () {
    alloc_locals;
    // Start with an empty stack.
    let (stack) = empty_stack();
    // Push 1, 10, 100.
    let (stack) = push(stack, 1);
    let (stack) = push(stack, 10);
    let (local stack) = push(stack, 100);

    // Check the size of the stack.
    assert stack.size = 3;

    // Query the stack at indices 0, 1 and 2.
    let (value) = stack_at(stack, 0);
    assert value = 100;
    let (value) = stack_at(stack, 1);
    assert value = 10;
    let (value) = stack_at(stack, 2);
    assert value = 1;

    // Pop the top 2 values (100 and 10) and push 1000.
    let (stack, value) = pop(stack);
    assert value = 100;
    let (stack, value) = pop(stack);
    assert value = 10;
    let (local stack) = push(stack, 1000);

    // Query the stack at indices 0 and 1.
    let (value) = stack_at(stack, 0);
    assert value = 1000;
    let (value) = stack_at(stack, 1);
    assert value = 1;

    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)*

How to create Structs in Cairo Lang for StarkNet?


In SNARKs, you can use [Zokrates](https://zokrates.github.io/gettingstarted.html#hello-zokrates) or [snarkjs](https://github.com/iden3/snarkjs) to generate a proof for a program/computation and verify it, locally or on Ethereum.


Similar to [this unanswered question](https://github.com/starkware-libs/cairo-lang/issues/2), how to do the same in Cairo and STARK for, say, [the 15-puzzle](https://www.cairo-lang.org/docs/hello_cairo/puzzle.html)?


Can `cairo-run` generate a proof, or only a trace?


I can send it to [SHARP](https://www.cairo-lang.org/docs/sharp.html) with `cairo-sharp`, but I can't generate nor see the proof locally. Any way to generate the proof by running my own prover without SHARP?



ㅤ
_This question was originally posted on [Stack Overflow](https://stackoverflow.com/questions/73056271/how-to-generate-a-proof-for-a-cairo-program-and-verify-it)_

How to generate a proof for a Cairo program and verify it?

How to get private key/mnemonic for account that been created using `deploy_account`?
or can i using existing 12 words mnemonic to create contract account?

_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

How to get private key/mnemonic for account that been created using `deploy_account` [StarkNet]?

Hey,
As each storage value is by default initialized to 0, does writing it to zero actually do something? Does it use storage in layer 1 with value 0? Or does it just do nothing?
Should I check that the value I want to write is different than 0 before writing it otherwise I will waste storage?

The same idea: does writing a storage value to 0 free storage on l1

Does writing it to zero actually do something?

Are there situations in which we prefer declaring variables as `local` vs `tempvar`?
I understand that both are used to avoid variables being revoked, curious to know if they are different in any way
Thread


_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Are there situations in which we prefer declaring variables as `local` vs `tempvar`?

I am trying to store a negative number, and then on a function call, read it. But I only get the positive `felt` number.


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

Popular tags

Cairo: Where/how is it defined and why is it much smaller than the field prime?

2 answers

Your answer

Related

You may find useful