Let’s look at some idiomatic Rust code, and see if we can explain what it’s doing and why! .iter().cloned().collect() often pops up when converting simple arrays into more complex collections like HashMap. Why Use This? This approach shines when initializing complex data structures while keeping your code concise. It’s also flexible—start with a small array, […]
Beyond the beginner friendly Soroban basics? Let’s now look at a larger Smart Contract example. As usual we’ll get to the essence of the code. We’ll stick to Alice and Bob for familiarity. What are we trying to achieve? The TimeLockContract is a Soroban smart contract designed to manage delayed execution of operations in a […]
![&[&str] vs [&str; N] in Function Parameters](https://redandgreen.co.uk/wp-content/uploads/2024/07/a7ed12e3-f5a0-4155-884e-2c92191913d9-150x150.jpeg)
In Rust, handling function parameters often involves understanding the distinction between fixed-size arrays ([&str; N]) and slices (&[&str]). While both are collections of elements, their use cases and behaviours differ significantly, particularly when working with dynamically sized inputs. This article will help clarify the differences and explain when to use each approach, complete with example […]
repr Memory Efficiency with #[repr(u8)] In Rust, enums are often used to represent a type that can take on a set of values, but by default, the underlying representation of an enum might be larger than needed. Using #[repr], we can specify exactly how we want the enum to be stored in memory. Let’s explore […]
This article explains how to use one of the Soroban provided examples We’ll Deploy and Invoke Soroban Smart Contracts where one contract calls another. TL;DR: Contract B’s add_with function invokes Contract A’s add function to do some addition. **Ok, so I used chatGPT to help write this, but the code has been tested by a […]
Merkle trees are a fundamental component in many blockchain and cryptographic systems. They allow for efficient and secure verification of large datasets. In this article, we’ll walk through how to build a Merkle tree in Rust, step-by-step, and provide the complete code at the end. Understanding the Process Here’s how the construction of a Merkle […]
When working with Rust, you’ll often encounter scenarios where you need to interact with slices. Two common approaches for converting data structures to slices are using .as_slice() and the &[ ] syntax. While both can often achieve the same result, there are subtle differences in intent, safety, and compatibility that make each appropriate for different […]
Understanding UTXO References in Transactions with Rust: A Practical Guide In blockchain and cryptocurrency systems, UTXO (Unspent Transaction Output) is a critical concept. Transactions consume UTXOs from previous transactions and create new ones for future use. This tutorial will guide you through using Rust to search for transactions referencing specific UTXOs using efficient data structures […]
Let’s assume we have a list of numbers, and we want to transform them into a list of structs: into_iter(): Consumes the original collection, turning it into an iterator. enumerate(): Adds an index (id) to each item. map(): Applies a closure to transform each item. collect(): Gathers the transformed items into a collection (e.g., Vec). […]
Comparison: impl Fn vs Box<dyn Fn> 1. Using impl Fn (Static Dispatch) Explanation: 2. Using Box<dyn Fn> (Dynamic Dispatch) Explanation: Key Differences: Feature impl Fn (Static Dispatch) Box<dyn Fn> (Dynamic Dispatch) Dispatch Type Compile-time (Static Dispatch) Run-time (Dynamic Dispatch) Performance Faster (No heap allocation) Slower (Heap allocation + Indirection) Flexibility Less flexible (Fixed closure type) […]