Imagine you have the following code:


```
tempvar x = 2;
let y = x * x * x;
let z = y * y * y;
serialize_word(z);
```


Because of the `let`s, the `serialize_word(z)` is equivalent to
`serialize_word(x * x * x * x * x * x * x * x * x)`
.

"tempvar" stands for "temporary variable", which means that
a variable will be allocated for the intermediate values
(`x * x * x` and `y * y * y`). If you change the two `let`s to `tempvar`s and run the program this reduces the same computation to use only 4 steps and 2 new variables.

`let` is used to declare a reference.  `let` keyword **doesn't create** an instruction, it simply replace reference by value. Example, everywhere I use x, compiler will replace it by 10.

```
let x = 10;
serialize_word(x);
```
equivalent to

```
serialize_word(10);
```

`tempvar` is used to declare a variable. It means we will take memory to store my variable. And `tempvar` keyword will create an instruction.

I'm new to Cairo and I want to know what is the difference when I write `let x = 1;` and `tempvar x = 1;`. Is there any difference in Cairo Lang between let and tempvar?

Hypobrai

Cairo: let vs tempvar what is the difference?

I'm trying to make a FixedPoint cairo lib, but I'm having some trouble making a pow function. 

It's inspired by this function

```solidity

    function pow(
        uint256 x,
        uint256 y,
        uint256 base
    ) internal pure returns (uint256 z) {
        assembly {
            switch x
            case 0 {
                switch y
                case 0 {
                    // 0 ** 0 = 1
                    z := base
                }
                default {
                    // 0 ** y = 0
                    z := 0
                }
            }
            default {
                switch mod(y, 2)
                case 0 {
                    // If y is even, store base in z for now.
                    z := base
                }
                default {
                    // If y is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, base)

                for {
                    // Shift y right by 1 before looping to halve it.
                    y := shr(1, y)
                } y {
                    // Shift y right by 1 each iteration to halve it.
                    y := shr(1, y)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xSquared, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xSquared := mul(x, x)

                    // Round to the nearest number.
                    let xSquaredRound := add(xSquared, half)

                    // Revert if xSquared + half overflowed.
                    if lt(xSquaredRound, xSquared) {
                        revert(0, 0)
                    }

                    // Set x to scaled xSquaredRound.
                    x := div(xSquaredRound, base)

                    // If n is even:
                    if mod(y, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, base)
                    }
                }
            }
        }
    }
```

and I wrote this one in Cairo

```cairo
    func pow{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr: felt}(
        x: Uint256,
        n: Uint256,
        baseUnit: Uint256
    ) -> (res: Uint256) {
        alloc_locals;

        let (xIsZero) = uint256_eq(x, Uint256(low=0, high=0));

        if(xIsZero == TRUE) {
            let (nIsZero) = uint256_eq(n, Uint256(low=0, high=0));
            if(nIsZero == TRUE) {
                // 0**0 = 1
                return (res=Uint256(low=1, high=0));
            } 
            // 0**n = 0
            return (res=Uint256(low=0, high=0));            
        }

        let (nHalf, nHalfRem) = uint256_unsigned_div_rem(n, Uint256(low=2, high=0));
        let (nIsEven) = uint256_eq(nHalfRem, Uint256(low=0, high=0));
        let (z) = _assignZIf(nIsEven, baseUnit, x);

        let (baseUnitHalf, baseUnitHalfRem) = uint256_unsigned_div_rem(baseUnit, Uint256(low=2, high=0));

        let (res) = pow_loop(x, nHalf, z, baseUnit, baseUnitHalf);

        return (res=res);
    }

    func pow_loop{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr: felt}(
        x: Uint256, 
        n: Uint256, 
        z: Uint256,
        baseUnit: Uint256,
        baseUnitHalf: Uint256
    ) -> (res: Uint256) {
        alloc_locals;
    
        let (n_LteOne) = uint256_le(n, Uint256(low=1, high=0));
        
        if(n_LteOne == TRUE) {
            return (res=z);
        }

        let (xx, xxOverflow) = uint256_mul(x, x);
        assert xxOverflow.low = 0;
        assert xxOverflow.high = 0;

        let (xxRound, xSquaredRoundCarry) = uint256_add(xx, baseUnitHalf);
        let (roundingOverflowed) = uint256_lt(xxRound, xx);
        assert roundingOverflowed = FALSE;

        let (temp_x, temp_x_rem) = uint256_unsigned_div_rem(xxRound, baseUnit);

        let (nHalf, nHalfRem) = uint256_unsigned_div_rem(n, Uint256(low=2, high=0));
        let (nHalfIsEven) = uint256_eq(nHalfRem, Uint256(low=0, high=0));
        if(nHalfIsEven ==  TRUE) {
            let (zx, zxOverflow) = uint256_mul(z, x);
            assert zxOverflow.low = 0;
            assert zxOverflow.high = 0;

            let (shouldBeZ, shouldBeZRem) = uint256_unsigned_div_rem(zx, x);
            let (zxNotOverflowed) = uint256_eq(shouldBeZ, z);
            assert zxNotOverflowed = TRUE;

            let (zxRound, zxRoundCarry) = uint256_add(zx, baseUnitHalf);
            let (zxRoundOverflowed) = uint256_lt(zxRound, zx);
            assert zxRoundOverflowed = FALSE;

            let (temp_z, temp_zRem) = uint256_unsigned_div_rem(zxRound, baseUnit);
            return pow_loop(x=temp_x, n=nHalf, z=temp_z, baseUnit=baseUnit, baseUnitHalf=baseUnitHalf);
        } else {
            return pow_loop(x=temp_x, n=nHalf, z=z, baseUnit=baseUnit, baseUnitHalf=baseUnitHalf);
        }
    }

    func _assignZIf{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr: felt}(
        nIsEven: felt,
        baseUnit: Uint256,
        x: Uint256
    ) -> (res: Uint256) {
        if(nIsEven == TRUE) {
            return (res=baseUnit);
        }
        return (res=x);
    }
```

