> ## Documentation Index
> Fetch the complete documentation index at: https://docs.starknet.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Network, RPC, Staking, and Bridging

> Configure networks, RPC providers, staking, and bridging for the SDK

## Overview

The `StarkZap` accepts configuration through a single options object. You can use network presets for simplicity, or provide explicit RPC URLs and chain IDs for custom setups.

<Info>
  **New to blockchain?** An **RPC** (Remote Procedure Call) is like an API endpoint for the blockchain—it's how your app communicates with the network. A **network** is like an environment (production, staging, development). See the [Glossary](/build/starkzap/glossary) for more web2-friendly explanations.
</Info>

<AccordionGroup>
  <Accordion title="Network">
    The simplest way to configure the SDK is using network presets. Think of networks like environments:

    * **mainnet** = Production (real money, real transactions)
    * **sepolia** = Staging/Testnet (fake money for testing)
    * **devnet** = Local development (your own test blockchain)

    ```typescript theme={null}
    import { StarkZap } from "starkzap";

    // Mainnet
    const sdk = new StarkZap({ network: "mainnet" });

    // Sepolia testnet
    const sdk = new StarkZap({ network: "sepolia" });

    // Local devnet (starknet-devnet-rs)
    const sdk = new StarkZap({ network: "devnet" });
    ```

    ### Available Presets

    | Preset    | Chain ID     | RPC                                           | Explorer                         |
    | --------- | ------------ | --------------------------------------------- | -------------------------------- |
    | `mainnet` | `SN_MAIN`    | `https://api.cartridge.gg/x/starknet/mainnet` | `https://voyager.online`         |
    | `sepolia` | `SN_SEPOLIA` | `https://api.cartridge.gg/x/starknet/sepolia` | `https://sepolia.voyager.online` |
    | `devnet`  | `SN_SEPOLIA` | `http://localhost:5050`                       | —                                |

    ### Using Network Objects

    You can also pass a custom `NetworkPreset` object:

    ```typescript theme={null}
    import { StarkZap, networks } from "starkzap";

    const sdk = new StarkZap({ network: networks.mainnet });
    ```
  </Accordion>

  <Accordion title="RPC">
    If you run your own blockchain node or use a different RPC provider (like using a different API endpoint):

    <Info>
      An **RPC provider** is like choosing which API server to use. Just like you might use AWS, Google Cloud, or your own servers, you can use different RPC providers to connect to the blockchain.
    </Info>

    ```typescript theme={null}
    import { StarkZap, ChainId } from "starkzap";

    const sdk = new StarkZap({
      rpcUrl: "https://starknet-mainnet.infura.io/v3/YOUR_KEY",
      chainId: ChainId.MAINNET,
    });
    ```

    <Note>
      `rpcUrl` and `chainId` override values from `network` if both are provided.
    </Note>
  </Accordion>

  <Accordion title="Staking">
    Enable staking functionality to let users earn passive income by staking their tokens. When configured, users can:

    * 💰 **Stake tokens** in validator pools and earn rewards over time (like earning interest on a savings account)
    * 📈 **Grow their holdings** as rewards accumulate automatically
    * 🔄 **Manage their positions** by adding more tokens, claiming rewards, or exiting pools
    * 🏦 **Support network security** while earning passive income

    Staking works out of the box using chain-aware staking contract presets:

    ```typescript theme={null}
    import { StarkZap } from "starkzap";

    const sdk = new StarkZap({
      network: "mainnet",
    });
    ```

    If needed, you can override the default preset:

    ```typescript theme={null}
    import { StarkZap, fromAddress } from "starkzap";

    const sdk = new StarkZap({
      network: "mainnet",
      staking: {
        contract: fromAddress(
          "0x00ca1702e64c81d9a07b86bd2c540188d92a2c73cf5cc0e508d949015e7e84a7"
        ),
      },
    });
    ```

    <Info>
      **Ready to implement staking?** See the [Staking & Delegation Guide](/build/starkzap/staking) for complete instructions on how users can stake tokens, claim rewards, and manage their positions.
    </Info>
  </Accordion>

  <Accordion title="Bridging">
    Configure optional cross-chain bridge settings when depositing assets from Ethereum or Solana into Starknet.

    ```typescript theme={null}
    import { StarkZap } from "starkzap";

    const sdk = new StarkZap({
      network: "mainnet",
      bridging: {
        ethereumRpcUrl: "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY",
        solanaRpcUrl: "https://solana-mainnet.g.alchemy.com/v2/YOUR_KEY",
        layerZeroApiKey: "YOUR_LAYERZERO_API_KEY", // for OFT routes
      },
    });
    ```

    * `ethereumRpcUrl`: Custom Ethereum RPC for bridge fee/balance operations
    * `solanaRpcUrl`: Custom Solana RPC (falls back to cluster URL if omitted)
    * `layerZeroApiKey`: Required for OFT/OFT-migrated routes

    <Warning>
      OFT routes require `bridging.layerZeroApiKey` and are supported on mainnet bridge routes only.
    </Warning>

    <Info>
      For the full deposit flow (`getBridgingTokens`, external wallet adapters, fee estimate, deposit), see the [Bridging Guide](/build/starkzap/bridging).
    </Info>
  </Accordion>
