seems your old __default__ wallet is broken, probably because its from pre 0.10.0?
I think an older version wallet is causing it. I tryied to deployed a new wallet with
starknet deploy account \
--account=coburn 
and updated my __default__ in 
~/starknet_wallets.json to the new one and it worked for me. 

and

starknet declare --contract contract_compiled.json 


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

Newton

following this page from the docs https://starknet.io/docs/hello_starknet/intro.html
I copied the code, compiled it using starknet compile, and when I go to declare it using starknet declare Im getting 
Status code: 500; text: {"code": "StarknetErrorCode.ENTRY_POINT_NOT_FOUND_IN_CONTRACT", "message": "Entry point <address>caed693fa4008dcdb4963b3 not found in contract with class hash <address>975148f6af3e9abddfdc701."}
Any help would be appreciated.

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

StarknetErrorCode.ENTRY_POINT_NOT_FOUND_IN_CONTRACT error in Cairo. Can anyone help?

How can I send a Uint256 amount of ERC20 tokens from L1 to starknet?
I have "amount" as a uint256 on L1 but how should I build my payload for "`sendMessageToL2`" to match the Uint256 format of Cairo?

---

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)

How can I send a Uint256 amount of ERC20 tokens from L1 to starknet? And how should I build my payload for "sendMessageToL2" to match the Uint256 format of Cairo?

How can I change solc compiler version in [warp](https://github.com/NethermindEth/warp)?

How can I change solc compiler version in warp?

Trying to install warp with command `yarn global add @nethermindeth/warp`

after successful install I try:
`warp install --verbose`
get this error:

```
zsh: command not found: warp
```


How to install Nethermind's Solidity to Cairo transpiler without an error "command not found: warp"?

## What is Kakarot, the zkEVM written in Cairo?


What is Kakarot, the zkEVM written in Cairo?

does cross-chain bridge produce its own block? or it only verify the blocks from A/B chain?

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

Does cross-chain bridge produce its own block? Or it only verify the blocks from A/B chain?

Can someone explain the difference `between unsigned_div_rem` and `uint256_unsigned_div_rem`?

Why unit version process so many extra steps, but overall number of steps for computing are different for these methods?



Can someone explain the difference between unsigned_div_rem and uint256_unsigned_div_rem?

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

StarknetErrorCode.ENTRY_POINT_NOT_FOUND_IN_CONTRACT error in Cairo. Can anyone help?

1 answers

Your answer

Related

You may find useful