Yes! Warp will try to find the path to node_modules and pass the correct flags to the solc compiler. If your openzeppelin or other library contracts are located somewhere else you can the base-path and include-path flags to make sure your imports work. See https://docs.soliditylang.org/en/v0.8.17/path-resolution.html#base-path-and-include-paths for the relevant docs.


victorforissier.eth

I'm currently trying to transpile an ERC 721 contract I have that uses openzeppelin libraries, is that possible?

Why should I run a Pathfinder node?

Can someone explain to me what Implicit arguments are? How do they work in Cairo lang?

What Implicit arguments are in Cairo lang?

Why am I getting the error message `“ArgumentsLengthError: The number of the given arguments (0) do not match what is defined in the ABI (1)”`


ApeWorX: Why am I getting the error message "ArgumentsLengthError"?

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



What hashing functions are available in Cairo? How are they secure?

In solidity I can add an error message as the 2nd argument to require, like: `require(<some_condition>, "My error message");`


Is there an equivalent way to do this in a starknet contract? Like for `assert some_var = 0`


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

Cairo: How do I write a custom error message when an assert fails?

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

```
// The program below lets you choose a number `x` and output its square `y = x*x`
// (proving that you know the square root of `y`).
//
// 1. Replace "YOUR_NUMBER" with a value of your choice, run the program and
//    make sure you get the expected output (the square of the value you chose).
//
// Take a look at the output line saying "Program hash: ...".
// The program hash is the (Pedersen) hash of the compiled program.
//
// 2. The compiled program does not include the [hints](https://cairo-lang.org/docs/how_cairo_works/hints.html),
//    so changing any code within a hint does not change the resulting program
//    hash.
//    Try changing `x` to a different number and note that the program hash remains
//    unchanged after rerunning.
//
// The Cairo SHARP collects several programs and creates a proof that they ran
// successfully. Such a batch of programs is called a "train".
// Note that it may take a while until a train is created, as the service waits
// to collect enough programs (after a certain amount of time, the train will
// be dispatched, even if it's not full).
//
// 3. Click on "Prove with SHARP" to prove the program using the shared proving service.
//
// After the proof is created, SHARP sends it to an [Ethereum goerli contract](https://goerli.etherscan.io/address/0xAB43bA48c9edF4C2C4bB01237348D1D7B28ef168).
// For each job in the train, a corresponding fact is registered on the contract,
// attesting to the validity of the run with its particular output.
//
// 4. You can monitor the status of your job, using the link in the output pane.
//
// For each job, the corresponding fact is computed as follows:
//   keccak(program_hash, keccak(program_output))
// where:
// * program_hash is the hash of the compiled program, which you can find in
//   the output pane (32 bytes).
// * program_output is the output of the program as a list of 32-byte
//   elements.
//
// For example, if you chose x=3, the output will be [9] and you can compute
// the fact in Python using:
//
//   from web3 import Web3
//
//   program_hash = 0x114952172aed91e59f870a314e75de0a437ff550e4618068cec2d832e48b0c7
//   program_output = [9]
//   Web3.solidityKeccak(['uint256', 'bytes32'], [
//     program_hash,
//     Web3.solidityKeccak(['uint256[]'], [program_output])
//   ])
//
// You can also find your job's fact in the SHARP tracking page you opened
// in step 4.
//
// 5. Once you see that the fact is registered, you can call the
//    [contract's isValid() method](https://goerli.etherscan.io/address/0xAB43bA48c9edF4C2C4bB01237348D1D7B28ef168#readContract) to make sure it's indeed registered.

%builtins output

from starkware.cairo.common.serialize import serialize_word

func main{output_ptr: felt*}() {
    alloc_locals;
    local x;
    %{ ids.x = YOUR_NUMBER %}

    serialize_word(x * x);
    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)*

What is SHARP in Cairo Language?

I’m signing a message using 
```
account.signMessage(data) 
```
and immediately verifying the signature with the same data and it’s returning false. I don’t see any issue open on this subject on starknet.js. Is this something you’ve already encountered by any chance?

here’s the code:

```python
const data = { types: proposeTypes, primaryType: 'Propose', domain, message };
const sig = await user.account.signMessage(data);
let res = await user.account.verifyMessage(data, sig); // returns `false`
```

I see that’s the expected way to use signMessage through the tests (https://github.com/0xs34n/starknet.js/blob/b20819424dea824c96ac31e0542733c84d87d441/__tests__/account.test.ts#L125-L126).

So I guess something’s going wrong when it comes to either hashing the data and signing it or hashing the data and verifying the signature?


btw: for those wondering: `verifyMessage` only works if the account is deployed: if you’re doing this with an account not deployed (basically just a keypair) then this won’t work :)

Popular tags

I'm currently trying to transpile an ERC 721 contract I have that uses openzeppelin libraries, is that possible?

1 answers

Your answer

Related

You may find useful