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?

How do you optimize gas in Cairo with Uint256/felt?

Do you think in Fture ETH will be Better than BTC ?
As we Know more and more eth will get burned sooner or later splly will be less than BTC
So do you think in Future eth can be more vlauable than BTC

Do you think in Fture ETH will be Better than BTC

### *From Newton AI*
*OpenZeppelin is a collection of reusable, secure smart contract libraries for Ethereum. It provides a set of Solidity contracts that implement common contract patterns and functions, such as ERC20 token contracts and contracts for managing and securing user accounts. By using OpenZeppelin libraries in your contracts, you can benefit from the security and functionality provided by these pre-written contracts, without having to reimplement them yourself. When transpiling your contracts, the transpiler will include the code from any imported libraries, such as OpenZeppelin, in the final transpiled output.*

Is it possible to transpile contracts that use openzeppelin libraries?

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?

I'm trying to run the contract example from https://pkg.go.dev/github.com/dontpanicdao/caigo#section-readme
```
cd examples/contract
go mod tidy
go run main.go
```
and i get 
```
./main.go:28:34: undefined: contracts.CounterCompiled
```

So i tried to compile the counter.cairo file and got
```
counter.cairo:17:5: Unknown identifier '__main__.counter.write'.
    counter.write(0);
    ^***********^
```
the code looks fine [https://github.com/coburn24/caigo/blob/main/contracts/src/counter.cairo](https://github.com/coburn24/caigo/blob/main/contracts/src/counter.cairo)
not sure why im getting this error
`cairo-compile v0.10.3`


caigo error: undefined: contracts.CounterCompiled

Hello! This is day 4 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 “Variables”. Can you launch this code with the instructions and write down how many steps the program has in the output?

[BONUS]: try to make it faster

```
// The following code outputs the 9th power of 2.
// 1. Click on "Debug" to run the code, and then click on
//    the arrows in the memory panel to trace the program
//    step by step.
//
// Observe that the computation of `z` take 8 steps and
// creates 8 temporary variables. This is because `let`
// simply replaces each instance of `y` with `x * x * x`
// and each instance of `z` with `y * y * y`, which is
// expanded to nine multiplications.
//
// 2. Change the two `let`s to `tempvar`s and run the program.
//
// "tempvar" stands for "temporary variable", which means that
// a variable will be allocated for the intermediate values
// (`x * x * x` and `y * y * y`). This reduces the same
// computation to use only 4 steps and 2 new variables.
//
// 3. Replace all three instance of the keyword `tempvar`
//    with `local`, uncomment the line containing `alloc_locals`
//    and run the code again.
//
// The behavior of the code doesn't change. This is because
// the keyword `local` allocates a new variables for the
// intermediate values as well. The main difference between
// `local` and `tempvar` is explained in the next challenge.

// Use the output builtin.
%builtins output

// Import the serialize_word() function.
from starkware.cairo.common.serialize import serialize_word

// Outputs the value 2^9.
func main{output_ptr: felt*}() {
    // alloc_locals;
    tempvar x = 2;
    let y = x * x * x;
    let z = y * y * y;
    // Because of the `let`s, the following line is equivalent to
    // serialize_word(x * x * x * x * x * x * x * x * x).
    serialize_word(z);
    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 the difference between tempvar/let in Cairo Lang? How to use allow_locals and local?

Do any of you know where I can find the list of the decorators available in Cairo, please?

List of Cairo Decorators

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.


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

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