StarkNet is in Alpha. Cool.

But what will Beta mean? When should it be beta? Please tell me. Chose all options which are "MVB" or "minimum viable beta". 6 questions.

1. How much **throughput** do you need? ~15TPS like ETH, ~150 TPS, ~1k TPS?
2. On speed of transactions on mainnet: ~10ms, ~1ms, ~10s, ~1s block time what do you think?
3. On pace of releases of Cairo / StarkNet: 1 per month, 1 per 6 month, 1 per 12 month?
4. What do you think about volition and Data availability systems/providers?
- VO & DAL optional, 
- VO mandatory, single DAL
- VO mandatory, various DAL?
5. On cost: ~10% of Ethereum, ~1% of Ethereum, ~0.1% of Ethereum?
6. When do you expect to see beta? ~3, ~6, ~12 months?

**Based on this [Twitter's thread](https://twitter.com/henrlihenrli/status/1599788123092754432)**

Newton

What do you think about current StarkNet Alpha and future Beta? What will Beta mean? When should it be beta?

```
...
const { available, connect, refresh, disconnect } = useConnectors()

    const connectors = [
      new InjectedConnector({ options: { id: "argentX" } })
    ];

return(
  <button onClick={() => connect(connectors[0])}>
    Connect {connectors[0].id()}
  </button>
)
```
any idea why this code doesnt connect to argentX in brave?

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

Any idea why this code doesn’t connect to argentX in brave?

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 do I connect my DAPP to Starknet-devnet using starknetjs?

When it comes to message cancellation (L1 -> L2) you can cancel a message in the case that:
- There is any kind of censorship on StarkNet (sequencer skipped your tx)
- The L2 contract's `` function flow has an assert that fails

Is this correct? Am I missing any other situations where message cancellation would/wouldn't work?

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

Can you explain about cancellation (L1 -> L2) in StarkNet (sequencer)?

How do I connect my DAPP to Starknet testnet using 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?

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

Hello! This is Day 2 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 “Functions”. Perhaps you can help me?

```python
// The following code is missing the function `add1`.
// 1. Click on "Run" to see the error.
// 2. Write the function `add1`, based on `add1_square`, so
//    that the program terminates successfully.
//
// Note that `add1` doesn't have to call other functions.
//
// You can learn more about functions [here](https://www.cairo-lang.org/docs/how_cairo_works/functions.html).

// Write your code here.

func add1_square(x: felt) -> (x: felt) {
    // Call `add1` and unpack the result into `z`.
    let (z) = add1(y=x);
    return (x=z * z);
}

func main() {
    // Call `add1_square` and save the result into `res`.
    let (res) = add1_square(x=12);

    // Verify the computation.
    assert res = (12 + 1) * (12 + 1);
    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

What do you think about current StarkNet Alpha and future Beta? What will Beta mean? When should it be beta?

0 answers

Your answer

Related

You may find useful