StarkNet's sequencer has an estimate_fee API. This API returns the max-fee for a transaction. *(From Julien of Argent)*

victorforissier.eth

How does Argent X wallet estimate fees in Starknet before sending a tx?

Elias Tazartes (Eikii)

What is the difference between return and ret?


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

What does ret do in Cairo?

该从该从哪里哪里开始开始学起学起呢呢？？PythonPython嘛嘛？？


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

开始学习Cairo

Are transpiled contracts only interactable with the warp cli?

Hello! This is day 12 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 “Structs.  Perhaps you can help me?

```
// In this challenge you're going to implement a stack using a linked list.
//
// Add the missing code so that main() runs successfully.

from starkware.cairo.common.registers import get_fp_and_pc

struct Node {
    // A pointer to the next node in the stack.
    next: Node*,

    // The value of the node.
    value: felt,

    // The number of elements in the stack.
    size: felt,
}

// Returns an empty stack.
func empty_stack() -> (stack: Node*) {
    alloc_locals;
    local new_node: Node;
    assert new_node.next = cast(0, Node*);
    assert new_node.value = 0;
    assert new_node.size = 0;

    // The usage of get_fp_and_pc() here is necessary in order
    // to access the address of a local variable (&new_node).
    // You can read more about get_fp_and_pc() [here](https://cairo-lang.org/docs/how_cairo_works/functions.html#retrieving-registers).
    let (local __fp__, _) = get_fp_and_pc();
    return (stack=&new_node);
}

// Adds a node to the top of the stack.
// Returns the updated stack (since Cairo is immutable, you can still use the
// old copy of the stack).
func push(stack: Node*, value: felt) -> (stack: Node*) {
    alloc_locals;
    local new_node: Node;
    // Fix and uncomment below.
    // assert new_node.next = ...
    // assert new_node.value = ...
    // assert new_node.size = ...

    let (__fp__, _) = get_fp_and_pc();
    return (stack=&new_node);
}

// Removes the top element of the stack.
// Returns the updated stack and the element that was removed.
func pop(stack: Node*) -> (stack: Node*, value: felt) {
    return (stack=stack.next, value=stack.value);
}

// Returns the value of the n-th element from the top of the stack.
func stack_at(stack: Node*, n: felt) -> (value: felt) {
    if (n == 0) {
        // Add your code here.
    }

    // Add your code here.
}

func main() -> () {
    alloc_locals;
    // Start with an empty stack.
    let (stack) = empty_stack();
    // Push 1, 10, 100.
    let (stack) = push(stack, 1);
    let (stack) = push(stack, 10);
    let (local stack) = push(stack, 100);

    // Check the size of the stack.
    assert stack.size = 3;

    // Query the stack at indices 0, 1 and 2.
    let (value) = stack_at(stack, 0);
    assert value = 100;
    let (value) = stack_at(stack, 1);
    assert value = 10;
    let (value) = stack_at(stack, 2);
    assert value = 1;

    // Pop the top 2 values (100 and 10) and push 1000.
    let (stack, value) = pop(stack);
    assert value = 100;
    let (stack, value) = pop(stack);
    assert value = 10;
    let (local stack) = push(stack, 1000);

    // Query the stack at indices 0 and 1.
    let (value) = stack_at(stack, 0);
    assert value = 1000;
    let (value) = stack_at(stack, 1);
    assert value = 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)*

How to create Structs in Cairo Lang for StarkNet?

This isn't a starknet question, but raw cairo. is it possible to use a pointer reference like let, and set it to a pointer with a hint, without doing a memory allocation?

looks like the answer is yes, but you do need to assign a reference when you declare a pointer reference with let, but that doesn't alter the memory

e.g.

```python
let s : felt* = cast(ap, felt*)
{
	ids.s = some_other_reference
}
```

the `cast(ap, felt*)` does nothing, just satisfies the compiler by having something on the rhs of a let

a pointer with a hint, without doing a memory allocation

heyy guys, running into a problem

I have this code :
```struct TokenLedger:
   member token_address : felt
   member drip_amount : Uint256
   member balance : Uint256
end

@storage_var
func tokens_ledger(index : felt) -> (tokenLedger : TokenLedger):
end```

```let (ledger : TokenLedger) = TokenLedger(token_address, drip_amount, balance)
tokens_ledger.write(index, ledger)```
But am getting this error :

```faucet.cairo:94:34: Unexpected '.' after '__main__.TokenLedger' which is struct.
let (ledger : TokenLedger)  = TokenLedger(token_detail.token_address, token_detail.drip_amount, curr_balance)
                                ^*********^

       Failed

Error in plugin Starknet: Failed compilation of 1 contract.```

How to write a struct in storage?

What resources are required to run a Pathfinder node?

Popular tags

How does Argent X wallet estimate fees in Starknet before sending a tx?

1 answers

Your answer

Related

You may find useful