![img](https://sun9-32.userapi.com/impg/i_uDJWsDuQgFJlwQEhkImlZ-hLa9pn5mP2meGg/FuvAg-JYy3M.jpg?size=1069x269&quality=96&sign=2b525fc47b12f587fb581be6dc93ae01&type=album)

If you want the answer for only letters string, here's what you can do.

Look at [https://www.techonthenet.com/ascii/chart.php](https://www.techonthenet.com/ascii/chart.php)

Find the character of interest that has the lowest value in the ascii table. Feed a bytes string with 20 times that char. Convert to int with python.

`int.from_bytes(b'                    ', 'big')` should work for your case.



### How to calculate the minimum decimal number that can store 20 chars long string as a field element?

Newton

How to calculate the minimum decimal number that can store 20 chars long string as a field element?

How do I connect my DAPP to Starknet mainnet using starknetjs?

Some questions that could be answered separately.

1. The only way to invoke a contract is using migrations (this applies for both devnet and testnet?)
2. When doing a migration file I receive the “Hint is not whitelisted. This may indicate that this library function cannot be used in StarkNet contracts.” error. For example for this code:

```
%lang starknet

@external
func up() {
    %{
        contract_address = deploy_contract(
             "./build/main.json",
             config={"wait_for_acceptance": True}
        ).contract_address

        invoke(
            contract_address,
            "initialize",
            {"new_authority": 123},
            config={
                "auto_estimate_fee": True,
                "wait_for_acceptance": True,
            }
        )
    %}

    return ();
}
```

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

The only way to invoke a contract is using migrations (this applies for both devnet and testnet?)

Hi, just saw starknet.js latest is now 4.4 and not 3.x anymore. Do you plan to move the that release at what horizon? Is there some known issues staying with 3.x and working with starknet-react?

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

Is there any issue between using 4.4 and 3.x starknet.js?

If not, are there any workarounds?


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

Does Cairo support int256, or negative numbers in general? 

In the medium article about 1.0.0 this is shown as the syntax for the for loop

```let sum = 0
for x in iter {
  sum = sum + x;
}```

That doesn't compile for me and loops are not mentioned on github release note.

Will recursion still be necessary if they work as they do in other languages? 

Will it be possible to invoke functions from within the loops?

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

Will it be possible to invoke functions from within the loops in Cairo 1.0?

Hello! This is day 10 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 “Bitwise operations”.  Perhaps you can help me?

```
// The bitwise builtin allows you to perform bitwise operations
// (and, or, xor) on integers up to 251 bits.
//
// The following code implements the function xor_last_hex_digits,
// which takes the two last hexadecimal digits and "xor"s them.
// For example, in 0x1234 the last two digits are 3 and 4,
// and their xor is 3^4=7.
//
// Fix the missing code and make sure it works.

%builtins bitwise

from starkware.cairo.common.bitwise import bitwise_and, bitwise_xor
from starkware.cairo.common.cairo_builtins import BitwiseBuiltin

// Returns the xor of the last two hexadecimal digits.
func xor_last_hex_digits{bitwise_ptr: BitwiseBuiltin*}(x: felt) -> (res: felt) {
    // Fix and uncomment the line below.
    // let (digit0) = ...

    let (shifted_digit1) = bitwise_and(x, 0xF0);
    tempvar digit1 = shifted_digit1 / 0x10;

    return bitwise_xor(digit0, digit1);
}

func main{bitwise_ptr: BitwiseBuiltin*}() {
    let (res) = xor_last_hex_digits(0x1234);
    assert res = 7;

    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 make Bitwise operations in Cairo Lang using %builtins bitwise, bitwise_xor?


The following code:



```
func pow4(n) -> (m : felt):
    alloc_locals
    local x

    jmp body if n != 0
    [ap] = 0; ap++
    ret

    body:
    x = n * n
    [ap] = x * x; ap++
    ret
end

func main():
    pow4(n=5)
    ret
end

```

is declared inefficient in the [doc](https://starknet.io/docs/how_cairo_works/consts.html#id7) because of non-continuous memory.


I ran it and could not see any hole in the memory table:



```
Addr  Value
-----------
â‹®
###
â‹®
1:0   2:0
1:1   3:0
1:2   5
1:3   1:2
1:4   0:21
1:5   25
1:6   625

```

so I don't understand where the problem is. I do see a hole with `n=0` though:



```
Addr  Value
-----------
â‹®
###
â‹®
1:0   2:0
1:1   3:0
1:2   0
1:3   1:2
1:4   0:21
â‹®
1:6   0

```

that I can fix using:



```
    jmp body if n != 0
    x = 0
    ret

```

but it's not what's suggested:


* Move the instruction alloc\_locals.
* or Use tempvar instead of local.



ㅤ
_This question was originally posted on [Stack Overflow](https://stackoverflow.com/questions/72601235/what-is-the-inefficiency-in-this-cairo-code-using-alloc-locals)_

Popular tags

How to calculate the minimum decimal number that can store 20 chars long string as a field element?

How to calculate the minimum decimal number that can store 20 chars long string as a field element?

1 answers

Your answer

Related

You may find useful