No their results are different, we recommend using keccak256 because the Cairo standard library has an implementation for it so Warp can support it. There is no sha256 implementation in the Cairo standard library yet.
Since both of them output a 256 bit key in most cases you can replace sha256 with keccak256, there might other considerations to make depending on your protocol, example if there is an off-chain sha256 being checked on chain then you'll need to change the off-chain component.
Additionally in real world solidity codebases we did not observe sha256 being used a lot, so its lower on our priority list compared to other features.

why does keccak256 replace sha256 in warp transpiler? I want to know: are they technically identical or different?

I am asking because I haven't the support of sha256 on [Github](https://github.com/NethermindEth/warp)

![sha256 is not supported in warp, use keccak256 instead](https://res.cloudinary.com/varga/image/upload/v1671461992/Screen_Shot_2022-12-19_at_18.58.51_dawd8x.png)

vargastartup

why does keccak256 replace sha256 in warp?

What libraries are secure to use in the Cairo language? How to know which library is audited? 

What libraries are secure to use in Cairo?


Hello! This is day 16 of the 17 days of the Cairo Challenge. In this exercise it is required to submit your first StarkNet contract. When you try to make it, you get an error:

```solidity
Error: code:20:1: Unsupported %lang directive. Are you using the correct compiler?
%lang starknet
^************^
```

Can you show your solution to [playground](https://www.cairo-lang.org/playground/) exercise “StarkNet contract” and also send a link to your contract, and a screenshot where you use your `add` method?

```solidity
// [StarkNet](https://starkware.co/product/starknet/) is a permissionless decentralized ZK-Rollup operating
// as an L2 network over Ethereum, where any dApp can achieve
// unlimited scale for its computation, without compromising
// Ethereum's composability and security.
//
// This is a simple StarkNet contract.
// Note that you won't be able to use the playground to compile and run it,
// but you can deploy it on the [StarkNet Planets Alpha network](https://medium.com/starkware/starknet-planets-alpha-on-ropsten-e7494929cb95)!
//
// 1. Click on "Deploy" to deploy the contract.
//    For more information on how to write Cairo contracts see the
//    ["Hello StarkNet" tutorial](https://cairo-lang.org/docs/hello_starknet).
// 2. Click on the contract address in the output pane to open
//    [Voyager](https://goerli.voyager.online/) - the StarkNet block explorer.
// 3. Wait for the page to load the information
//    (it may take a few minutes until a block is created).
// 4. In the "STATE" tab, you can call the "add()" transaction.

// The "%lang" directive declares this code as a StarkNet contract.
%lang starknet

@view
func add(x: felt, y: felt) -> (res: felt) {
    return (res=x + y);
}
```

---

> 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 submit a StarkNet contract?

hi guys! is it possible to import local python files into hints?

Like so:
```python
# Cairo here

%{
	import my_python_file.py
	# Python here
%}
```

Is it possible to import local python files into hints?

How do I put funds into my newly created account from the ape console?


ApeWorX: How do I fund newly created accounts from the ape console?


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

Hey! With starknetjs(4.15.1) I am trying to declare a contract on devnet(0.4.2) using one of  predeployed accounts:

```
const account = new Account(
  provider,    '0x33507ff2edf12c12c73d0b6d1d90de9fac12a355de1097ab305249612451919',
  ec.getKeyPair('0x1de9ea6670d3da1fc735df5ef7697fb9')
);
...
const response = await account.declare({contract, classHash})
```

In return I get:

```
     GatewayError: Error at pc=0:124:
Signature (190318159909676960154007463740407923762489366165178197276822367516441018681, 1481560316189074241501727945883196969140908548840364106059171525936237675551), is invalid, with respect to the public key 1739835831186746845112715264902076958080619051586179661985458614041125785393, and the message hash 1015445806423683747697120201561835375586563571781789449937604429244570518935.
Cairo traceback (most recent call last):
Unknown location (pc=0:615)
Unknown location (pc=0:600)
Unknown location (pc=0:245)
```


Declaring a StarkNet contract on DevNet with Account(), but I get GatewayError in StarkNetJS

Hey, I’m learning Cairo and I want to know more about Gas Optimization. In Solidity compiler, there is a difference between writing uint128 and uint256. Similarly to C and other languages, for example:

```solidity
contract ThisIsNotAnOptimizedContract{
	uint128 Zero;
	uint256 One;
	uint128 Two;
}

contract ThisIsAGasOptimizedContract{
	uint128 Zero;
	uint128 Two;
	uint256 One;
}

```

`uint128` variables each occupy a separate `uint256`just for themselves, wasting 128 bits for each slot (Like the first contract). The Solidity compiler puts 2 `uint128` in the one 256-bit memory slot when they are declared next to each other. 

I’m curious if there is any similar issue in Cairo. `Uint256` uses two felt objects for low/high bits of the value.

```python
struct Uint256 {
    // The low 128 bits of the value.
    low: felt,
    // The high 128 bits of the value.
    high: felt,
}
```

Is there any similar practice in Cairo to optimize `felt` and Uint256 objects to save some compiler steps?

Popular tags

why does keccak256 replace sha256 in warp?

1 answers

Your answer

Related

You may find useful