"Mastering Arbitrum Stylus SDK in C" by Karol Huertas

Which data type is primarily used for handling token balances in Stylus C contracts?

uint256_t

stylus_bigint_t

int64_t

What is the key advantage of using Rust over Solidity in Arbitrum Stylus?

Rust contracts require no compilation

Rust contracts are gas-free

Rust enables parallel execution and memory safety

Which programming languages can be used with the Stylus SDK?

C

Solidity

All the above

Rust

How does Arbitrum Stylus ensure deterministic execution of C-based contracts?

By caching contract states in local memory

By enforcing a single-threaded execution model

By disallowing floating-point operations

Which compiler is used to compile Rust-based smart contracts for Arbitrum Stylus?

Cargo-stylus

Solc

Clang

9. How does Arbitrum Stylus optimize gas usage for C-based contracts?

By batching multiple transactions into a single execution unit

By using WASM-based execution instead of the EVM

By precompiling all contract functions

What is the purpose of stylus_storage_store in the C SDK?

It writes data to Arbitrum’s Nitro L2 storage

It allows C contracts to store data in an external database

It stores data in Solidity contracts only

What function does the C SDK provide to interact with Ethereum storage?

stylus_storage_load

wasm_storage_fetch

evm_storage_read

What does the Stylus SDK allow developers to do?

Create smart contracts

Build decentralized applications

All of the above

Develop Layer 2 solutions

What is the main purpose of Layer 2 solutions like Arbitrum?

To create new cryptocurrencies

To enhance scalability and reduce congestion

To increase transaction fees

To replace Ethereum entirely

How are Ethereum addresses represented in the Arbitrum Stylus C SDK?

As eth_address_t

As bytes20

As uint160_t

What is the primary role of the C SDK in Arbitrum Stylus?

To enable Solidity developers to call C functions

To allow low-level system interactions and optimize performance in Stylus smart contracts

To provide an alternative EVM execution environment

What is the correct way to handle logging events from a C-based contract in Arbitrum Stylus?

Using stylus_emit_log()

Writing to stderr in WASM

Calling a Solidity event manually

How does Arbitrum Stylus handle memory management in C-based contracts?

It requires manual memory allocation and deallocation like traditional C programs

It uses a linear memory model in WebAssembly (WASM)

It relies on Rust’s ownership model

What is a key advantage of using the C SDK in Arbitrum Stylus over Solidity?

Built-in Solidity compatibility without external calls

Lower-level access to memory and computation for performance optimization

Automatic gas cost reduction for contract execution