Upgrade strategies in Blockchain / Solidity - Time & Space Complexity

Time Complexity: Upgrade strategies

O(n)

Understanding Time Complexity

When upgrading blockchain contracts or systems, it is important to understand how the time to complete an upgrade grows as the system size increases.

We want to know how the upgrade process scales when more data or components are involved.

Scenario Under Consideration

Analyze the time complexity of the following upgrade function.

function upgradeContracts(address[] memory contracts) public {
  for (uint i = 0; i < contracts.length; i++) {
    address current = contracts[i];
    // Perform upgrade steps on each contract
    upgradeSingleContract(current);
  }
}

function upgradeSingleContract(address contractAddr) internal {
  // Simulate upgrade logic
  // e.g., migrate storage, update logic pointers
}
    

This code upgrades multiple contracts one by one by calling an upgrade function on each.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the list of contracts to upgrade each one.
• How many times: Once for each contract in the input array.

How Execution Grows With Input

As the number of contracts to upgrade increases, the total work grows in direct proportion.

Input Size (n)	Approx. Operations
10	10 upgrade calls
100	100 upgrade calls
1000	1000 upgrade calls

Pattern observation: Doubling the number of contracts doubles the total upgrade time.

Final Time Complexity

Time Complexity: O(n)

This means the upgrade time grows linearly with the number of contracts to upgrade.

Common Mistake

[X] Wrong: "Upgrading multiple contracts at once is always constant time because it's one function call."

[OK] Correct: The function loops through each contract, so the time depends on how many contracts there are, not just one call.

Interview Connect

Understanding how upgrade operations scale helps you design efficient blockchain systems and answer questions about performance in real projects.

Self-Check

"What if the upgradeSingleContract function itself had a loop over internal data? How would that affect the overall time complexity?"