I suspect it will be similar to cairo-lang's CLI where you provide first the length of the array (baseUri_len) and then all the felts that represent 31 characters chunks of the baseUri. Those felts have to be passed in order,does it make sense?

---
this article might help you understand how would you do that with cairo-lang, nile is a wrapper for cairo-lang so it should work the same way: [https://david-barreto.com/starknet-erc721-workshop-exercise-7/](https://david-barreto.com/starknet-erc721-workshop-exercise-7/)

Newton

I'm trying to use Nile (StarkNet).
I send this function call : 

```cairo
func setBaseURI{pedersen_ptr: HashBuiltin*, syscall_ptr: felt*, range_check_ptr}(
    baseUri_len: felt, baseUri: felt*
)
```

The only thing that would get processed is 

```
nile send account mycontract setBaseURI 3 1 1 1
```

but I don't think that's the right way. How do you pass an array of felt to call with Nile?

How can I pass an array of felt to call with Nile in StarkNet?

# Is Kakarot zkEVM a blockchain?

Does Kakarot have its own consensus, finality, commitment to L1, blocks, etc.?

Is Kakarot zkEVM a blockchain?

Hi, I'm trying to solve a Playground exercise on the [Cairo website](https://www.cairo-lang.org/playground/) named "Conditionals". I don't know how to make OR operator in Cairo. I tried something like that:

```
func abs_eq(x: felt, y: felt) -> (bit: felt) {
    if (x == -y) or (x == y) {
        return (bit=1);
    } else {
        return (bit=0);
    }
}
```

but it gives me an error


`Error: code:12:18: Unexpected token Token('IDENTIFIER', 'or'). Expected: "{".
    if (x == -y) or (x == y) {`

How can I solve it?


Cairo OR operator

How to transpile multiple contracts at once using [Nethermind's warp](https://github.com/NethermindEth/warp)?

How to transpile multiple contracts at once using warp?

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?

How do you write the pseudocode:


if x == 1 and y == 1, then return 1.


Else return 0.


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

How to write "and" conditional logic in Cairo?

anybody manged to declare contracts with the new nile?

```
Error: AssertionError: Sender must be passed explicitly when making a direct declaration using --no_wallet.
```

I saw a hardhat issue aswel

must be an upstream thing

https://docs.starknet.io/docs/Blocks/transactions/#calculating-the-hash-of-a-v1-declare-transaction

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

An error “AssertionError: Sender must be passed explicitly when making a direct declaration using —no_wallet.” using the new nile?

In SNARKs, you can use Zokrates or snarkjs to generate a proof for a program/computation and verify it, locally or on Ethereum.


Similar to [this unanswered question](https://github.com/starkware-libs/cairo-lang/issues/2), how to do the same in Cairo and STARK for, say, [the 15-puzzle](https://www.cairo-lang.org/docs/hello_cairo/puzzle.html)?


Can `cairo-run` generate a proof, or only a trace?


I can send it to [SHARP](https://www.cairo-lang.org/docs/sharp.html) with cairo-sharp, but I can't generate nor see the proof locally. Any way to generate the proof by running my own prover without SHARP?


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

Popular tags

How can I pass an array of felt to call with Nile in StarkNet?

1 answers

Your answer

Related

You may find useful