</AccordionGroup>

## Complete Configuration Example

Here's an example with all optional features configured:

### Using Network Preset

```typescript theme={null}
import { StarkZap, fromAddress } from "starkzap";

const sdk = new StarkZap({
  // Network configuration
  network: "mainnet",
  
  // Optional: override staking contract preset
  staking: {
    contract: fromAddress(
      "0x00ca1702e64c81d9a07b86bd2c540188d92a2c73cf5cc0e508d949015e7e84a7"
    ),
  },
  bridging: {
    ethereumRpcUrl: "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY",
    layerZeroApiKey: "YOUR_LAYERZERO_API_KEY",
  },
});
```

### Using Custom RPC

```typescript theme={null}
import { StarkZap, ChainId, fromAddress } from "starkzap";

const sdk = new StarkZap({
  // Custom RPC configuration
  rpcUrl: "https://starknet-mainnet.infura.io/v3/YOUR_KEY",
  chainId: ChainId.MAINNET,
  
  // Optional: override staking contract preset
  staking: {
    contract: fromAddress(
      "0x00ca1702e64c81d9a07b86bd2c540188d92a2c73cf5cc0e508d949015e7e84a7"
    ),
  },
  bridging: {
    solanaRpcUrl: "https://solana-mainnet.g.alchemy.com/v2/YOUR_KEY",
  },
});
```

<Note>
  For paymaster configuration, see the [Paymasters Guide](/build/starkzap/paymasters) for detailed setup instructions for AVNU Paymaster or Cartridge's built-in paymaster.
</Note>

## Configuration Type Reference

```typescript theme={null}
interface SDKConfig {
  // Network (choose one)
  network?: NetworkName | NetworkPreset;
  rpcUrl?: string;
  chainId?: ChainId;
  
  // Optional features
  paymaster?: PaymasterOptions; // { nodeUrl?: string; default?: boolean; headers?: object }
  explorer?: ExplorerConfig;
  staking?: StakingConfig;
  bridging?: BridgingConfig;
}

interface StakingConfig {
  contract: Address; // optional override
}

interface BridgingConfig {
  layerZeroApiKey?: string;
  ethereumRpcUrl?: string;
  solanaRpcUrl?: string;
}
```

<Note>
  For paymaster configuration details, see the [Paymasters Guide](/build/starkzap/paymasters).
</Note>

## Next Steps

* Set up [Paymasters](/build/starkzap/paymasters) for gasless transactions
* Enable [Staking & Delegation](/build/starkzap/staking) so users can earn passive income
* Configure [Bridging](/build/starkzap/bridging) for Ethereum/Solana deposits into Starknet
* Learn about [Connecting Wallets](/build/starkzap/connecting-wallets) with different signers
* Configure [Account Presets](/build/starkzap/connecting-wallets#account-presets) for your use case