Are the errors correct? If so and you want to turn off the formatting, you can remove/uninstall your cairo extension. If the errors are not correct, can you post the code and what formatter you are using?


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

I'm getting a lot of error squiggles showing Cairo compilation errors. I wonder how I may turn that off?


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

How to disable error squiggles for Cairo Compiler in VS Code


I've written a couple contracts for L1 (Ethereum) and L2 (Starknet) and have them communicate [here](https://www.cairo-lang.org/docs/hello_starknet/l1l2.html).


I can see that L1 sent the message I'm expecting, see [this TX on etherscan](https://goerli.etherscan.io/tx/0x28f3c1021672431d81b34cc141b49a927ae9c989b1521f12b971c45e9717b1f6). The last message in there however never executed on my L2 contract. I'm trying to figure out whether the L2 Sequencer has invoked the handler function of my contract and if so, whether/how it failed.


Does anyone here know how to find the TX that handles the invoke on L2? Or any other ideas/tools that would help figuring out why the l1\_handler never executed/failed?



ㅤ
_This question was originally posted on [Stack Overflow](https://stackoverflow.com/questions/72239816/checking-result-of-an-l1-l2-message-invoke-in-starknet)_

Checking result of an L1 -> L2 message/invoke 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)*

How to use Pedersen Hash in StarkNet / Cairo Language?

I want to transfer ether in Cairo, can I do this with a payable function? If not, how can I achieve this?


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

Does cairo have payable functions?

Hello! This is day 11 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 “Address of locals”.  Perhaps you can help me?

```
// When Cairo needs to retrieve the *address* of a local variable,
// it needs to be told the value of the frame pointer register, fp
// (see [here](https://cairo-lang.org/docs/how_cairo_works/functions.html#fp-register)).
//
// This can be done by setting a reference named __fp__ to the value, which
// can be obtained using the library function get_fp_and_pc().
//
// 1. Try to run the code as-is, and make sure you understand the error.
// 2. Uncomment the line setting __fp__, and run again.
//    The code should now work and you should be able to see that `x` was set
//    to 1000.
// 3. Uncomment the line calling foo() and try to run the code.
//    Fix the code by adding exactly one word to it.
//    Hint: Revisit the "Revoked references" challenge.

from starkware.cairo.common.registers import get_fp_and_pc

// Returns a^3 for a != 0 and 1 otherwise.
func foo(a) -> (res: felt) {
    if (a == 0) {
        return (res=1);
    } else {
        return (res=a * a * a);
    }
}

func main() -> () {
    alloc_locals;

    // let (__fp__, _) = get_fp_and_pc();
    local x: felt;
    // let (x) = foo(a=10);
    local y: felt* = &x;
    assert [y] = 1000;
    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 use get_fp_and_pc in Cairo Lang?

Looking to call the approve and transfer functions for an erc-20 in the same transaction. Thoughts on how to do this?


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

Cairo: How can i approve erc20 and transfer in the same transaction?

What will the bundler ecosystem look like in AA?

---

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

What will the bundler ecosystem look like in Account Abstraction?

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

How to disable error squiggles for Cairo Compiler in VS Code

1 answers

Your answer

Related

You may find useful