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?

Hey there! 

I am using the Oz Nile framework for smart contract development on Starknet. More specifically, I am testing the proxy upgrade feature, but my tests fail with the error message TypeError: int() can't convert non-string with explicit base. This happens when nile.signer tries to sign a transaction. Here's the snippet in the stack trace below. 

```
def sign_transaction(self, sender, calls, nonce, max_fee):
        """Sign a transaction for an Account."""
        (call_array, calldata) = from_call_to_call_array(calls)
        message_hash = get_transaction_hash(
>           int(sender, 16), call_array, calldata, nonce, int(max_fee)
        )
```

Some relevant info:
cairo-lang==0.10.0
cairo-nile==0.8.2
openzeppelin-cairo-contracts==0.4.0b
pytest==7.1.2
python=3.9 

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

Cairo/Nile: Testing the proxy upgrade feature, but my tests fail with the error message TypeError: int() can't convert non-string with explicit base.

How do I call a test account while trying to test a function?



ApeWorX: How do I call an account while trying to test a function?

Hey guys,

I am having issue with generating _abi.json file when I use namespace,
Please see example below.

Does someone know solution of how to generate _abi.json file when namespace is used? I really need help 🙏 

This code generates starknet_abi.json

%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin
from starkware.starknet.common.syscalls import get_caller_address

@External
   func store_name{syscall_ptr: felt, pedersen_ptr: HashBuiltin, range_check_ptr}(_count: felt) -> (even : felt) {
      alloc_locals;
      local even;

      let (caller) = get_caller_address();
      if (_count == 2) {
         even = 1;
      }
      return (even=even);
   }
=============================================================
This code does not generates starknet_abi.json (please see use of  namespace)

%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin
from starkware.starknet.common.syscalls import get_caller_address

namespace ToMoon {
@External
   func store_name{syscall_ptr: felt, pedersen_ptr: HashBuiltin, range_check_ptr}(_count: felt) -> (even : felt) {
      alloc_locals;
      local even;

      let (caller) = get_caller_address();
      if (_count == 2) {
         even = 1;
      }
      return (even=even);
   }
}



Issue with generating _abi.json file 

﻿  



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

How can i learn Cairo with Python base?

How can I connect to deployed StarkNet contract 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?

Trying to install warp with command `yarn global add @nethermindeth/warp`

after successful install I try:
`warp install --verbose`
get this error:

```
zsh: command not found: warp
```


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