
## Context

Account abstraction is a new paradigm to make blockchain accounts programmable. To first understand AA, you need to understand how things work today. Then I will explain what’s unique and new about account abstraction.

## The Status Quo

- Today there are two account types on Ethereum : Contract Accounts and Externally Owned Accounts (basically that last one is regular user accounts).
- For anything to happen on-chain a transaction must be initiated and paid for by an EOA.
- The way you control an EOA is through its private key. You use this private key to create a signature that proves to the blockchain it’s your account.

## Why it sucks

- With this setup your private key makes you super vulnerable. And if you lose it, you lose your account and all your funds… Recently a friend of mine inadvertently uploaded his main private key to a public GitHub. A [scanning bot](https://geekflare.com/github-credentials-scanner/) instantly picked it up and drained his account of all his saving. $15k worth of tokens.
- The main issue is that the system is rigid and hard coded. You can implement multi-signature smart contract wallets like [Gnosis Safe](https://gnosis-safe.io/) but the default is this: you get an account with a key and if you lose your key, you’re fucked.
- The alternative of custodial accounts like Coinbase is not great. If they get hacked you have the same problem, and a single point of failure makes it super easy for governments to seize or freeze all your funds arbitrarily.

## What Account Abstraction improves

- Account Abstraction unifies Contract Accounts and EOAs. It makes user accounts more ‘programmable’. You remove the logic of signing transactions from the account, you “abstract” it out, hence account abstraction.
- This unlocks much more flexibility, you could code an account for multi-sig, 2-factor authentications, withdrawal limits, expiration on keys… it makes me think of [Revolut Virtual Cards](https://blog.revolut.com/a/virtual-card/).
- This is very very exciting because it allows the non-custodial blockchain UX to scale. (Can you really imagine the security risk of letting your parents manage their private keys when their email password is “Miami1973”?)

1. What’s the difference between AA (Abstract Account) and EOA (Externally Owned Account)?

2. What is an abstract account? Where is the account address derived from? Does the account address also come from the mnemonic and the private key?

3. What is multi-call? What will it bring to UX?

Can you explain what is Abstract Account?

## Hello World

This is the most classic 1st programming challenge.

People are awesome though, some answers go to such length, it's great!

> ✅ Solution
>>>>>      serialize_word(z);

serialize_word is like printf, console.log, and so many others...

Can you help how to change the code so that it outputs 400 as well?

```
// The following code outputs the numbers 100, 200, 300.
// 1. Click on "Run" to see the output.
// 2. Change it to output 400 as well.

// Use the output builtin.
%builtins output

// Import the serialize_word() function.
from starkware.cairo.common.serialize import serialize_word

func main{output_ptr: felt*}() {
// Output 100 by calling serialize_word.
serialize_word(100);
// Output 200.
serialize_word(200);
// Output 300.
serialize_word(300);
// Return.
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-Playground-Newton-550dfcda6a2d449ca468be293c776578)*

How to make output like "hello world" in Cairo Language (StarkNet)?

## You learn to code by copy pasting

You can pretty much solve this challenge by copying the syntax of the previous.

Copy this function:
```
func add1_square(x: felt) -> (x: felt) {
    // Call `add1` and unpack the result into `z`.
    let (z) = add1(y=x);
    return (x=z * z);
}
```
On thing I think that could be confusing is that you need to declare a variable name for function parameters and return values. But basically it can be the same! (here x & x).

> Good developers copy, great developers steal.

So here is our theft:
```
// Write your code here.
func add1(y: felt) -> (y: felt) {
    return (y=y+1);
}
```

Note that you need to call the variable __y__ because higher up in the program it's called as such. (It's when `add1(y=x)` is called).

Hello! This is Day 2 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 “Functions”. Perhaps you can help me?

```python
// The following code is missing the function `add1`.
// 1. Click on "Run" to see the error.
// 2. Write the function `add1`, based on `add1_square`, so
//    that the program terminates successfully.
//
// Note that `add1` doesn't have to call other functions.
//
// You can learn more about functions [here](https://www.cairo-lang.org/docs/how_cairo_works/functions.html).

// Write your code here.

func add1_square(x: felt) -> (x: felt) {
    // Call `add1` and unpack the result into `z`.
    let (z) = add1(y=x);
    return (x=z * z);
}

func main() {
    // Call `add1_square` and save the result into `res`.
    let (res) = add1_square(x=12);

    // Verify the computation.
    assert res = (12 + 1) * (12 + 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 write a function in Cairo Lang (StarkNet)?

## You need a forest...
...of IFs.
Yes Cairo doesn't support logic operators. (like ||)

So you need to add:
```
if (x == y) {
    return (bit=1);
}
```

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

```python
// The function `abs_eq` should return 1 if its inputs
// are equal or differ only in sign and 0 otherwise.
// Its current implementation is incorrect.
//
// 1. Click on "Run" to see where it fails.
// 2. Fix the body of `abs_eq`, so that the
//    program terminates successfully.

// Returns 1 if |x| = |y| (that is, x = y or x = -y),
// 0 otherwise.
func abs_eq(x: felt, y: felt) -> (bit: felt) {
    if (x == -y) {
        return (bit=1);
    } else {
        return (bit=0);
    }
}

func main() {
    let (bit) = abs_eq(2, -2);
    assert bit = 1;

    let (bit) = abs_eq(2, 3);
    assert bit = 0;

    let (bit) = abs_eq(2, 2);
    assert bit = 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 make conditional expressions if..then..else in Cairo lang?

StarkNet uses a similar scheme to calculate addresses for deployed contracts, most importantly it also has the option to use the deployer’s address for the new address.

Another question I have is:

**What's easier, adapt the create2 trick in Solidity then transpile or transpile first then adapt in Cairo?**

---

### *From Newton AI:*

*"Create2" is a feature in Solidity, the programming language used to write smart contracts for the Ethereum blockchain. It allows the creation of new contract accounts using a deterministic algorithm, rather than having to send a transaction to create the contract like with the original "create" function. This can be useful in certain situations, such as when creating a contract that is intended to be deployed at a specific address.*

*Transpiling is the process of converting code written in one programming language into another language. This can be useful if a piece of code needs to be run on a platform that only supports a different language, or if it is desired to use a different language's features or syntax.*


Did you change the factory/create2 part (to compute pool addresses)?

### *From Newton AI*
*"Assembly" is a low-level language that is used to write smart contracts for the Ethereum Virtual Machine (EVM). It is similar to machine code, which is the code that is run directly on a computer's central processing unit (CPU). Assembly is often used in Solidity contracts to perform complex tasks or to optimize the performance of the contract.*

*If a Solidity contract contains assembly code, it is important to be careful when working with it, as it can be difficult to read and understand. Additionally, certain assembly instructions, known as "special EVM calls," can have unintended consequences if not used correctly. For example, some special EVM calls can cause a contract to consume an excessive amount of gas, which can make it more expensive for users to interact with the contract.*

*It is generally recommended to avoid using assembly in Solidity contracts if possible, as it can make the contract more difficult to understand and maintain. If you do need to use assembly, it is important to thoroughly test and debug the contract to ensure that it functions as intended.*

What if my solidity contract contains Assembly or special EVM calls ?

### *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.*

Popular tags

Profile

victorforissier.eth

Wallet address: 0xb3d0969a0e5c9dee8960f6ffa243eb1e208a09b1

Recent questions

Recent answers