Sorry, ser,here is the profile of starknet:
> StarkNet is a permissionless decentralized Validity-Rollup (also known as "ZK-Rollup"). It runs as an L2 network on Ether, enabling any dApp to achieve unlimited scale of computation - without compromising the composability and security of Ether, thanks to StarkNet's reliance on the most secure and scalable cryptographic proof system - STARK.
So it's not optimistic, for more details on starks and starknet pls check this article: https://medium.com/starkware/starks-starkex-and-starknet-9a426680745a
but if you mean parallelism,in a few weeks, we plan to introduce parallelization into the sequencer, enabling faster block production (starknet V0.10.1),thank you😀

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

Newton

Hey is there optimistic parallelism in StarkNet? I can't find it in the docs

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

Is there optimistic parallelism 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?

test another new question new

1. What’s the difference between AA (Abstract Account) and EOA (Externally Owned Account)?

2. What is an abstract account? Where is the account address derived from? Does the account address also come from the mnemonic and the private key?

3. What is multi-call? What will it bring to UX?

Can you explain what is Abstract Account?

How large can addresses be in Cairo?


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

How large can addresses be in Cairo?

I'm new to Cairo and I want to know what is the difference when I write `let x = 1;` and `tempvar x = 1;`. Is there any difference in Cairo Lang between let and tempvar?

Cairo: let vs tempvar what is the difference?

does anybody have a working local setup ? I find myself having to run tests on the testnet...

I tried both nile and protostar. the problem is that I can set it up but I don't know how to get access to the accounts that are pre-loaded with ETH. new accounts that I create don't have ETH and I don't have a way to transfer ETH to them..

if anybody has a go-to setup that they can share that'd be much appreciated 🙏

How to setup local Starknet node with Account contracts?

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

Is there optimistic parallelism in StarkNet?

1 answers

Your answer

Related

You may find useful