Here’s a simple working Solidity contract demonstrating your mapping example with NetworkConfig

[mirmohmmadluqman]

Here’s a simple working Solidity contract demonstrating your mapping example with NetworkConfig:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract NetworkManager {

    // Define the struct
    struct NetworkConfig {
        uint256 entranceFee;
        uint256 interval;
        address vrfCoordinator;
        bytes32 gaselane;
        uint32 callbackGasLimit;
        uint256 subscriptionId;
    }

    // Single local network config
    NetworkConfig public localNetworkConfig;

    // Mapping from chainId to network config
    mapping(uint256 => NetworkConfig) public networkConfig;

    // Set local network config
    function setLocalConfig(
        uint256 entranceFee,
        uint256 interval,
        address vrfCoordinator,
        bytes32 gaselane,
        uint32 callbackGasLimit,
        uint256 subscriptionId
    ) external {
        localNetworkConfig = NetworkConfig({
            entranceFee: entranceFee,
            interval: interval,
            vrfCoordinator: vrfCoordinator,
            gaselane: gaselane,
            callbackGasLimit: callbackGasLimit,
            subscriptionId: subscriptionId
        });
    }

    // Set config for a specific chainId
    function setNetworkConfig(
        uint256 chainId,
        uint256 entranceFee,
        uint256 interval,
        address vrfCoordinator,
        bytes32 gaselane,
        uint32 callbackGasLimit,
        uint256 subscriptionId
    ) external {
        networkConfig[chainId] = NetworkConfig({
            entranceFee: entranceFee,
            interval: interval,
            vrfCoordinator: vrfCoordinator,
            gaselane: gaselane,
            callbackGasLimit: callbackGasLimit,
            subscriptionId: subscriptionId
        });
    }

    // Get entrance fee for a chainId
    function getEntranceFee(uint256 chainId) external view returns (uint256) {
        return networkConfig[chainId].entranceFee;
    }

    // Get VRF coordinator for a chainId
    function getCoordinator(uint256 chainId) external view returns (address) {
        return networkConfig[chainId].vrfCoordinator;
    }
}

---

1 How it works

1. networkConfig stores configs per chain ID.
2. localNetworkConfig stores config for your local/test network.
3. setNetworkConfig() → saves data into mapping.
4. getEntranceFee() → reads data from mapping.
5. public mapping automatically creates a getter too, e.g.:

networkConfig[31337].entranceFee

---

Brief Explaination:

let’s break mapping in Solidity clearly

2 What a mapping is

• A mapping is like a key-value store (like a dictionary in Python).
• Each key maps to a value.
• In your code:

mapping(uint256 => NetworkConfig) public networkConfig;

• Key = uint256 (maybe a chain ID like 1 for Ethereum mainnet, 31337 for local).
• Value = NetworkConfig struct.

---

2 How data is stored

• Solidity stores mapping in a hash table in storage, not in a sequential array.

• You cannot iterate over mappings directly — you only access values by key.

• Example storing a value:

networkConfig[31337] = NetworkConfig({
    entranceFee: 0.01 ether,
    interval: 300,
    vrfCoordinator: 0x123...,
    gaselane: 0xabc...,
    callbackGasLimit: 500000,
    subscriptionId: 1
});

• This stores a NetworkConfig for chain ID 31337.

---

4 How to call/use it

• Since you declared public, Solidity auto-creates a getter:

NetworkConfig memory config = networkConfig[31337];

• Access individual fields:

uint256 fee = networkConfig[31337].entranceFee;
address coordinator = networkConfig[31337].vrfCoordinator;

• Example inside a function:

function getFee(uint256 chainId) external view returns (uint256) {
    return networkConfig[chainId].entranceFee;
}

---

4️⃣ Accessing localNetworkConfig

• It’s just a single struct, not a mapping:

localNetworkConfig.entranceFee; // gets the fee for local network

---

TL;DR

• mapping = key → value (like dictionary)
• store = networkConfig[chainId] = ...
• read = networkConfig[chainId].field

[EngrPips]

Excellent, Thanks for this detailed explanation.

[Andy-Fernandez]

Cool, but I don’t get how I could actually use it — not how the mappings work, but like, in what situation I’d even use this NetworkManager contract. (Sorry if that’s a basic question)

[mirmohmmadluqman]

Hey Andy! Totally fair question. This contract is part of a course example, but it’s also very usable in real projects.

Think of it like a configuration manager. In real blockchain setups, different networks (like Sepolia, Mainnet, or Local Anvil) have different settings — for example, different VRF coordinators, subscription IDs, or gas lanes.

So instead of hardcoding all that inside every contract or script, we use something like this NetworkManager (or HelperConfig in Foundry) to store and fetch the right parameters automatically based on the network we’re on.

This kind of pattern is actually used a lot in deployment scripts, testing setups, and Chainlink VRF/Automation projects to make the same code work smoothly across networks.

So yeah, it’s part of the course, but it’s also a real dev pattern used by auditors and smart contract engineers every day.

If you want to know How It’s Used, Real-World Scenarios, or Why It Matters, Let me know !

[Ptyline]

Interesting

[EngrPips]

Indeed.