To use a variable in a hint in Dairo it has to be a local variable. This is because when it does the hint execution it need the variable to be based on the function pointer instead of the allocation pointer, and only the local variable is based on the allocation pointer.


Just replace `let num1 = Uint256(20000, 0)`, with `local num1 : Uint256 = Uint256(20000, 0)`.


You also need to add `alloc_locals` to the beginning of your function.


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

I’m having a problem where I’m trying to use a Uint256 in a hint, but I keep getting this error


Here is my code:


`%builtins output range_check`


`﻿`


`from starkware.cairo.common.uint256 import (uint256_add, Uint256,`


 `uint256_mul)`


`from starkware.cairo.common.serialize import serialize_word`


`﻿`


`func main{output_ptr : felt*, range_check_ptr}():`


 `alloc_locals`


 `let num1 = Uint256(20000, 0)`


 `%{print(ids.num1)%}`


 `let num2 = Uint256(low=0,high=7)`


 `let (local mul_low : Uint256, local mul_high : Uint256) = uint256_mul(num1, num2)`


 `serialize_word(mul_high.low)`


`﻿`


 `return ()`


`end`


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

Cairo error "Expected expression of type 'starkware.cairo.common.uint256.Uint256' to have an address."

Some questions that could be answered separately.

1. The only way to invoke a contract is using migrations (this applies for both devnet and testnet?)
2. When doing a migration file I receive the “Hint is not whitelisted. This may indicate that this library function cannot be used in StarkNet contracts.” error. For example for this code:

```
%lang starknet

@external
func up() {
    %{
        contract_address = deploy_contract(
             "./build/main.json",
             config={"wait_for_acceptance": True}
        ).contract_address

        invoke(
            contract_address,
            "initialize",
            {"new_authority": 123},
            config={
                "auto_estimate_fee": True,
                "wait_for_acceptance": True,
            }
        )
    %}

    return ();
}
```

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

The only way to invoke a contract is using migrations (this applies for both devnet and testnet?)

I have a struct with : 

```struct Binary:
felt a:
felt* b:
```

How to return this in a view function?
I see this error:
```
Can't identify return variable
```


how to return struct

How do I run a Pathfinder node?

Hey!
I had a question about what would be the cleanest way to imitate a `uint32` or `uint64` in cairo. Two approaches came to mind:
1. Simply use a felt and check that is less than `2**32 - 1`
2. Pass a Uint256 and check that var.high == 0 and var.low is less than `2 ** 32 -1`

First approach seems straightforward, but I wanted to know if there was a convention for this or a better way.

How to check for smaller Uints in Cairo?

I have a question about creating elements via a function vs doing them directly. Here's a small gist: [https://gist.github.com/rlkelly/6cc8f4cce06762c3153fc7e3acaf9429](https://gist.github.com/rlkelly/6cc8f4cce06762c3153fc7e3acaf9429)

```
%lang starknet

from starkware.cairo.common.alloc import alloc

struct Foo:
    member val: felt
end

func make_foo(value: felt) -> (foo: Foo):
    let foo = Foo(
        val=value,
    )
    return (foo)
end

func make_foo_array() -> (entry: Foo*):
    let (struct_array : Foo*) = alloc()

    let foo0 = make_foo(0)
    assert struct_array[0] = foo0
    return (struct_array)
end

@external
func test_make_foo{syscall_ptr : felt*, range_check_ptr}():
    let (foo_array) = make_foo_array()
    return ()
end

#   File "starkware/cairo/lang/compiler/preprocessor/preprocessor.py", line 1223, in visit_CodeElementCompoundAssertEq
#  starkware.cairo.lang.compiler.preprocessor.preprocessor_error.PreprocessorError: contracts/tests/test_foo.cairo:22:5: Cannot compare '__main__.Foo' and '(foo : __main__.Foo)'.
```

i'm curious why `__main__.Foo` and `(foo : __main__.Foo)` are typed differently

it appears like `let foo =` and `let (foo) =`  allocate memory differently

Creating Elements via a function

What is the proper way to declare a string in Cairo?


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

Declaring Strings in Cairo

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

```
// The following function uses hints to efficiently compute the square root `res`
// of the argument `n`.
// The idea is that the verifier only needs to be convinced that res * res = n,
// it doesn't really care how res was computed.
// In such cases, we don't have to compute res in pure Cairo - we can write a
// piece of Python code inside the Cairo program, which is called a "hint".
// A hint is a piece of code that the prover runs to initialize
// some memory cells. Note that it is completely transparent from the verifier's
// point of view, so the result of the hint *must* be verified using pure Cairo
// instructions (e.g., the "assert n = res * res" instruction below).
//
// 1. Comment out the line "assert n = res * res;" and run the code. Does it still output
//    the expected value? Can you explain why the assert is nonetheless essential?
//    Hint: Recall that from the verifier's point of view, the hint does not exist.
// 2. Uncomment the assert line and change the function to compute the fourth
//    root.

%builtins output

from starkware.cairo.common.serialize import serialize_word

// Computes the square root (over the integers) of `n`.
// Prover assumption: The square root exists.
func sqrt(n) -> (res: felt) {
    alloc_locals;
    local res;

    // Set the value of res using a Python hint.
    %{
        import math

        # Use the ids variable to access the value of a Cairo variable.
        ids.res = int(math.sqrt(ids.n))
    %}

    // From the verifier's point of view, the hint is completely transparent.
    // The following line guarantees that `res` is the square root
    // (either the positive or negative) of `n`.
    assert n = res * res;
    return (res=res);
}

func main{output_ptr: felt*}() {
    let (res) = sqrt(256);
    serialize_word(res);
    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

Cairo error "Expected expression of type 'starkware.cairo.common.uint256.Uint256' to have an address."

1 answers

Your answer

Related

You may find useful