StarkNet Concepts for App Developers

StarkNet is a Layer 2 network on Ethereum that uses zero-knowledge proofs for security and scalability. If you're coming from web2, Ethereum, or Solana, this guide maps StarkNet concepts to what you already know. Chipi abstracts most of the complexity. You don't need to understand ZK proofs to build apps. But understanding the underlying model helps you debug issues and make better design decisions.

On Ethereum, there are two types of accounts: EOAs (Externally Owned Accounts, controlled by a private key) and smart contracts. On StarkNet, every account is a smart contract. There are no EOAs.

What this means for you:

• - No MetaMask. Wallets don't need browser extensions. Chipi wallets use WebAuthn passkeys stored on the user's device
• - No private key in the browser. The passkey never leaves the device hardware
• - Native multicall. One transaction can batch multiple calls (e.g., approve + swap). No need for Multicall3 contracts
• - Programmable validation. Each wallet can define its own signature validation rules. Chipi wallets validate passkey or PIN signatures

When you call useCreateWallet, Chipi deploys a smart contract wallet on StarkNet. The wallet is deployed on the first transaction (lazy deployment). Creation returns a wallet address immediately, but the contract is only deployed when the user first transacts.

Chipi supports two account contract types:

CHIPI (default, recommended): Chipi's own account contract. Supports session keys (one auth, many transactions), gasless transactions, and passkey/PIN authentication.

READY: Argent X compatible account contract. The wallet appears in the Argent X wallet app. No session key support.

| Feature | CHIPI | READY | |---------|-------|-------| | Session Keys | Yes | No | | Gasless | Yes | Yes | | Passkey Auth | Yes | Yes | | Argent X Compatible | No | Yes |

Always use CHIPI unless the user specifically needs Argent X compatibility. You cannot convert a READY wallet to CHIPI. They use different account contracts. If you start with READY and later want session keys, the user must create a new wallet.

StarkNet uses ERC-20 tokens (same standard as Ethereum). The key tokens:

• - USDC. 6 decimals. $10.00 = 10,000,000 raw units. The primary payment token on Chipi
• - ETH. 18 decimals. Used as gas token on StarkNet, but gasless through Chipi
• - STRK. 18 decimals. StarkNet's native token. Also usable for gas, but gasless through Chipi

Key contract addresses (StarkNet mainnet):

• - USDC: 0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb
• - ETH: 0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7
• - STRK: 0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d

When using useTransfer, pass human-readable amounts (e.g., amount: 10 for 10 USDC). The SDK handles decimal conversion. When using useCallAnyContract, pass raw values with u256 encoding: [low_128_bits, high_128_bits].

Every transaction goes through these stages:

PENDING → PROCESSING → COMPLETED
                    ↘ FAILED

• - PENDING. Transaction submitted, awaiting processing
• - PROCESSING. Transaction being executed on-chain by the sequencer
• - COMPLETED. Transaction confirmed on StarkNet
• - FAILED. Transaction reverted (wrong calldata, insufficient balance, contract error)

Chipi wallets are deployed lazily. The smart contract is deployed on the first transaction. Wallet creation returns a wallet address immediately, but no on-chain deployment happens until the user's first transfer, stake, or contract call.

On Ethereum, users pay gas fees in ETH for every transaction. On Solana, users pay fees in SOL. On StarkNet with Chipi, users pay nothing. Chipi sponsors all gas fees through a paymaster.

How it works:

1. User signs a transaction with their passkey
2. Chipi's paymaster wraps the transaction and pays the gas
3. Transaction executes on StarkNet. The user only sees the business logic (transfer, stake, etc.)

This means:

• - Users don't need ETH or STRK in their wallet to transact
• - No gas estimation code needed
• - No "insufficient gas" errors
• - Works for all operations: transfers, staking, contract calls, SKU purchases

The paymaster model is native to StarkNet's account abstraction. It's not a subsidy. It's built into how the network processes transactions.

Quick reference for developers coming from other chains:

vs Ethereum/EVM:

• - No EOAs. Every account is a smart contract
• - No MetaMask. Wallets use passkeys instead of browser extensions
• - No chain switching. Single network, no wallet_switchEthereumChain
• - No ABI files needed. Chipi hooks abstract contract interactions
• - u256 = two felts. [low_128, high_128] instead of a single 256-bit value
• - Addresses: 0x + 64 hex chars (not 40)
• - Native multicall. Batch calls in one transaction, no Multicall3

vs Solana:

• - No PDAs. Data stored in contract storage, not derived accounts
• - No ATAs. ERC-20 balanceOf(address) replaces Associated Token Accounts
• - No rent. Deploy once, stays forever
• - No wallet adapter. Passkeys replace Phantom/Solflare
• - Base58 → hex. Addresses start with 0x, not Base58 encoded
• - Programs rewritten in Cairo. Anchor/Rust programs don't work on StarkNet

vs Web2:

• - Passkeys work like Face ID / fingerprint login. Familiar to users
• - Wallets are created behind the scenes. No crypto onboarding friction
• - Transactions are like API calls. Gasless, fast, confirmable