# Starknet - Cairo-Powered Validity Rollup Documentation

## Starknet RPC plans and rate limits

- **Free plan:** 20 responses per second, up to 100,000 responses a day.
- **Plans:** $49/mo, $299/mo, $999/mo with 25M, 150M, and 500M included responses. Overages billed at $5/$3/$2 per million responses respectively.
- **Paid rate limits:** 100 to 5,000 responses per second (bursts from 500 to 10,000), no daily limit.
- **Billing:** 1 response = 1 API credit on every shared plan, over HTTPS or WebSocket (WSS) where Starknet supports it.

Details: [Pricing](https://www.dwellir.com/docs/getting-started/pricing) · [Rate limits](https://www.dwellir.com/docs/getting-started/rate-limits) · [Authentication](https://www.dwellir.com/docs/getting-started/authentication) · [Archive nodes](https://www.dwellir.com/docs/getting-started/archive-nodes)

## Why Build on Starknet?

Starknet is the leading validity rollup (zk-rollup) that executes Cairo smart contracts with STARK proof security, offering unparalleled scalability while maintaining Ethereum-grade security:

### **Revolutionary Cairo Performance**

- **Native account abstraction** - Every account is a programmable smart contract
- **Cairo VM execution** - Provable computation with mathematical guarantees
- **Sub-second finality** - Fast transaction confirmation with L1 security
- **99%+ cost reduction** compared to Ethereum mainnet

### **STARK Proof Security**

- **Zero-knowledge proofs** - Cryptographically secure state transitions
- **Ethereum settlement** - Inherits L1 security with validity proof verification
- **Decentralized proving** - Robust network with permissionless participation

### **Developer-First Ecosystem**

- **Cairo language** - Safe, powerful programming language for contracts
- **Rich tooling** - starknet.js, starknet.py, Protostar, Scarb, and more
- **Growing DeFi** - Leading protocols like Avnu, Ekubo, Nostra, JediSwap
- **Account abstraction native** - Flexible wallet experiences out of the box

## Quick Start with Starknet

Connect to Starknet in seconds with Dwellir's optimized endpoints:

### Installation & Setup

Direct JSON-RPC
starknet.js
starknet.py
Scarb & Cairo

```bash
# Get latest block number
curl -X POST https://api-starknet-mainnet.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "starknet_blockNumber",
    "params": [],
    "id": 1
  }'

# Get chain ID
curl -X POST https://api-starknet-mainnet.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "starknet_chainId",
    "params": [],
    "id": 1
  }'

# Call a contract function (ETH balance)
curl -X POST https://api-starknet-mainnet.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "starknet_call",
    "params": [
      {
        "contract_address": "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
        "entry_point_selector": "0x2e4263afad30923c891518314c3c95dbe830a16874e8abc5777a9a20b54c76e",
        "calldata": ["0x1234..."]
      },
      "latest"
    ],
    "id": 1
  }'
```

```typescript
import { RpcProvider, Contract, Account, CallData } from 'starknet';

// Connect to Starknet mainnet
const provider = new RpcProvider({
  nodeUrl: 'https://api-starknet-mainnet.n.dwellir.com/YOUR_API_KEY'
});

// Verify connection and get network info
const chainId = await provider.getChainId();
console.log('Connected to Starknet chain ID:', chainId);

// Get the latest block
const block = await provider.getBlockWithTxs('latest');
console.log('Latest block number:', block.block_number);
console.log('Block hash:', block.block_hash);

// Query account balance (ETH contract on Starknet)
const ethAddress = '0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7';
const accountAddress = '0x1234...'; // Your account address

const { result } = await provider.callContract({
  contractAddress: ethAddress,
  entrypoint: 'balanceOf',
  calldata: CallData.compile([accountAddress])
});

console.log('ETH balance:', result[0]);
```

```python
import asyncio
from starknet_py.net.full_node_client import FullNodeClient
from starknet_py.contract import Contract
from starknet_py.net.models import StarknetChainId

async def main():
    # Connect to Starknet mainnet
    client = FullNodeClient(
        node_url="https://api-starknet-mainnet.n.dwellir.com/YOUR_API_KEY"
    )

    # Verify connection
    chain_id = await client.get_chain_id()
    print(f"Connected to chain ID: {chain_id}")

    # Get latest block
    block = await client.get_block_with_txs(block_number="latest")
    print(f"Latest block: {block.block_number}")

    # Query contract (ETH token balance)
    eth_address = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7"
    account_address = "0x1234..."  # Your account address

    call_result = await client.call_contract(
        call={
            "contract_address": eth_address,
            "entry_point_selector": "balanceOf",
            "calldata": [account_address]
        }
    )

    print(f"ETH balance: {call_result}")

# Run the async function
asyncio.run(main())
```

```bash
# Initialize a new Cairo project with Scarb
scarb new my_starknet_contract
cd my_starknet_contract

# Add Starknet dependencies to Scarb.toml
cat >> Scarb.toml << EOF

[[target.starknet-contract]]
sierra = true
casm = true

[dependencies]
starknet = ">=2.6.3"
EOF

# Create a simple contract
cat > src/lib.cairo << 'EOF'
#[starknet::interface]
trait IHelloStarknet<TContractState> {
    fn increase_balance(ref self: TContractState, amount: felt252);
    fn get_balance(self: @TContractState) -> felt252;
}

#[starknet::contract]
mod HelloStarknet {
    #[storage]
    struct Storage {
        balance: felt252,
    }

    #[abi(embed_v0)]
    impl HelloStarknetImpl of super::IHelloStarknet<ContractState> {
        fn increase_balance(ref self: ContractState, amount: felt252) {
            self.balance.write(self.balance.read() + amount);
        }

        fn get_balance(self: @ContractState) -> felt252 {
            self.balance.read()
        }
    }
}
EOF

# Build the contract
scarb build
```

## Network Information

| Parameter     | Value        | Details                 |
| ------------- | ------------ | ----------------------- |
| Chain ID      | SN\_MAIN     | 0x534e5f4d41494e        |
| Block Time    | \~10 seconds | STARK proof batches     |
| Native Token  | ETH          | Fee token               |
| Account Model | AA Native    | Smart contract accounts |

### Network Details

| Parameter                  | Value                                              | Details |
| -------------------------- | -------------------------------------------------- | ------- |
| Mainnet Chain ID           | `0x534e5f4d41494e` (`SN_MAIN`)                     |         |
| Testnet (Sepolia) Chain ID | `0x534e5f5345504f4c4941` (`SN_SEPOLIA`)            |         |
| Fee Tokens                 | ETH (primary), STRK (governance, future staking)   |         |
| Finality                   | L2 confirmation (\~10s), L1 finality (\~1-4 hours) |         |
| TPS                        | 50+ current, 100+ roadmap with parallel execution  |         |

## API Reference

Starknet implements its own JSON-RPC namespace (`starknet_*`) with Cairo-specific functionality. Access all Starknet methods with STARK proof security.

## Common Integration Patterns

### Account Management

```typescript
import { Account, RpcProvider } from 'starknet';

const provider = new RpcProvider({
  nodeUrl: 'https://api-starknet-mainnet.n.dwellir.com/YOUR_API_KEY'
});

const account = new Account(provider, accountAddress, privateKey);
const nonce = await account.getNonce();
```

### Token Operations

```typescript
// Get token balance
const { result } = await provider.callContract({
  contractAddress: tokenAddress,
  entrypoint: 'balanceOf',
  calldata: [accountAddress]
});
```

### Contract Calls

```typescript
// Execute contract function
const call = {
  contractAddress: contractAddress,
  entrypoint: functionName,
  calldata: [param1, param2]
};

const { transaction_hash } = await account.execute(call);
```

## Resources & Tools

### Official Resources

- [Starknet Documentation](https://docs.starknet.io/)
- [Cairo Language Guide](https://book.cairo-lang.org/)
- [Starknet JSON-RPC Spec](https://github.com/starkware-libs/starknet-specs)

### Block Explorers

- [Voyager Explorer](https://voyager.online/) - Comprehensive block explorer
- [Starkscan](https://starkscan.co/) - Alternative explorer with rich features

### Developer Tools

- [Starknet.js](https://www.starknetjs.com/) - TypeScript SDK
- [Starknet.py](https://github.com/software-mansion/starknet.py) - Python SDK
- [Scarb](https://docs.swmansion.com/scarb/) - Cairo package manager
- [Starknet Foundry](https://foundry-rs.github.io/starknet-foundry/) - Testing framework
- [Protostar](https://docs.swmansion.com/protostar/) - Cairo development toolchain

### Ecosystem Projects

- [Avnu](https://www.avnu.fi/) - DEX aggregator
- [Ekubo Protocol](https://ekubo.org/) - Concentrated liquidity AMM
- [Nostra](https://nostra.finance/) - Money market protocol

### Need Help?

- **Email**: <support@dwellir.com>
- **Docs**: You're here!
- **Dashboard**: [dashboard.dwellir.com](https://dashboard.dwellir.com)
- **Community**: [Starknet Discord](https://discord.gg/qypnmzkhbc)

### Related Reading

- [Top 6 Starknet RPC Providers](https://www.dwellir.com/blog/best-starknet-rpc-providers)

***

*Start building on Starknet with Cairo-powered smart contracts using Dwellir's enterprise-grade RPC infrastructure. [Get your API key](https://dashboard.dwellir.com/register)*