The thing is that I don't get the same results.

Here are some example of my results compared to the solidity function

- pow(1, 3, 10^18): Cairo = 1 / Solidity = 0

- pow(10^18, 5, 10^18): Cairo = 4000000000000000000 (4x10^18) / Solidity = 32000000000000000000 (32x10^18)

- pow(10^19, 5, 10^18): Cairo = 100000000000000000000 (10^20) / Solidity = 100000000000000000000000 (10^23)

I can't see what I'm doing wrong in my code

Fixed Point pow operation error

Hello. Does starknet have name service? what is the difference between starknet id and starknet name service? Are they same projects?

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

Does starknet have name service? 

In the following function I am presented with the following error, even though my code does not make it to this function. What am I doing wrong?


`func fill_in_row{output_ptr: felt*}(row_idx : felt, row_size : felt, curr_row : felt*) {` 


 `if (row_idx == row_size-2) {`


 `return ();`


 `}`


 `let val : felt = curr_row[row_idx-1] + curr_row[row_idx];`


 `serialize_word(val);`


 `curr_row[row_idx+1] = val;`


 `return fill_in_row(row_idx+1, row_size, curr_row);`


`}`


Error: code:80:5: While expanding the reference 'curr_row' in:


 curr_row[row_idx+1] = val;


 ^******^


code:72:73: Expected a register. Found: [fp + (-4)].


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

Cairo Error: Getting Error while setting value of item in array

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?

I have the following code:


`@external`


`func updateCurrNum{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(updatedNum : felt):`


 `let (isOwner) = isOwner()`


 `assert isOwner = 1`


`...`


And I am getting this error: 


Unexpected '.' after '__main__.updateCurrNum.isOwner' which is future.


 let (isOwner) = isOwner()


 ^*****^


What am I doing wrong?


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

Cairo error for Unexpected '.' after ... which is future

Hey guys,
I'm wondering:
- What **hashing functions** are available now with Cairo?
- What are the **advantages/disadvantages** of each, like computation, security?

So far I know some:
- [keccak](https://github.com/starkware-libs/cairo-lang/tree/master/src/starkware/cairo/common/cairo_keccak)
- Pedersen hash, which can be used to hash chain, [here](https://www.newton.so/view/63427472405280f6d1cf502d)
- [sha256 extension](https://github.com/cartridge-gg/cairo-sha256) of the starkware implementation which can Computes SHA256 of 'input'. Inputs of arbitrary length are supported.

Happy hashing :)



Popular tags

Cairo: let vs tempvar what is the difference?

2 answers

Your answer

Related

You may find useful