You can change the current active network using `with networks.parse_network_choice(“ethereum:local”):` or `with networks.parse_network_choice(“starknet:local”):`. This is not just limited to these two networks, you can change the current active network to any network plugin provider that you have available for your project. 

More information can be found [here](https://docs.apeworx.io/ape/stable/userguides/testing.html#multi-chain-testing)

How can I test on multi-chain with both Starknet and Ethereum?


ApeWorX: How can I test on multi-chain with both Starknet and Ethereum?

How does warp handles the contract solidity version?


Hey guys,
I'm wondering:
- What **hashing functions** are available now with Cairo?
- What are the **advantages/disadvantages** of each, like computation, security?

So far I know some:
- [keccak](https://github.com/starkware-libs/cairo-lang/tree/master/src/starkware/cairo/common/cairo_keccak)
- Pedersen hash, which can be used to hash chain, [here](https://www.newton.so/view/63427472405280f6d1cf502d)
- [sha256 extension](https://github.com/cartridge-gg/cairo-sha256) of the starkware implementation which can Computes SHA256 of 'input'. Inputs of arbitrary length are supported.

Happy hashing :)



What hashing functions are available in Cairo? How are they secure?

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?

Is there a way/a tool that can automatically generate events for Cairo functions, since pretty much all of my events follow the same format


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

Cairo Automatic Events

test another new question new

Hi everyone, I have a technical question:

We know that L2s are taking transaction load off of the Ethereum, but how is that process taking place? Is there a threshold of optimum transaction speed/cost? Are L2s only intervening when the L1 is congested or that threshold is passed?

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

 Is there a threshold of optimum transaction speed/cost in L2s?


I can often make a terminal recursive version of my functions with a little less elegant code. Should I do it because it could reduce the fees or should I keep the unoptimised version?


For example, here is an "unoptimised" function which sums elements of an array:



```
@view
func get_convoy_strength{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    convoy_id : felt
) -> (strength : felt):
    alloc_locals
    let (convoyables_len : felt, convoyables : felt*) = get_convoyables(convoy_id)
    return _get_convoyables_strength(convoyables_len, convoyables)
end

```

and here is the tail call optimization:



```
func _get_convoyables_strength_tc{
    syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr
}(convoyables_len : felt, convoyables : felt*, sum : felt) -> (strength : felt):
    if convoyables_len == 0:
        return (sum)
    else:
        let convoyable_id = [convoyables]
        alloc_locals
        let (convoyable_strength) = _get_strength(convoyable_id)
        return _get_convoyables_strength_tc(
            convoyables_len - 1, convoyables + 1, sum + convoyable_strength
        )
    end
end

```

As you can see it's a little less friendly because it requires an additional argument (which will always be 0). On a normal computer this could be optimized to not fill the call stack but as FeedTheFed pointed out, the memory is immutable here so it doesn't seem to be useful. He did say, however, that it could be interesting for "not wasting memory cells for the intermediate return values". It would be very helpful to me to have a more detailed explanation as I'm not sure to understand.


Here is the cairo doc related to this: <https://www.cairo-lang.org/docs/how_cairo_works/functions.html?highlight=tail#tail-recursion>



ㅤ
_This question was originally posted on [Stack Overflow](https://stackoverflow.com/questions/72321871/when-to-use-tail-call-optimization-in-a-cairo-smartcontract)_

Popular tags

ApeWorX: How can I test on multi-chain with both Starknet and Ethereum?

1 answers

Your answer

Related

You may find useful