Hi, I recommend using the `Contract` interface. 

The address and ABI of the token have to be known. You will also need your account instance.

For example, if you would like to send ETH tokens:
- get its ABI (e.g. from the [starkscan.co](https://starkscan.co/contract/0x048624e084dc68d82076582219c7ed8cb0910c01746cca3cd72a28ecfe07e42d#class))
- create the `Contract` instance
- invoke `transfer` function

```
eth_address = 0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7

contract = Contract(address=eth_address, abi=abi, client=account)

res = await contract.functions["transfer"].invoke(recipient=recipient_address, amount=1000, max_fee=int(1e16))
await res.wait_for_acceptance()
```

where:
- abi is an abi of the contract
- account is an AccountClient instance

war-in

Hey, I have some tokens on my account and would like to send them to another. How to do it in StarkNet.py?

How to send tokens through StarkNet.py?

Hello! This is day 8 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 “Field Elements”.  Perhaps you can help me?

```
// Unlike most systems where the primitive type is a 32 or 64-bit integer,
// the primitive type in Cairo is "felt", which stands for "field element".
// When we say "a field element" we mean an integer in the range -P / 2 < x < P / 2,
// where P is a very large (prime) number.
// Currently we use a 252-bit number (76 decimal digits).
// When we add, subtract or multiply and the result is outside the range above,
// there is an overflow.
//
// The most important difference between integers and field elements is division:
// Division of field elements (and therefore division in Cairo) is not the
// integer division you may be used to.
// In the next challenge, you'll see how to use unsigned_div_rem()
// for truncated (i.e., rounding down) integer division.
//
// Make the code below output the results of the following expressions:
// 1. 1 + 100, 1 - 100, 9 * 9.
// 2. pow(10, 74), pow(10, 75), pow(10, 76)
// 3. 12 / 3, (-12) / 3
// 4. 13 / 3 (This is an example of division in the field)

%builtins output

from starkware.cairo.common.serialize import serialize_word

// Computes base^exp.
func pow(base: felt, exp: felt) -> (res: felt) {
    if (exp == 0) {
        return (res=1);
    }

    let (res) = pow(base=base, exp=exp - 1);
    return (res=res * base);
}

func main{output_ptr: felt*}() {
    serialize_word(1 + 100);
    // Add your code here.

    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 math operation with Field Elements (felts) in Cairo lang?

I’m signing a message using 
```
account.signMessage(data) 
```
and immediately verifying the signature with the same data and it’s returning false. I don’t see any issue open on this subject on starknet.js. Is this something you’ve already encountered by any chance?

here’s the code:

```python
const data = { types: proposeTypes, primaryType: 'Propose', domain, message };
const sig = await user.account.signMessage(data);
let res = await user.account.verifyMessage(data, sig); // returns `false`
```

I see that’s the expected way to use signMessage through the tests (https://github.com/0xs34n/starknet.js/blob/b20819424dea824c96ac31e0542733c84d87d441/__tests__/account.test.ts#L125-L126).

So I guess something’s going wrong when it comes to either hashing the data and signing it or hashing the data and verifying the signature?


btw: for those wondering: `verifyMessage` only works if the account is deployed: if you’re doing this with an account not deployed (basically just a keypair) then this won’t work :)

signing a message using account.signMessage(data) | starknet.js

I have a switch statment where I need to set two distinct, values so thought I would use a tuple  or a struct but I keep getting:

For a struct

`Expected a 'felt' or a pointer type. Got:<TYPE PATH> `

For a tuple

`Expected a 'felt' or a pointer type. Got:(felt,felt) `

This is with the unset tempvar being declared before the branching, and being set in each of the paths. 


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

A switch statement in Cairo lang to set two distinct values

Hey how can I get ETH for the test net in StarkNet?

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

How can I get ETH for the test net in StarkNet?

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?

hi guys! is it possible to import local python files into hints?

Like so:
```python
# Cairo here

%{
	import my_python_file.py
	# Python here
%}
```

Is it possible to import local python files into hints?

Another vanilla Cairo question, what are the sorts of references, i.e. ids that can be modified by hints? relatively important to work against an evil prover

presumably not locals or tempvars, but say, implicit references, or the two(?) kinds of let statements (expressions and references)

maybe if there's some documentation i don't know about re: all the id types, relocatable values and so on,

also maybe, is there a pattern that can be used for function pointers?

Popular tags

How to send tokens through StarkNet.py?

1 answers

Your answer

Related

You may find useful