You can try something like this (cf Starkgate code):

```
 uint256 constant UINT256_PART_SIZE_BITS = 128;
 uint256 constant UINT256_PART_SIZE = 2**UINT256_PART_SIZE_BITS;
```

And payload will be like this :

```
uint256[] memory payload = new uint256[](3);
payload[0] = l2Recipient;
payload[1] = amount & (UINT256_PART_SIZE - 1);
payload[2] = amount >> UINT256_PART_SIZE_BITS;
```

Then on L2 you will received amount as 2 felt, high and low. Then you juste have to use it with ` let (amount: Uint256) =Uint256(low=low, high=high)`  And that's it.





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)

Newton

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?

Ahoy Caironauts,

  How can I define two functions with the same name but not the same arguments, e.g, 

- `func test()`
- `func test(param: Uint256)`

It is possible in Solidity and I'm trying to find the Cairo equivalent.

---
This question is participating in [Newton Bounties | Incentivized Test Program](https://newtonso.notion.site/Newton-Bounties-Incentivized-Test-Program-94322ad48e7d40a3adcf36f6b26174cd) Every verified valid question gets $10 USDC (mainnet)

How can I define two functions with the same name but not the same arguments?

Starknet is using which oracle service provider?

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

Which oracle service provider is StarkNet using?

>Hello! This is day 5 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 “Revoked references”. Can you run these 6 steps and write down what you see?

```
// The scope of some types of references in Cairo (e.g., return values of
// functions and temporary variables) is somewhat restricted.
// For example, a call to another function may revoke those references.
//
// 1. Try to run the following code. You should get an error that `x` was revoked
//    (this is because of the second call to `foo`).
// 2. In simple cases, like this one, the compiler can solve this automatically
//    if the "alloc_locals" keyword is used within the function's scope.
//    Add "alloc_locals;" to the beginning of main(), and make sure the code works.
// 3. To understand what happens behind the scenes, replace "alloc_locals;" with
//    "ap += SIZEOF_LOCALS;" - this command allocates memory cells for local variables
//    (you'll need them below) but doesn't enable the mechanism that
//    automatically resolves revoked references.
//    Trying to run the code now should result in the original error.
// 4. Solve the problem manually by copying the value of `x` to a local variable
//    (e.g., "local x2 = x;"). Local variables are not revoked when functions
//    are called.
//    You can read more about local variables [here](https://www.cairo-lang.org/docs/how_cairo_works/consts.html#local-vars).
// 5. You can even use the same name: "local x = x;".
//    This is called "reference rebinding", where the meaning of `x` changes:
//      Before this line, `x` refers to the return value.
//      After that, `x` refers to the local variable.
// 6. A shorter syntax is "let (local x) = foo(10);" which achieves the same goal.
//    Try it!

%builtins output

from starkware.cairo.common.serialize import serialize_word

// Returns a^3 for a != 0 and 1 otherwise.
func foo(a) -> (res: felt) {
    if (a == 0) {
        return (res=1);
    } else {
        return (res=a * a * a);
    }
}

// Outputs the value 10^3 + 5^3.
func main{output_ptr: felt*}() {
    let (x) = foo(10);
    let (y) = foo(5);
    serialize_word(x + y);
    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)*



Cairo Lang / StarkNet: What are Revoked references? What is alloc_locals?

Any nft marketplace has launched on starknet L2?

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

Any NFT marketplace has launched on starknet L2?

Why will I use events in the Cairo language? Can I use it on a front-end client application side?

Why will I use events in Cairo language?

I'm aware of starknet having a common--and unsafe--keccak library. Either way, I was wondering if there's a way to mimic the behavior of solidity's 
```
keccak256(abi.encode(parameters))
```
Thank you very much.

Is there a Cairo equivalent to Keccak256(abi.encode(parameters))?

# Hello world!

I try to implement the function `abs_value` of the package `starkware.cairo.common.math` but i have this error

```
AssertionError: Expected main to contain the following arguments (in this order): ['range_check_ptr_ptr']. Found: ['range_check_ptr'].
```

I dont understand the error. 

Can someone explain the error to me, why it happens ? 

> I am doing the challenge #17daysOfCairo of the day 3


Full code

```
%builtins range_check_ptr
from starkware.cairo.common.math import abs_value

func main{range_check_ptr}() {
    let x = abs_value(-1);
    return ();
}
```


Popular tags

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?

1 answers

Your answer

Related

You may find useful