The Challenge of Go’s Map Iteration in the Cosmos SDK Blockchain: A Dive into Determinism

Mo Ashouri
5 min readOct 16, 2023


Author, Mo Ashouri,

Understanding the interplay between programming languages and deterministic behaviors is crucial as a senior blockchain engineer. In this article, I will shed light on the Cosmos SDK, a prominent blockchain framework built using Go, emphasizing the importance of deterministic operations. With a focus on the non-deterministic iteration behavior inherent in Go maps, the piece provides developers with insights into potential pitfalls and solutions. By exploring the nuances of the Cosmos SDK and Go’s characteristics, readers can see the challenges and best practices in ensuring blockchain reliability and integrity.

Golang and Background: The Pillar of Determinism in Blockchain

Golang is celebrated for its concurrency capabilities, efficiency, and simplicity. However, like all languages, Go has its idiosyncrasies. One such peculiarity that has raised eyebrows, especially in deterministic systems like blockchain, is the non-deterministic iteration behavior of its native map data structure.

In a blockchain, determinism stands as a non-negotiable element. Every node in a decentralized network must process transactions identically, ensuring they reach the same state. This uniformity maintains consensus across the entire network.

However, non-deterministic behaviors, where outcomes are unpredictable or varied, can spell disaster in this environment:

  • Consensus Failure: Nodes with differing states can cause the network to splinter, leading to forks.
  • Double Spending: Indeterminacy can be exploited, allowing actors to spend the same funds multiple times.
  • Contract Vulnerabilities: Smart contracts relying on a specific order can malfunction, leading to unintended behaviors.

The language and tools used in developing blockchain solutions become paramount given these potential pitfalls.

Golang & Cosmos SDK: A Powerful Duo

The Cosmos SDK is a powerhouse for creating interoperable, customizable, and scalable blockchains. At its core, it leverages Go (Golang), renowned for its simplicity and efficiency. However, with Go’s many strengths come certain quirks, one being its behavior with map iterations.

In Go, iterating over maps does not guarantee a consistent order. For many applications, this poses no issue. However, within the rigid deterministic world of blockchain, such variability can introduce severe challenges.


package main
import "fmt"
func main() {
m := map[string]int{
"one": 1,
"two": 2,
"three": 3,
for key, value := range m {
fmt.Println(key, value)

This Go program, when run multiple times, might yield differing key-value pair orders:

Run 1:
one 1
three 3
two 2
Run 2:
two 2
one 1
three 3

Such unpredictable orders can cause the issues mentioned above when applied to a blockchain project.

Implications for Blockchain

In the domain of blockchain, determinism is of utmost importance. For a blockchain network to maintain consensus, all nodes must process transactions in the exact same sequence, leading to an identical state. The non-deterministic behavior of Go’s map iteration poses a risk, as it can introduce subtle inconsistencies between nodes, potentially leading to consensus failures.

A few potential risks include:

  • Consensus Failure: As mentioned, nodes may derive different states due to varying order of map iteration, resulting in a split or “fork” in the blockchain.
  • Smart Contract Vulnerabilities: Contracts, especially those that involve token distribution or voting mechanisms, may malfunction if they rely on specific map iteration order.
  • Transaction Inconsistencies: Differences in transaction ordering across nodes can cause discrepancies in the blockchain state.

Other Non-deterministic Behaviors

While map iteration stands out, it’s worth noting that Go has other potential sources of non-determinism. For instance:

  • Goroutines: The scheduling of goroutines is not deterministic. If not handled carefully, concurrent execution can introduce race conditions, another source of non-determinism.
  • Time-dependent operations: Functions that depend on the current time, like time.Now(), can produce different results across nodes.

Solutions for the developers

The non-deterministic behavior of Go’s map iteration presents challenges, but they are not insurmountable. Cosmos SDK developers have several strategies to ensure determinism and, by extension, maintain the integrity of the blockchain systems they build. Below are expanded solutions with more detailed explanations:

1. Avoid Native Go Maps for Critical Logic

  • Description: In contexts where the data sequence is paramount, relying on Go’s native map can introduce unwanted variability. The iteration order of a map isn’t fixed and can differ across program runs.
  • Recommendation: Instead of the native map, utilize slices or linked lists, which maintain the insertion order. These data structures provide predictability, making them more suited for deterministic systems like blockchain. When order is a non-issue, maps remain a powerful tool for O(1) average time complexity lookups.

2. Embrace Deterministic Data Structures

  • Description: Recognizing the need for determinism in blockchain applications, the Cosmos SDK comes equipped with tools tailored for this purpose.
  • Recommendation: Make use of structures like those KVStore provided by Cosmos SDK. The KVStore is a key-value store that guarantees deterministic behavior, thereby eliminating the concerns associated with non-deterministic map iterations. By leaning into these purpose-built structures, developers can harness the power of Go while ensuring their blockchain applications remain consistent across all nodes1.

3. Rigorous Testing

  • Description: The complex nature of blockchain applications, combined with the intricacies of the Go language, means that unforeseen behaviors might emerge in edge cases or uncommon scenarios.
  • Recommendation: Implement a robust testing regimen. Continually and comprehensively testing smart contract logic, especially in varied and extreme scenarios, is essential. Unit, integration, and stress tests can help developers identify and rectify potential non-deterministic behaviors before they manifest in a live environment. Modern testing tools and frameworks for Go can simulate different conditions and sequences to ensure the desired determinism.

By incorporating these solutions into their development workflow, Cosmos SDK developers can effectively navigate the challenges posed by Go’s non-deterministic behaviors, ensuring the creation of robust and reliable blockchain systems.


When building with the Cosmos SDK using Go, understanding the specifics of Go’s data structures becomes essential. One such nuance is the behavior of Go maps, which can be unpredictable. For blockchain applications where every detail matters, this unpredictability can lead to larger issues.

I am Mo Ashouri, a cybersecurity expert and blockchain researcher who highlights the importance of being aware of these subtleties. If you’re diving into blockchain development or are keen on cybersecurity insights, following me on social media is a great way to stay updated. His insights are informative and practical, tailored for developers in the field.


  1. Go Documentation: “Map Types”
  2. Cosmos SDK Official Documentation
  3. The Go Blog: “Go maps in action”
  4. Blockchain Basics: Understanding Determinism in Smart Contracts
  5. Non-deterministic Behaviors in Smart Contracts: A Survey
  6. Cosmos SDK GitHub Repository



Mo Ashouri

Mo has a Ph.D. in Compter Science. Mo specializes in Backend Programming and Security.