Efficiently fill a Solidity array with a range of numbers

Question

does anyone know how I can fill an array with numbers 1 - 10,000 efficiently? For example, in our constructor we have the following but it doesn't work due to gas costs; too many items to push to a dynamic array. If I do, let's say 100, it works fine.

    constructor() ERC721("Contract", "C") {
        for (uint i = 1; i < 10001; i++) {
            tokens.push(i);
        }
    }

Any ideas?

For context, in my smart contract we want to randomly choose an id to mint to avoid sequential minting, so we use a Chainlink VRF to get a random number less than the tokens array length, choose an id randomly from the array, then remove the last index to shrink the array using roughly this code:

    uint[] tokens;
    uint randomNumber = RandomNumberContract.randomResult();
    function handleGetTokenId(uint _tokenOffset) public onlyOwner returns(uint) {
        require(tokens.length > 0, "No more tokens left");

        // random number based on number of tokens left
        uint randomIndex = uint(keccak256(abi.encode(randomNumber, _tokenOffset))) % tokens.length;

        // random id at index in array
        uint randomId = tokens[randomIndex];

        require(!_exists(randomId), "token already minted");

        // at position randomIndex, replace with last id
        tokens[randomIndex] = tokens[tokens.length - 1];
        // remove last index; shortens length and ensures no double minting
        tokens.pop();

        return randomId;
    }

The issue is, we have 10,000 ids to choose from and we cannot efficiently fill the dynamic array at initialization. Is there a better way to randomly choose an id to mint, or to keep track of what's been minted or not? Also we tried using a fixed size array which is cheaper with gas, but couldn't find a solution to effectively choose a random number within the range of 0 to numberOfTokensMinted because we do not have the arrays length.

Answer 1

Filling an array in this way is not efficient. Tool many elements being added at once, depleting all the gas. Adding one element at a time after construction is not feasible either, since there are too many of them.

For your use case, since you only want some sort of a list of ids from 1 to 10000, you can use some interesting tricks with the modulo operator % and a single uint variable.

You can create a uint public tokensCount = 10_000 state variable and use a random number of the block.timestamp alone or mixed with a random number or any other number, to generate a number to be used as an id in your desired range and decrease the tokensCount by one so next time you get a number in between a new range.

Then, you can save in a mapping if this id was already used or not.

Take a look at my example below.

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

contract ModuloRanging {

    uint constant public tokensCount = 10_000;
    uint public tokensProcessed = 0;
    uint public lastId;
    mapping(uint => bool) public mited;

    function handleGetTokenId() public returns(uint) {
        require(tokensProcessed >= tokensCount, "No more tokens left");

        // For more "randomness", mix the block.timestamp with any other "random" number before applying the modulo operator
        // or simply use a random number, or the keccak256 of the random number and the _tokenOffset
        // uint id = (block.timestamp + randomNumber) % tokensCount;
        uint id = (block.timestamp + tokensProcessed) % tokensCount;

        require(!mited[id], "Token already minted");

        tokensProcessed++;

        lastId = id;
        return id;
    }

}

You can try it out and see the value of lastId in remix.

This approach is extremely efficient compared to using arrays and mappings.