It's hard to be sure how this will play out; we still haven't seen people exploiting MEV on chains using Account Abstraction.

Most searchers sending bundles today use smart contracts to move assets; it's not clear yet how account abstraction may change their experience.

What will the bundler ecosystem look like in AA?

---

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

What will the bundler ecosystem look like in Account Abstraction?

### *From Newton AI*
*OpenZeppelin is a collection of reusable, secure smart contract libraries for Ethereum. It provides a set of Solidity contracts that implement common contract patterns and functions, such as ERC20 token contracts and contracts for managing and securing user accounts. By using OpenZeppelin libraries in your contracts, you can benefit from the security and functionality provided by these pre-written contracts, without having to reimplement them yourself. When transpiling your contracts, the transpiler will include the code from any imported libraries, such as OpenZeppelin, in the final transpiled output.*

Is it possible to transpile contracts that use openzeppelin libraries?

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?

Does AA support bundling multiple operations at once?
---

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)

Does Account Abstraction (StarkNet) support bundling multiple operations at once?

![img](https://sun9-13.userapi.com/impg/9YrwMdCKAVbgBRKmMdGysFrP3qhbHWBiTNgp3A/64s3EVNAEpE.jpg?size=1158x874&quality=96&sign=f55c859f079b65212bc744b47e7bb7af&type=album)
Is there a plan to get better visibility when a transaction got received but not placed into a block?
For the moment we only know that it is RECEIVED but have no clue if it’s been discarded because of missing constructor params or if it’s just late:

```python
{
	transaction_hash: '0x3d26af3d7a8f17ea28c2a71a250fd8c5dcd162b779051fd36a3bfcd9f130fab',
	actual_fee: undefined,
	status: 'RECEIVED',
	status_data: undefined,
	messages_sent: [],
	events: [],
	l1_origin_message: undefined
}
```

upd: I noticed we are notified when we make an error, but:

1. we don’t know what’s happening between `RECEIVED` and `REJECTED | ACCEPTED_ON_L2`, it’d be nice to be able to monitor a bit more preceisely where’s the transaction in the pipeline

2. the error message is often cryptic and not human readable, ex:

```python
Error: REJECTED: TRANSACTION_FAILED
Error at pc=0:1073:
An ASSERT_EQ instruction failed: 9:6 != 9:5.
```

Is there a way / tool to be able to debug this kind of failed transactions?

A plan to get better visibility when a transaction got received but not placed into a block?

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?

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?

Hello everyone, how can I make a multicall in JS? With which library ?

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

Popular tags

What will the bundler ecosystem look like in Account Abstraction?

1 answers

Your answer

Related

You may find useful