This textbook was generated automatically from a GitHub Repo. Visit the repo for more information.

# IOTA Developer Essentials

These notebooks provide a self-study introduction to IOTA protocol and are designed for developers and tech enthusiasts who would like to get quickly familiar with the IOTA. Technical-related information is accompanied with interactive code snippets to help you to quickly jump on the platform and be ready to build own solutions based on it.

Motto of this tutorial: "Let's start with baby steps before we can try and fly."

## Main Goal

Main goal of this guide is to provide a comprehensive yet well-balanced proportion of deep-dive technical information and essentials.

## Getting Started

There are several chapters available. If you are not familiar with IOTA then it is highly recommended to follow them in the particular order to understand all important IOTA concepts properly. Otherwise you may get quickly confused later.

## Code Snippets

Code snippets are currently based on Python, NodeJs and C#. Since Python is very descriptive language and easy to understand, I believe the tutorial is basically understandable to anyone. Anyway, all important IOTA concepts are described in language-agnostic way and so you would be able to use any language of your choice.

Interested to see what is the overall code base coverage breaked down to a specific language? The following page provides you such an info. Needless to say, we are working hard to be sure there is no language that would be a second-class citizen.

IOTA Developer Essentials are accompanied by IOTA Developer Lab and so you can play with all code snippets directly in your web browser. Feel free to experiment with the prepared code snippets and get your hands dirty. It is a best way how to get familiar quickly.

All standalone code snippets are also maintained @ GitHub Gist. It enables you to fork them, comment them, share them, embed them and track all changes to them. See the action panel next to each code snippet.

## Viewing and running

### Interactive Mode

There exists a side project called IOTA Developer Lab that is built on top of IOTA Developer Essentials. The project provides infrastructure services for you to be able to get an interactive experience with all code snippets.

### Static Mode

If you prefer a static experience (for printing purposes, for instance) you can reach the given notebooks as a Complete Textbook that is compiled from all source materials:

Everything is tightly linked together and so you can easily switch between different languages for instance, or you can share links to specific chapters, code snippets, etc. All links are static so feel free to share them.

## Feedback and corrections

These notebooks are maintained at GitHub. Issues can be submited via issue tracker.

These notebooks are developed and maintained by Petr Zizka (petr@zizkovi.name). It has been supported by the EDF Grant (https://blog.iota.org/the-5th-cohort-of-iota-ecosystem-development-fund-grantees-5cbf05227525).

It is ongoing process since IOTA is still under heavy development and rapidly emerging every day. So stay tuned - the plan is to keep adding fresh content on regular basis.

Feel free to follow me at Twitter or IOTA Discord Channel (@hribek25#2683). (New to Discord? Invitation link: https://discord.gg/fNGZXvh)

Disclaimer: I am not associated with the IOTA foundation. I am IOTA supporter.

The IOTA Developer Essentials and IOTA Developer Lab are long-term projects. The main goal is to provide a comprehensive onboarding information to anybody interested in the IOTA protocol. It will cover much more chapters, more code snippets and it will also cover more languages. Your kind donations will support the vision pushing forward. Thank you.

Donations (IOTA): DSZRO9TCIJIKZOKUPVNOJFKVAHFCKL9YMLPVZUAEVZPOFXLIUWLPRQWBMVVSFTKGMGPPHXCYE9MIZEVBXQNFYKYUA9

# IOTA 101: Essentials and IOTA Terminology

IOTA is an open-source Distributed Ledger Technology (DLT) with the following characteristics: permissionless, feeless and trustless. In contrary to the blockchain technology, the IOTA transactions are stored in a form of Directed Acyclic Graph (DAG) called the Tangle.

## Transactions

Transactions (TXs) in the tangle can be of two types:

• Value transactions (IOTA token represents funds in case of value transactions)
• Zero-value transactions (aka meta transactions)

Every transaction is attached to a specific IOTA Address. There are no miners with IOTA protocol to validate transactions. The consensus is achieved by network participants themselves. Each participant that wants to broadcast a new transaction has to approve 2 past transactions and basically attach transaction as a children node. Transactions without children transactions (waiting to be confirmed) are called tips.

## Seed, private key and address

Pair of unique IOTA address and corresponding Private Key is determistically generated from a Seed. You can generate (253 - 1) different addresses/private keys based on one Seed. Anybody can send anything to the given address however only Seed owner can send funds from IOTA address since only the Seed owner is able to generate corresponding Private Key.

IOTA protocol uses One-Time Signature (OTS) for "verifying" whether private key matches to the given address, specifically Winternitz OTS (WOTS). So Private Key (specifically Key Fragments of the private key) is the key component while signing transactions using WOTS.

That's the reason why nobody should use IOTA address that have been already funds spent from. New IOTA address (of the given seed) should be generated and used instead. Please note, it applies only to fund-spending. Receiving funds/data is totaly fine even multiple times.

To summarize the key concept here. Only Seed is needed to be stored somewhere. Everything else can be safely generated from it: private key as well as address.

## IOTA nodes

The Tangle runs on a distributed network of IOTA nodes called mainnet. There are also other separate "Tangles" serving for specific purposes: Devnet, SPAMnet, etc. You can interact with the network via public nodes using collection of public API calls. You can interact with any public node of the given network since all nodes "gossiping" all TXs across the whole network. Nodes are powered by a reference piece of software called IRI (IOTA Reference Implementation) as of now.

It is also important to mention that you do not exchange any sensitive information such as Seed with a node. Every sensitive operation such as TX signing is done on client's side and node is just a "messenger" that delivers your TX to the IOTA network.

## Custom node

You can even run own IOTA node and actively participate to the whole network. There is a big advantage for developers in that case. Actual implementation of IRI provides an usefull real-time information via messaging platform called ZeroMQ and so developers can leverage that.

## API calls

There are ready-made libraries for major programming languages available and so you have more developer-friendly way how to interact with the IOTA network. Anyway, you can interact with IOTA network using pure API calls without any library. It is up to you.

## Ternary

It is difficult to avoid mentioning Ternary numeral system while discussing IOTA at all. IOTA is based on ternary system under the hood and so you have got to be aware of some basic terminology in this respect. You are going to face this fact in any developer-related IOTA guide out there.

### Ternary

Ternary has three as its base (aka base 3) as opposted to binary which is base 2. Instead of two states (0 and 1) it recognizes three states (for ex. -1, 0, 1).

### Trit

One Trite is analogous to one bit. It is the smallest digit and has three states. Trit = Trinary digit.

### Tryte

Tryte consists of three trits meaning 27 combinations. $$3^3=27$$

You will recognize soon that almost everything is encoded in Trytes in the IOTA world. Tryte is visually represented using [A..Z] alphabets and number 9. One character represents one tryte (here comes 27 possible characters again). Don't get mad, IOTA libraries are going to help us.

Small example:

#r "Tangle.Net.dll"
using Tangle.Net.Entity;

var trytes = new TryteString("YZJEATEQ9JKLZ");
Console.WriteLine(trytes.ToString());
Console.WriteLine("Number of Trytes: " + trytes.TrytesLength);

var trits = trytes.ToTrits();

Console.WriteLine(String.Join(",", trits));
Console.WriteLine("Number of Trits: " + trits.Length);

YZJEATEQ9JKLZ
Number of Trytes: 13
1,-1,0,-1,0,0,1,0,1,-1,-1,1,1,0,0,-1,1,-1,-1,-1,1,-1,0,-1,0,0,0,1,0,1,-1,1,1,0,1,1,-1,0,0
Number of Trits: 39

# IOTA 101: Basic network interactions

The tutorial is based on IOTA libraries called PyOTA for Python, IOTA Javascript Library (@iota/core) for JavaScript and Tangle.Net for C# (.NET 4.x and .NET Standard). It encapsulates all official IRI API calls and it can be installed via pip in Python environment, via npm in JS environment and via NuGet in case of .NET environment.

Reader is also encouraged to try a ready-made environment via IOTA Developer Lab project (at lab.iota101.info) where anyone can run a code directly in a web browser. When viewing it interactively then just select a code snippet and hit ctrl + enter which executes it.

Anyway, most of the information in the tutorial is language-agnostic and so only particular interfaces slightly differ across different IOTA libraries. Top-level details are the same regardless programming language you are going to use.

## A few words about specific IOTA libraries

### Python

PyOTA is well maintained and understandable IOTA library that can be reached at https://github.com/iotaledger/iota.lib.py. It is very good starting point for beginners. It can be installed via pip: pip install pyota

### JavaScipt

Official IOTA Javascript library (v1.0) is currently in beta however all main functions are working just fine, please see https://github.com/iotaledger/iota.js/. It is very modular and so you can install only components you really need.

Main component is @iota/core and can be installed via npm: npm install @iota/core

As with everything in NodeJS, most of the tasks are asynchronous and they are chained via callbacks or promise. Snippets below leverage promise chaining.

### C# (.NET)

Tangle.Net is well maintained IOTA library for .NET and can be reached at https://github.com/Felandil/tangle-.net. It can be installed via NuGet: nuget.exe install tangle.net

Snippets below uses synchronous functions however the library provides also asynchronous (async postfix) version.

## Conneting to IOTA nodes

Before you can interact with the IOTA network you need an URL of the running IOTA node. There are dozen of directories of public nodes available, feel free to google them.

For a sake of this tutorial I use a project thetangle.org. It is a load ballancer that provides you an access to a pool of participanting nodes effortlessly.

• Advantage: you do not have to care about public nodes and whether they are running or not
• Disadvantage: you do not know in advance which specific node will process your API call. So in some respect results of API calls may differ since some API calls depend on specific node, such as GetNodeInfo().

### Node is not synced

Even if a node is up and running it may not be fully prepared to process your API calls correctly. The node should be "synced", meaning should be aware of all TXs in the Tangle. It is better to avoid not fully synced nodes.

### Health checking

Once you connect to an IOTA node you should be able to send API calls. However it is better to do some checks in advance in order to find out whether the given node is in good condition or not. IOTA nodes can be run by anyone and so health check is always a good practice.

Basic healthcheck can be done via GetNodeInfo() API call. It returns a basic information about the given IOTA node.

#r "Tangle.Net.dll"
#r "Newtonsoft.Json.dll"
#r "RestSharp.dll"

using Tangle.Net.Repository;
using Newtonsoft.Json;
using RestSharp;

var NodeURL = "https://nodes.thetangle.org:443";

var repo = new RestIotaRepository(new RestClient(NodeURL)); // ctor initialization of the Tangle.Net library
var nodeInfo = repo.GetNodeInfo(); // Getting information about the current node
Console.WriteLine(JsonConvert.SerializeObject(nodeInfo, Formatting.Indented)); //Result is printed in JSON notation

// Basic check whether node is in sync or not
// Elementary rule is that "latestMilestoneIndex" should equal to "latestSolidSubtangleMilestoneIndex" or be very close
Console.WriteLine(
Math.Abs(nodeInfo.LatestMilestoneIndex - nodeInfo.LatestSolidSubtangleMilestoneIndex) > 3 ?
"Node is probably not synced!" : "Node is probably synced!"
);

{
"AppName": "IRI",
"AppVersion": "1.8.1",
"Duration": 0,
"JreAvailableProcessors": 16,
"JreFreeMemory": 1854364030,
"JreMaxMemory": 20997734400,
"JreTotalMemory": 4585458676,
"LatestMilestone": "UNFVFYFRHCKCYSCSLDAJROUSBEPYTOOHHJOGZGLJXJIBSTXAYTIKDMWEKPMMKHVOSETQJYEFUXLOZ9999",
"LatestMilestoneIndex": 1178174,
"LatestSolidSubtangleMilestone": "UNFVFYFRHCKCYSCSLDAJROUSBEPYTOOHHJOGZGLJXJIBSTXAYTIKDMWEKPMMKHVOSETQJYEFUXLOZ9999",
"LatestSolidSubtangleMilestoneIndex": 1178174,
"Neighbors": 24,
"PacketsQueueSize": 0,
"Time": 1568711224721,
"Tips": 7991,
"TransactionsToRequest": 0
}
Node is probably synced!

Please note: When using node load balancers then this type of check is quite useless since other API calls of yours may be served by different node that may have not been checked. You should be aware of it and trust that the load balancer participates only with nodes that are in a good condition.

## Generating IOTA seed and IOTA address

Since the IOTA network is permissionless type of network, anybody is able to use it and interact with it. No central authority is required at any stage. So anybody is able to generate own seed and respective private key/address anytime. It is highly recommended to NOT use online generators at all.

The Seed is the only key to the given addresses. Anyone who owns the Seed owns also all funds related to respective IOTA addresses (all of them).

Seed and addresses only consists of characters [A-Z] and number 9. Length is always 81 charaters. There are usually also used additional 9 characters in IOTA addresses (so total lenght is 90 then) which is a checksum. It provides a way how to prevent typos while manipulating with IOTA addresses.

### Seed

A seed generation is a process that is based on random quessing of each character in the seed. Of course, you should always use cryptographically secure pseudo-random generator!

//based on https://github.com/siqniz/IOTA-Random-Seed-Generator
using System.Security.Cryptography;

private static string NewRandomSeed()
{
string iotaseed = string.Empty;
using (RNGCryptoServiceProvider _ran = new RNGCryptoServiceProvider()) // The class provides crypto-safe random generator
{
string[] _seed = new string[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "9" };

byte[] _data = new byte[8];  //8 bytes to hold an unsigned bits int
for (int i = 0; i <= 80; i++)   //The number times this will run in orde to fill the 81 char requirment
{
_ran.GetBytes(_data);
var gennum = BitConverter.ToUInt64(_data, 0);
var _num = (gennum % 27);
iotaseed += _seed[_num];
}
}

return iotaseed;
}

Console.WriteLine(NewRandomSeed());

U9LYFWEPCQATZ9MNDQJZPMSCVQZMTNTWRWOIIPDCXOORZAPYATQGRZHVHSQ9DL9RYKGP9PAEBOTKAFM9R

Alternatively you can leverage also PyOTA library since it has own implementation of the pseudo-random Seed generator (Python 2.7+ compatible). Difference between both methods is very subtle. I just wanted to illustrate both ways: Fully independent and IOTA-library-dependant. Please note, IOTA Javascript library does not support a seed generation.

#r "Tangle.Net.dll"
using Tangle.Net.Entity;

var seed = Seed.Random(); // Initializing new random seed
Console.WriteLine(seed.ToString());
Console.WriteLine("Length :" + seed.ToString().Length);

9KCKAMKL9JDWXTQKSEDBKJHZHBBARHBD9HXTDLSWQTGOXWBGDVOKOAFVHYKUYHIJKYCI9AETEKXIYQCAV
Length :81

There is a deterministic function how to get an address from a seed. It is a basically an indexed collection of addresses starting with address at index 0, 1, 2, etc.

While generating addresses you should be also aware there are three different so called Security Levels (1, 2 and 3). Each security level generates totally independent pool of addresses. Addresses of Security Level 1 are totally different from addresses of Security Level 2, etc.

In a nutshell, Security Level indicates how difficult is to generate Private key from the Seed and also what is its size. The higher security level, the more secure (longer) is the given private key. Default Security Level is 2. Most of IOTA wallets uses Security Level=2 and users are usually not allowed to change it. So be carefull while designing your app.

As long as seed, address index and security level are the same, you always get the same address and corresponding private key:

$$PrivateKey/Address = fce(Seed, AddressIndex, SecurityLevel)$$

General example: $$PrivateKey/Address1 = fce(Seed, 1, 2)$$ $$PrivateKey/Address2 = fce(Seed, 2, 2)$$ $$PrivateKey/Address3 = fce(Seed, 3, 2)$$

// No code snippet available for the selected language: csharp


Please note, some IOTA libraries may communicate with a IOTA network while generating addresses to double check whether the given address was used or not.

So it is sometimes better to use directly an address generator component. Outputs are equivalent in both cases but the latter one usually only generates pool of addresses locally:

#r "Tangle.Net.dll"
#r "Newtonsoft.Json.dll"

using Tangle.Net.Cryptography;
using Tangle.Net.Entity;
using Newtonsoft.Json;

SecurityLevel.Medium //security level 2
,0 // from index
,3 // count
);

// The Address instance is very detailed and provides so many fields - so showing only address in Trytes for better clarity
Console.WriteLine(JsonConvert.SerializeObject(from i in addresses select i.ToTrytes(), Formatting.Indented));

[
"HRLKBQUZAEB9HIVWJEWVDYQ9G9VRQXQAXR9ZWGBFQJKRPOPJYHGAT9LBEIE9RWRMUFSNLCWYHQGYAECHD",
]

As mentioned earlier, IOTA address consists of 81 trytes ([A..Z9] characters) or 90 trytes including checksum. Checksum is useful when you want to make sure a valid address was given (no typos, etc.) and so it is a good practise to encourage user of your app using IOTA addresses including checksums = 90 trytes.

IOTA libraries are able to help you to deal with some basic patterns such as validating addresses, generating checksums, etc.

#r "Tangle.Net.dll"
using Tangle.Net.Entity;

// There is a function Withchecksum() but it did not work when tested


Original input excl. checksum address:
CYJV9DRIE9NCQJYLOYOJOGKQGOOELTWXVWUYGQSWCNODHJAHACADUAAHQ9ODUICCESOIVZABA9LTMM9RW
Length: 81
Input address including checksum:
CYJV9DRIE9NCQJYLOYOJOGKQGOOELTWXVWUYGQSWCNODHJAHACADUAAHQ9ODUICCESOIVZABA9LTMM9RWTHBIRSXTA
Length incl checksum: 90

You should always make sure your app is dealing with valid IOTA address. Please note, you should also make sure an address is of correct length and consists only of allowed characters. IOTA libraries may slightly differ in their approaches but differences are very subtle and both libraries provide enough functions to validate IOTA address.

General steps should be:

• Checks length
• Checks valid characters
• Checks address against its checksum

#r "Tangle.Net.dll"
using Tangle.Net.Entity;
using Tangle.Net.Utils;

{
Console.WriteLine("Not valid input address incl. checksum was given.");
} else {

}

Input address incl checksum:
CYJV9DRIE9NCQJYLOYOJOGKQGOOELTWXVWUYGQSWCNODHJAHACADUAAHQ9ODUICCESOIVZABA9LTMM9RWTHBIRSXTA
Is it valid addr based on checksum? True
Input address excl checksum:
CYJV9DRIE9NCQJYLOYOJOGKQGOOELTWXVWUYGQSWCNODHJAHACADUAAHQ9ODUICCESOIVZABA9LTMM9RW

# IOTA 101: Transactions

A transaction is a smallest piece of data that can be broadcasted to the network. Each transaction consists of fixed 2673 trytes. Transactions (TXs) are basically of two types:

• Value TXs: those transactions change ownership of IOTA tokens. Two possible states: spending TXs or receiving TXs
• Non-Value TXs: those transactions include piece of data that can be broadcasted and read from the Tangle

Transactions are broadcasted in an envelope called Bundle. Bundle may consist of multiple TXs. Bundle is processed by the Tangle as a single entity; meaning only the whole bundle is confirmed by the network (and all TXs within) or nothing. You have to prepare a bundle even if you broadcast single transaction only. Bundle is also described as atomic since every bundle includes all information needed to process it antonomously.

Each transaction includes several fields, let's name the most important ones:

• Value: Value can be positive number = receiving IOTA tokens, negative number = spending IOTA tokens or zero = broadcasting only piece of data
• Address: It is IOTA address that is associated with the given transaction. Value indicates whether it is an address of a receiver or a sender
• Tag: It is an user-defined tag that can be used for searching, etc.
• SignatureMessageFragment: This is the most lenghty attribute (2187 trytes) and could include: transaction signature based on private key in case it is a spending TX or piece of data (message) in case it is non-value TX. Alternatively it can be also left blank (in case of non-value TXs)
• TrunkTransaction / branchTransaction: Those two fields refer to some previous transactions in the Tangle (tips) that the given bundle is going to approve
• Timestamp: TX timestamp. It is actually UNIX timestamp (UTC)

A process of sending IOTA transaction can be summarized in 5 steps:

• To create transation(s) with the given attributes: value, address and potentially also tag or message
• To finalize a bundle that includes all transactions. Once the bundle is finalized no new transactions can be added. It basically means to generate a bundle hash
• To search for two tips in the Tangle that you are going to validate. There is not a strict rule how to search them but it is generally recommended to leave it on a tip selection algorithm implemented on node's side
• To do a Proof-of-Work for each transaction in the bundle. Result of POW is Nonce and Transaction hash stored with each transaction
• Finally you need to broadcast the whole bundle to the network

### A secret of a bundle

There is a secret to be shared. You have to understand one important thing. Bundle is a top level construct that link all related transactions under one entity however the bundle itself is not broadcasted in fact. You still broadcast "only" collection of individual transactions instead. All transactions are recognized to be part of a bundle by the IOTA protocol however any data peering is based on individual transactions (in trytes).

In other words, a bundle can be reconstructed anytime from a collection of transactions via fields bundle hash, current index and last index.

## Non-value transactions

Let's start with non-value transactions (meta transactions) first since they are a bit easier for starters.

Please note, the chapter is divided in two separate sections. In the first section, examples are really close to bare metal (still not too close:) to illustrate the whole process and describing implementation details wherever possible. It is also useful when you want to experiment with different settings at each step (hey "non-existing tips", looking at you).

In the second section, IOTA-facing libraries are fully levearged since they are capable to hide all implementation details behind a curtain. Needless to say, if you are not interested in such details then you would probably like to start with the second section.

### Creating and broadcasting transaction in 5 steps (you want to understand the process)

#### Create a transaction

First of all let's create transactions (offline; in memory) and set main fields.

BTW: Timestamp field is defined automatically by the IOTA-facing libraries in the process. It is important field while creating bundle hash.

In the examples within this chapter we are going to broadcast meta transactions (data only) to two different IOTA addresses.

#r "Tangle.Net.dll"
#r "Newtonsoft.Json.dll"
using Tangle.Net.Entity;
using Newtonsoft.Json;

var MySeed = "HGW9HB9LJPYUGVHNGCPLFKKPNZAIIFHZBDHKSGMQKFMANUBASSMSV9TAJSSMPRZZU9SFZULXKJ9YLAIUA";

var NowIs = DateTime.Now.ToShortDateString(); //this is not important - just to have some meaningful message

var pt = new Transfer() // creating a first transfer (a proposed transaction)
{
ValueToTransfer=0,
Message=TryteString.FromUtf8String("Here comes a first message. Now is " + NowIs),
Tag=new Tag("HRIBEK999IOTA999TUTORIAL"),
Timestamp = Timestamp.UnixSecondsTimestamp // please note, Tangle.Net library does not enter timestamp for you
};

var pt2 = new Transfer() // creating a second transfer (a proposed transaction)
{
ValueToTransfer = 0,
Message = TryteString.FromUtf8String("Here comes a second message. Now is " + NowIs),
Tag = new Tag("HRIBEK999IOTA999TUTORIAL"),
Timestamp = Timestamp.UnixSecondsTimestamp // please note, Tangle.Net library does not enter timestamp for you
};

Console.WriteLine("Created transaction objects - mandatory fields only:");
Console.WriteLine(JsonConvert.SerializeObject(pt, Formatting.Indented));
Console.WriteLine(JsonConvert.SerializeObject(pt2, Formatting.Indented));

Created transaction objects - mandatory fields only:
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
},
"Message": {
"TrytesLength": 88,
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 0,
"ValueToTransfer": 0
}
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
},
"Message": {
"TrytesLength": 90,
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 0,
"ValueToTransfer": 0
}

#### Finalizing bundle

Once all individual transactions are created it is time to prepare and finalize the bundle. While preparing the bundle you need at least to specify list of prepared transaction(s). In case of non-value transactions it is quite straightforward process. However, it is a bit more complicated in case of value transactions - please see later.

Finalizing the bundle consists of several tasks under the hood:

• Each transaction is indexed. Attributes current_index / last_index are set
• Bundle hash is generated (Sponge function + normalization) and assigned to each transaction
• signatureMessageFragment is bascially copy of message field in case of non-value transactions
• PyOTA library also checks whether the data in message field is larger than transaction allows (2187 trytes). If this is the case then it takes care of it and split your data into several transactions

Please note, finalizing the bundle also means you are no longer able to add new transactions to the bundle post the finalization process.

Simply put, bundle hash is a cryptographic "fingerprint" of all transactions in the bundle. It uniquely represents them and so as long as transactions are the same (incl their particular order) the bundle hash is also the same.

$$BundleHash = fce(address, value, legacy tag, timestamp, current index, last index)$$

You may be wondering what is a difference between tag and legacy_tag. Tag includes actualy the tag that was defined during the transaction creation. Legacy_tag is also based on it however it is modified during the normalization process while bundle hashing to be sure that bundle hash is can be securely used while TX signing. That's why the bundle hash is sometimes refered as normalized bundle hash.

The bundle refers to the first transaction in collection as tail_transaction. You can perceive tail transaction as an official representative of the whole bundle while checking for confirmation status, etc. Remember, the bundle is an atomic entity and so whatever is done to bundle it applies to ALL transactions within.

//preparing bundle that consists of both transactions prepared in the previous example
var bundle = new Bundle();

//generate a bundle hash using sponge/absorb function + normalize bundle hash + copy bundle hash into each transaction / bundle
bundle.Finalize();
bundle.Sign();

Console.WriteLine("Generated bundle hash: " + bundle.Hash.ToString());
Console.WriteLine("Tail Transaction in the Bundle is a transaction #" + bundle.TailTransaction.CurrentIndex + ".");

Console.WriteLine("List of all transactions in the bundle:");
Console.WriteLine(JsonConvert.SerializeObject(bundle.Transactions, Formatting.Indented));

Generated bundle hash: HMCU9CJIIGJLNCJJSYACUYZNFPDREPKLADUU9EHBEZNQUAHWGXJ9BZZHZPBLWXCXBHSLSKSLZZYFLVHZB
Tail Transaction in the Bundle is a transaction #0.
List of all transactions in the bundle:
[
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
},
"AttachmentTimestamp": 999999999,
"AttachmentTimestampLowerBound": 999999999,
"AttachmentTimestampUpperBound": 999999999,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "999999999999999999999999999999999999999999999999999999999999999999999999999999999"
},
"BundleHash": {
"TrytesLength": 81,
},
"CurrentIndex": 0,
"Fragment": {
"IsEmpty": false,
"TrytesLength": 2187,
},
"Hash": null,
"IsTail": true,
"LastIndex": 1,
"Nonce": {
"TrytesLength": 27,
"Value": "999999999999999999999999999"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "LWIBEK999IOTA999TUTORIAL999"
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 0,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "999999999999999999999999999999999999999999999999999999999999999999999999999999999"
},
"Value": 0
},
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
},
"AttachmentTimestamp": 999999999,
"AttachmentTimestampLowerBound": 999999999,
"AttachmentTimestampUpperBound": 999999999,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "999999999999999999999999999999999999999999999999999999999999999999999999999999999"
},
"BundleHash": {
"TrytesLength": 81,
},
"CurrentIndex": 1,
"Fragment": {
"IsEmpty": false,
"TrytesLength": 2187,
},
"Hash": null,
"IsTail": false,
"LastIndex": 1,
"Nonce": {
"TrytesLength": 27,
"Value": "999999999999999999999999999"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 0,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "999999999999999999999999999999999999999999999999999999999999999999999999999999999"
},
"Value": 0
}
]

At this stage you can also see how does our finalized bundle look encoded in Trytes so far. It is also a proof that there is no bundle to be broadcasted itself, only list of transations matter.

Console.WriteLine(JsonConvert.SerializeObject(bundle.ToTrytes(), Formatting.Indented)); //bundle as trytes - there is no bundle just transactions

[
{
"TrytesLength": 2673,
},
{
"TrytesLength": 2673,
}
]

#### Selecting two tips

As mentioned earlier you need to find two tips that you are going to validate together with your bundle for a sake of network participation. This will be outsourced to an IOTA node and so it will be for the first time we interact with the network (via API call get_transactions_to_approve).

There is a depth parameter needed. It instructs a node how many milestones it should go in the past while confirming tips. The higher value the better to network however more resources needed. Depth=3 is considered to be well-balanced compromise. Higher value than depth=10 will probably throw an exception depending on node's configuration.

It should return two selected tips as branch and trunk transactions. Those transactions will be used while broadcasting the bundle.

#r "RestSharp.dll"
using RestSharp;
using Tangle.Net.Repository;

var NodeURL = "https://nodes.thetangle.org:443";
var repo = new RestIotaRepository(new RestClient(NodeURL)); // ctor initialization of the Tangle.Net library

var gta = repo.GetTransactionsToApprove(3);
Console.WriteLine(JsonConvert.SerializeObject(gta, Formatting.Indented));

{
"BranchTransaction": {
"TrytesLength": 81,
"Value": "KAIQDBQEOHPOQELQZXIMICACCRPHGAZCZAUAUKZVSRZLKUD9BBKKAMNNBGUTQTKLVMLGGO9ZZLWKA9999"
},
"Duration": 190,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "AZYDOXZLYNILMCSCWBXRPNNXWFZGTHOVSEQBYMKEXBZZRKWTPHSWPZCERVSPHUXPXAEGEILXITVA99999"
}
}

#### Performin' POW

Proof of work is a relatively simple cryptograhic puzzle to be solved. It represents energy-based costs of your transaction. It also helps to minimize risks of some attack vectors to the network.

This task can be also outsourced to IOTA nodes. In order to perform it you need selected tips, finalized bundle (in trytes) and also Minimum Weight Magnitude parameter. This parameter defines how diffciult the given cryptographic puzzle should be to be accepted by the network. As of now, you should set at least min_weight_magnitude=14 in case of mainnet.

Please note, POW is performed per each transaction and so it can take some time. That's why it is not recommended to have more than 30 transactions in a bundle.

Once succesfully performed, the modified bundle (list of all transactions in trytes) is returned in order to be broadcasted.

Specifically:

• Fields nonce and transaction hash are calculated per each transaction
• Trunk and Branch tips are correctly mapped among transactions within the bundle. Check that trunk of the first TX refers to the second TX, etc.

Console.WriteLine("Performing POW... Wait please...");
var att = repo.AttachToTangle(branchTransaction: gta.BranchTransaction, //first tip selected
trunkTransaction: gta.TrunkTransaction, //second tip selected
transactions: bundle.Transactions, //our finalized transactions
minWeightMagnitude: 14); // MWMN

Console.WriteLine(JsonConvert.SerializeObject(att, Formatting.Indented));

Performing POW... Wait please...
[
{
"TrytesLength": 2673,
},
{
"TrytesLength": 2673,
}
]

You can eventually also preview what specific fields have been modified using transaction objects. The bundle is ready to be broadcasted and so it also show you all fields/values that will be stored in the network.

// show what has been broadcasted - hash transaction + nonce (POW)

Console.WriteLine("Final bundle including POW and branch/trunk transactions:");

foreach (var tr in att)
{
Console.WriteLine(JsonConvert.SerializeObject(Transaction.FromTrytes(tr), Formatting.Indented));
}

Final bundle including POW and branch/trunk transactions:
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
},
"AttachmentTimestamp": 1568818706823,
"AttachmentTimestampLowerBound": 0,
"AttachmentTimestampUpperBound": 3812798742493,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "KAIQDBQEOHPOQELQZXIMICACCRPHGAZCZAUAUKZVSRZLKUD9BBKKAMNNBGUTQTKLVMLGGO9ZZLWKA9999"
},
"BundleHash": {
"TrytesLength": 81,
},
"CurrentIndex": 1,
"Fragment": {
"IsEmpty": false,
"TrytesLength": 2187,
},
"Hash": {
"TrytesLength": 81,
"Value": "OYHIDWXOYTIDSLXUYVPTYJSYSUYGME9OWRFNKISZGENKAJWCAQTDRJXFCJKXBBNHROIGZBNYRXSY99999"
},
"IsTail": false,
"LastIndex": 1,
"Nonce": {
"TrytesLength": 27,
"Value": "NYHCWZKAFTLDYXZGUXQN9CGWORG"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 0,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "AZYDOXZLYNILMCSCWBXRPNNXWFZGTHOVSEQBYMKEXBZZRKWTPHSWPZCERVSPHUXPXAEGEILXITVA99999"
},
"Value": 0
}
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
},
"AttachmentTimestamp": 1568818710254,
"AttachmentTimestampLowerBound": 0,
"AttachmentTimestampUpperBound": 3812798742493,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "AZYDOXZLYNILMCSCWBXRPNNXWFZGTHOVSEQBYMKEXBZZRKWTPHSWPZCERVSPHUXPXAEGEILXITVA99999"
},
"BundleHash": {
"TrytesLength": 81,
},
"CurrentIndex": 0,
"Fragment": {
"IsEmpty": false,
"TrytesLength": 2187,
},
"Hash": {
"TrytesLength": 81,
"Value": "RBE9XKMLBBTXFTNANSTOTW9VHWSAZJM9FBCALBQESWTOKURWQEAJUJEKQJXUOOSAIDXABSOJXMBB99999"
},
"IsTail": true,
"LastIndex": 1,
"Nonce": {
"TrytesLength": 27,
"Value": "NXO9XFRKWJIPJOGSREFDHPHRIJQ"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "LWIBEK999IOTA999TUTORIAL999"
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 0,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "OYHIDWXOYTIDSLXUYVPTYJSYSUYGME9OWRFNKISZGENKAJWCAQTDRJXFCJKXBBNHROIGZBNYRXSY99999"
},
"Value": 0
}

Now it is time to broadcast the given bundle to the network. List of all transations in trytes returned from the previous step is only thing needed.

Once succesfully broadcasted it returns the same input bundle as a confirmation.

Console.WriteLine("Broadcasting transactions...");

Broadcasting transactions...
Broadcasted.

You can check the broadcasted bundle via The Tangle Explorer at any of the receiving addresses:

### Creating and broadcasting transaction in a single call (you want send a transaction quickly)

As mentioned above, IOTA-facing libraries are able to encapsulate all implementation details and so you do not need to care of them anymore. It is usually based on extended API calls that were proposed to be included by IOTA Foundation to make developer's life easier (https://github.com/iotaledger/wiki/blob/master/api-proposal.md).

Even if using extended API calls you can still slightly control a level of your involvement in the whole process. From almost no involvement and fully automatic (send_transfer()) to semi-manual approach discussed above.

There are some specifics you should consider while designing your app:

• You are loosing a bit of control of individual steps of the process and you have to rely of some predefined parameters (tip selection algo, etc.)
• If there is an exception raised during the process then you need to go back at beginning and restart the whole process again

So it is basically your call to decide what works best for you.

Now back to our exercise. Here comes a code that basically broadcasts transactions in a single call (send_transfer()) and you do not have to care of any implemenation details that are hidden under the hood.

#r "Tangle.Net.dll"
#r "Newtonsoft.Json.dll"
#r "RestSharp.dll"

using Tangle.Net.Entity;
using Newtonsoft.Json;
using RestSharp;
using Tangle.Net.Repository;
using Tangle.Net.Utils; //this is needed because of Timestamp function

var MySeed = "HGW9HB9LJPYUGVHNGCPLFKKPNZAIIFHZBDHKSGMQKFMANUBASSMSV9TAJSSMPRZZU9SFZULXKJ9YLAIUA";

var NowIs = DateTime.Now.ToShortDateString(); //this is not important - just to have some meaningful message

var pt = new Transfer() // creating a first transfer (a proposed transaction)
{
ValueToTransfer=0,
Message=TryteString.FromUtf8String("Here comes a first message. Now is " + NowIs),
Tag=new Tag("HRIBEK999IOTA999TUTORIAL"),
Timestamp = Timestamp.UnixSecondsTimestamp // please note, Tangle.Net library does not enter timestamp for you but it is very important since it has impact on bundle hash
};

var pt2 = new Transfer() // creating a second transfer (a proposed transaction)
{
ValueToTransfer = 0,
Message = TryteString.FromUtf8String("Here comes a second message. Now is " + NowIs),
Tag = new Tag("HRIBEK999IOTA999TUTORIAL"),
Timestamp = Timestamp.UnixSecondsTimestamp // please note, Tangle.Net library does not enter timestamp for you but it is very important since it has impact on bundle hash
};

var bundle = new Bundle();

var NodeURL = "https://nodes.thetangle.org:443";
var repo = new RestIotaRepository(new RestClient(NodeURL)); // ctor initialization of the Tangle.Net library

// the whole process initiated in a single call
var sentBundle = repo.SendTransfer(seed: new Seed(MySeed),
bundle: bundle,
securityLevel: 2,
depth: 3,
minWeightMagnitude: 14); //it returns a bundle object

Console.WriteLine("Generated bundle hash: " + sentBundle.Hash.ToString());
Console.WriteLine("Tail Transaction in the Bundle is a transaction #" + sentBundle.TailTransaction.CurrentIndex + ".");

Console.WriteLine("List of all transactions in the bundle:");
foreach (var tx in sentBundle.Transactions)
{
Console.WriteLine(JsonConvert.SerializeObject(tx, Formatting.Indented));
}

Preparing/Broadcasting... Wait please...
Generated bundle hash: MJZPGDLCDKOIWFTNKJJZUC9STN9RGXWC9EBRWKBGOCLIGRZCJQEUYUARGPDCFUJXIHI9UKDDVXKBZVFD9
Tail Transaction in the Bundle is a transaction #0.
List of all transactions in the bundle:
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
},
"AttachmentTimestamp": 1568832066884,
"AttachmentTimestampLowerBound": 0,
"AttachmentTimestampUpperBound": 3812798742493,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "WYLFSDUXVFRYYPDH9GOCHKLASCXTPAFUMAC9JKMPAXZIOZVGCJ9LARVDFFJPCTAXLBIYSSZEYKNHA9999"
},
"BundleHash": {
"TrytesLength": 81,
"Value": "MJZPGDLCDKOIWFTNKJJZUC9STN9RGXWC9EBRWKBGOCLIGRZCJQEUYUARGPDCFUJXIHI9UKDDVXKBZVFD9"
},
"CurrentIndex": 0,
"Fragment": {
"IsEmpty": false,
"TrytesLength": 2187,
},
"Hash": {
"TrytesLength": 81,
"Value": "PUM9YUXZWH9TZQKEUKIBIBVAIPWXNGIUEKBQHLM9PRHGGOJPTASEKHMXHHMK9EBXZSJOPXYQUIHRZ9999"
},
"IsTail": true,
"LastIndex": 1,
"Nonce": {
"TrytesLength": 27,
"Value": "BSVCUUWALVPHMHXBINNMXAEJ9VA"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "ODIBEK999IOTA999TUTORIAL999"
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 1568832063,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "YBJB9C9T9CFSKTLMHKOMHDRNT9MZTPNZIHTJ9DMNDJSYECMGLAGIIY9RH9PNSTPJXMHUIUCPVLLYZ9999"
},
"Value": 0
}
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
},
"AttachmentTimestamp": 1568832066523,
"AttachmentTimestampLowerBound": 0,
"AttachmentTimestampUpperBound": 3812798742493,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "WYLFSDUXVFRYYPDH9GOCHKLASCXTPAFUMAC9JKMPAXZIOZVGCJ9LARVDFFJPCTAXLBIYSSZEYKNHA9999"
},
"BundleHash": {
"TrytesLength": 81,
"Value": "MJZPGDLCDKOIWFTNKJJZUC9STN9RGXWC9EBRWKBGOCLIGRZCJQEUYUARGPDCFUJXIHI9UKDDVXKBZVFD9"
},
"CurrentIndex": 1,
"Fragment": {
"IsEmpty": false,
"TrytesLength": 2187,
},
"Hash": {
"TrytesLength": 81,
"Value": "YBJB9C9T9CFSKTLMHKOMHDRNT9MZTPNZIHTJ9DMNDJSYECMGLAGIIY9RH9PNSTPJXMHUIUCPVLLYZ9999"
},
"IsTail": false,
"LastIndex": 1,
"Nonce": {
"TrytesLength": 27,
"Value": "GFSZAC9PCWNJNNWDLG9WZKTAVJX"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 1568832063,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "WYLFSDUXVFRYYPDH9GOCHKLASCXTPAFUMAC9JKMPAXZIOZVGCJ9LARVDFFJPCTAXLBIYSSZEYKNHA9999"
},
"Value": 0
}

You can check the broadcasted bundle via The Tangle Explorer at any of the receiving addresses:

And to complete the picture here is addtional code that uses prepare_transfer() and send_trytes() combo.

#r "Tangle.Net.dll"
#r "Newtonsoft.Json.dll"
#r "RestSharp.dll"

using Tangle.Net.Entity;
using Newtonsoft.Json;
using RestSharp;
using Tangle.Net.Repository;
using Tangle.Net.Utils;

var MySeed = "HGW9HB9LJPYUGVHNGCPLFKKPNZAIIFHZBDHKSGMQKFMANUBASSMSV9TAJSSMPRZZU9SFZULXKJ9YLAIUA";

var NowIs = DateTime.Now.ToShortDateString(); //this is not important - just to have some meaningful message

var pt = new Transfer() // creating a first transfer (a proposed transaction)
{
ValueToTransfer=0,
Message=TryteString.FromUtf8String("Here comes a first message. Now is " + NowIs),
Tag=new Tag("HRIBEK999IOTA999TUTORIAL"),
Timestamp = Timestamp.UnixSecondsTimestamp // please note, Tangle.Net library does not enter timestamp for you but it is very important since it has impact on bundle hash
};

var pt2 = new Transfer() // creating a second transfer (a proposed transaction)
{
ValueToTransfer = 0,
Message = TryteString.FromUtf8String("Here comes a second message. Now is " + NowIs),
Tag = new Tag("HRIBEK999IOTA999TUTORIAL"),
Timestamp = Timestamp.UnixSecondsTimestamp // please note, Tangle.Net library does not enter timestamp for you but it is very important since it has impact on bundle hash
};

var bundle = new Bundle();

var NodeURL = "https://nodes.thetangle.org:443";
var repo = new RestIotaRepository(new RestClient(NodeURL)); // ctor initialization of the Tangle.Net library

Console.WriteLine("Almost prepared bundle - tips and POW are still missing");

var preparedBundle = repo.PrepareTransfer(seed: new Seed(MySeed),
bundle: bundle,
securityLevel: 2); // please note, depth and MNWM are not needed since neither GTTA nor ATT is performed
foreach (var tx in preparedBundle.ToTrytes())
{
Console.WriteLine(tx.ToString());
}

Console.WriteLine("Searching for tips and performing POW... Wait please...");
var sentBundle = repo.SendTrytes(transactions: preparedBundle.Transactions,
depth: 3,
minWeightMagnitude: 14);

Console.WriteLine("Final transactions were returned - including nonce(POW)");
foreach (var tx in sentBundle)
{
Console.WriteLine(tx.ToString());
}

Almost prepared bundle - tips and POW are still missing
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
Searching for tips and performing POW... Wait please...
Bundle was broadcasted.
Final transactions were returned - including nonce(POW)
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
RBTCFDTCEARCCDADTCGDEAPCEAUCXCFDGDHDEAADTCGDGDPCVCTCSAEAXBCDKDEAXCGDEACBTAVABBTAWAUAVACB99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999CXDUYK9XGHC9DTSPDMKGGGXAIARSRVAFGHJOCDDHWADLVBBOEHLICHTMGKVDOGRU9TBESJNHAXYPVJ9R9999999999999999999999999999Z9IBEK999IOTA999TUTORIAL9999KAAIAD99999999999A99999999MJCVGAPSTFRW99JCEBCWHGFXWCZCLTVPWJD9QKYEZX9UIZSIJXTHDBAQFJ9ANVAUOEDY9GIAHBCECJYGXEWFEQDYZHSSPGBLOC9XVFBVTIAKLRNNUGHATPCQRQVAXYQHXXIJDZLBXLASF9ZI9SIDUDNJTJ9PWZ9999JVEXQTEBULMLJQJCBASUKVGWTANPOOXNQJDWEGMZQKCHCFPXTGRYPWFFETSDYWUIQMNQUSCIQCTFZ9999HRIBEK999IOTA999TUTORIAL999R9MZULZOF999999999MMMMMMMMMBWSRMLGBWQCDYRPQIXVNLYQYUZR

You can check the broadcasted bundle via The Tangle Explorer at any of the receiving addresses:

## Value transactions

Meta transactions were discussed in the previous chapter. This chapter describes value transactions which are transactions that transfer IOTA tokens between IOTA addresses. Tokens are fully premined and so number of tokens in the network is given. So transfering tokens means changing their ownership only.

While preparing a bundle with value transations it is important to distinguish three different transaction types within a bundle:

• Input TXs: those are transactions that deducting (spending) value from address(es). Those transactions have negative value field. They usually refer to senders
• Output TXs: those are transactions that adding (receiving) value to address(es). Those transactions have positive value field. They usually refer to recipients
• Unspent/change TX: technically speaking it is also output transaction that adding value however it usually refers to senders and so it is better to consider it separated from other output TXs

All three types have to be part of each bundle otherwise you are under a risk of loosing IOTA tokens. In other words, each bundle should consists of at least one input TX, one output TX and one unspent TX. Total balance of the bundle should be zero since the number of tokens is the same, just token owners have been "changed".

Example:

• Alice owns 100 tokens (input = 100)
• Alice is going to send 20 tokens to John from the address that includes 100 tokens of her (Alice -100)
• John is going to receive 20 tokens from Alice (output = 20; John +20)
• Alice still owns 80 tokens after the transaction (unspent = 80; Alice +80)

Alice's bundle should look like: \begin{align} Input - Output & = \ Unspent \\ Input - Output - Unspent & = \ 0 \\ 100 - 20 - 80 & = \ 0 \end{align}

Why Alice has to "put" all 100 tokens in the bundle while she is going to actually spend only 20 tokens? The reason is that IOTA protocol uses one-time signature scheme (OTS) for transaction signing while spending tokens. And with every signing process a half of a private key of the given address is revealed. That's why no one should ever spend tokens from the same address again.

### Spending tokens

Please note: for a purpose of this chapter we are going to switch to a test network called devnet. It is the testing Tangle. Tokens are not real and everything you do have no implication to the mainnet at all. However it is stil powered by standard node software and so technicaly speaking it behaves like the mainnet. If you need more info regarding devnet please refer to the official documentation.

Everything what has been mentioned in the previous chapter focused on non-value transations is still valid also in case of value transactions however there are several additional tasks you should take care of. Needless to say, IOTA libraries (PyOTA and others) are ready to help you and are able to hide all implementation details in case you would like to. In this case I would encourage everyone to prefer a functionality that is offered by extended API calls, such as send_transfer. Experimenting with value transactions and trying to tweak them does not seem to be a good idea (on the mainnet).

Anyway, even in this chapter I am going to describe main tasks that are performed under the hood to be able to understand the whole concept.

Let's have the following setup:

// Sender's side
// Sender seed
var SeedSender = "HGW9HB9LJPYUGVHNGCPLFKKPNZAIIFHZBDHKSGMQKFMANUBASSMSV9TAJSSMPRZZU9SFZULXKJ9YLAIUA";

// Recipient's seed - this is actually not needed for the exercise - it is just to have corresponding seed somewhere written

//This is our target address to which we are going to send tokens to (BTW: it is a first generated address based on recipient's seed)

var DevnetNode = "https://nodes.devnet.iota.org:443";
Console.WriteLine("Variables were initialized.");

Variables were initialized.

You may be wondering why only the seed for sender's side is defined. As mentioned above the reason is that the address with tokens is changing with every spending exercise and so you have to find address with tokens that left in a bucket programatically (if any tokens left:).

Let's find out. For this purpose you can use extended API call get_account_data which returns a list of used addresses and total sum of all tokens available accross all of them:

#r "Tangle.Net.dll"
#r "Newtonsoft.Json.dll"
#r "RestSharp.dll"

using Tangle.Net.Entity;
using Newtonsoft.Json;
using RestSharp;
using Tangle.Net.Repository;
using Tangle.Net.Utils;

Console.WriteLine("Checking the total balance");

var repo = new RestIotaRepository(new RestClient(DevnetNode)); // ctor initialization of the Tangle.Net library

// Get the total available balance for the given seed and all related used addresses
var accountData = repo.GetAccountData(seed: new Seed(SeedSender),
includeInclusionStates: false,
securityLevel: 2,
addressStartIndex: 29, // Library will start from the address at index 0. please note I increased it to start from index 29 to save time
addressStopIndex: 0); // it will search until first unused address is found

// Tangle.Net library returns very detailed info including Private Keys and so outputing only some
Console.WriteLine("Total Balance:");
Console.WriteLine(JsonConvert.SerializeObject(accountData.Balance, Formatting.Indented));

Formatting.Indented));

if (accountData.Balance>0){
Console.WriteLine("Yes, there are some token available! Hurray");
}

Checking the total balance
Please note, this may take some time if many addresses has been used already...
Total Balance:
3828
Latest Unused Address:
"MHJIRKPUVSXBZWUXKUBNT9MRSEG9CRR9DNKIVNSCBZVGEDIDYTXIAVJLSTKQGVGDBFHRCRHBEMMZXPUFZ"
Used Addresses:
[
{
"Balance": 0,
},
{
"Balance": 0,
},
{
"Balance": 0,
},
{
"Balance": 0,
},
{
"Balance": 0,
},
{
"Balance": 2979,
},
{
"Balance": 849,
}
]
Yes, there are some token available! Hurray

Please note: API call get_account_data consider only confirmed transactions while calculating total balance. So it is better to wait until all transactions are cleared before you send additional tokens.

Are there any tokens left (value in balance field)? If yes then continue - no action is needed. If not, then you need to obtain some. It can be done visiting IOTA faucet and entering an unused address of the given seed:

// Now let's find a first unused address that can be used as a destination address for unspent/new tokens
// This step is not required in case of NodeJS/Tangle.Net library, please see result above

addressStartIndex: 29, // please note the index below starts from 29 to save some time. If you would like to start from beginning it should be 0
count: 1, // how many new unused addresses we want ?
securityLevel: 2);

Console.WriteLine("This is the first unused address that can be used for new tokens or unspent tokens:");

Please note, this may take some time if many addresses has been used already...
This is the first unused address that can be used for new tokens or unspent tokens:
SZAVDSKTHNQFWTTINRAYQKJAXTLD9CRFFWWBSEXIEXPLBBEP9FT9IVGICWIXTJCFUKJSTOUFANJGBTPQX

What have just happened behind the curtain?

• The PyOTA library started to generating addresses from the index=0 of the given seed and at the same time it also checked whether there are any transactions registered for each address
• If yes, then in case we are after balances, the balance is saved. In case we are after new unused address then the given address is skipped. First address for which there are not registered transactions is returned
• That's why it may be quite time consuming. And now you also understand all issues regarding zero balances after the snapshot

You may be also wondering how to get individual balances for each used address? This can be checked using the core API call get_balances which provides you with a balance for any address you specify. Let's query for used addresses from the previous exercise:

if (accountData.UsedAddresses.Count>0)
{
threshold: 100);

}

[
{
"Balance": 0,
},
{
"Balance": 0,
},
{
"Balance": 0,
},
{
"Balance": 0,
},
{
"Balance": 0,
},
{
"Balance": 2979,
}
]

It returns balances and you can see how the remaining tokens move to new unused address every time you spend some tokens. Needless to say, used addresses with zero balances should not be used anymore since tokens were already spent from them. So let's spend some tokens:

using Tangle.Net.Utils;
var bundleMoney = new Bundle();

{
ValueToTransfer = 10,
Tag = new Tag("HRIBEK999IOTA999TUTORIAL"),
Timestamp = Timestamp.UnixSecondsTimestamp
});

if (accountData.Balance > 0) // there are some tokens
{
var sentBundle = repo.SendTransfer(seed: new Seed(SeedSender),
bundle: bundleMoney,
securityLevel: 2,
depth: 3,
minWeightMagnitude: 9, // MWM; in case of Devnet it is 9

// you can specify null in remainderAddress or inputAddresses, however it may be quite time consuming then.
// It starts to search addresses from the index 0 and searchs until it finds some funds and/or unused address
// so it is better to specify it manually as above (using accountData for instance) if you have such info

foreach (var tx in sentBundle.Transactions)
{
Console.WriteLine(JsonConvert.SerializeObject(tx, Formatting.Indented));
}
}

Sending iotas... Please wait...
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
"Value": "BMFSMZMNBGKHAWPIZIOMJGRBXZETVSAYDSTDQCHLYTBWZMIXLNXF9XHLTMOCATFVFOMBQF9IOQGPEBPDC"
},
"AttachmentTimestamp": 1568994476124,
"AttachmentTimestampLowerBound": 0,
"AttachmentTimestampUpperBound": 3812798742493,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "ODHVT9ZVBUOOUBKCYUZMFJTZQAGECIMWJKO9ZVAHAPVTEZFOEPDPMKSCTPRAIHWPYLERCOFWAHNYKS999"
},
"BundleHash": {
"TrytesLength": 81,
"Value": "POKCELONFRIBFFQAOLKSOQAIGESODBDIXCASS99SCIW9LOHGCZNLGTNKISQISOZOPWIKEYZXDALCJCZ9W"
},
"CurrentIndex": 0,
"Fragment": {
"IsEmpty": true,
"TrytesLength": 2187,
"Value": "999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
},
"Hash": {
"TrytesLength": 81,
"Value": "TVNUVTJMDUQPJTETSUQZDSCNLQEOZVUQBSFCBESFGOVTDQAP9ILCLUXACSBFFNSRX9SGTNBOA9YPCO999"
},
"IsTail": true,
"LastIndex": 3,
"Nonce": {
"TrytesLength": 27,
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "VEIBEK999IOTA999TUTORIAL999"
},
"Tag": {
"TrytesLength": 27,
"Value": "HRIBEK999IOTA999TUTORIAL999"
},
"Timestamp": 1568994271,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "RLYSXEDFSDOHCZYLXNXZWQRRTUHWNAVUDTWDFKGTTALSVKRUGWO9XHOHXQANXRHAWFPRJWEYGCKWFI999"
},
"Value": 10
}
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
"Value": "OTJSUNSQ9DLJVLKMVVPLDUTRHZAJDISDPZQCEPWNJWUGZOSFWRRBTUJAWCKKXACMZQIUP9NVVFYWRISWA"
},
"AttachmentTimestamp": 1568994476100,
"AttachmentTimestampLowerBound": 0,
"AttachmentTimestampUpperBound": 3812798742493,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "ODHVT9ZVBUOOUBKCYUZMFJTZQAGECIMWJKO9ZVAHAPVTEZFOEPDPMKSCTPRAIHWPYLERCOFWAHNYKS999"
},
"BundleHash": {
"TrytesLength": 81,
"Value": "POKCELONFRIBFFQAOLKSOQAIGESODBDIXCASS99SCIW9LOHGCZNLGTNKISQISOZOPWIKEYZXDALCJCZ9W"
},
"CurrentIndex": 1,
"Fragment": {
"IsEmpty": false,
"TrytesLength": 2187,
"Value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
},
"Hash": {
"TrytesLength": 81,
"Value": "RLYSXEDFSDOHCZYLXNXZWQRRTUHWNAVUDTWDFKGTTALSVKRUGWO9XHOHXQANXRHAWFPRJWEYGCKWFI999"
},
"IsTail": false,
"LastIndex": 3,
"Nonce": {
"TrytesLength": 27,
"Value": "9MGJNMEMMYIEIUXMAFQTAAPOCSN"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "999999999999999999999999999"
},
"Tag": {
"TrytesLength": 27,
"Value": "999999999999999999999999999"
},
"Timestamp": 1568994378,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "QHWMHCGTVIIJOWONJMOHQIMG9XZPPWGQHJFGDAPRSPVZBDI9SBAQNEHWJTHBSWQZUHUUDKKKKHOIUL999"
},
"Value": -859
}
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
"Value": "OTJSUNSQ9DLJVLKMVVPLDUTRHZAJDISDPZQCEPWNJWUGZOSFWRRBTUJAWCKKXACMZQIUP9NVVFYWRISWA"
},
"AttachmentTimestamp": 1568994476061,
"AttachmentTimestampLowerBound": 0,
"AttachmentTimestampUpperBound": 3812798742493,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "ODHVT9ZVBUOOUBKCYUZMFJTZQAGECIMWJKO9ZVAHAPVTEZFOEPDPMKSCTPRAIHWPYLERCOFWAHNYKS999"
},
"BundleHash": {
"TrytesLength": 81,
"Value": "POKCELONFRIBFFQAOLKSOQAIGESODBDIXCASS99SCIW9LOHGCZNLGTNKISQISOZOPWIKEYZXDALCJCZ9W"
},
"CurrentIndex": 2,
"Fragment": {
"IsEmpty": false,
"TrytesLength": 2187,
},
"Hash": {
"TrytesLength": 81,
"Value": "QHWMHCGTVIIJOWONJMOHQIMG9XZPPWGQHJFGDAPRSPVZBDI9SBAQNEHWJTHBSWQZUHUUDKKKKHOIUL999"
},
"IsTail": false,
"LastIndex": 3,
"Nonce": {
"TrytesLength": 27,
"Value": "AGSRO9XBGFMRZCJYRKWXTTEUGFW"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "999999999999999999999999999"
},
"Tag": {
"TrytesLength": 27,
"Value": "999999999999999999999999999"
},
"Timestamp": 1568994378,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "MRSAOMMNAAQGWHIKN9YBFENJMFMCSXJRWKDGZIWXBRRGIS9HJZGPSXZTD9MCIZORKBCORDUSKUFKBF999"
},
"Value": 0
}
{
"Balance": 0,
"Checksum": null,
"KeyIndex": 0,
"PrivateKey": null,
"SecurityLevel": 0,
"SpentFrom": false,
"TrytesLength": 81,
"Value": "SZAVDSKTHNQFWTTINRAYQKJAXTLD9CRFFWWBSEXIEXPLBBEP9FT9IVGICWIXTJCFUKJSTOUFANJGBTPQX"
},
"AttachmentTimestamp": 1568994476035,
"AttachmentTimestampLowerBound": 0,
"AttachmentTimestampUpperBound": 3812798742493,
"BranchTransaction": {
"TrytesLength": 81,
"Value": "ODHVT9ZVBUOOUBKCYUZMFJTZQAGECIMWJKO9ZVAHAPVTEZFOEPDPMKSCTPRAIHWPYLERCOFWAHNYKS999"
},
"BundleHash": {
"TrytesLength": 81,
"Value": "POKCELONFRIBFFQAOLKSOQAIGESODBDIXCASS99SCIW9LOHGCZNLGTNKISQISOZOPWIKEYZXDALCJCZ9W"
},
"CurrentIndex": 3,
"Fragment": {
"IsEmpty": true,
"TrytesLength": 2187,
"Value": "999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
},
"Hash": {
"TrytesLength": 81,
"Value": "MRSAOMMNAAQGWHIKN9YBFENJMFMCSXJRWKDGZIWXBRRGIS9HJZGPSXZTD9MCIZORKBCORDUSKUFKBF999"
},
"IsTail": false,
"LastIndex": 3,
"Nonce": {
"TrytesLength": 27,
"Value": "GLKUMZVXVLHZXXFALUYZJHZJJZI"
},
"ObsoleteTag": {
"TrytesLength": 27,
"Value": "999999999999999999999999999"
},
"Tag": {
"TrytesLength": 27,
"Value": "999999999999999999999999999"
},
"Timestamp": 1568994471,
"TrunkTransaction": {
"TrytesLength": 81,
"Value": "ODHVT9ZVBUOOUBKCYUZMFJTZQAGECIMWJKO9ZVAHAPVTEZFOEPDPMKSCTPRAIHWPYLERCOFWAHNYKS999"
},
"Value": 849
}

Let's review all transactions that has been prepared and sent eventually:

• The first transaction current_index=0 is the output TX that basically adds tokens to some address
• Transactions current_index=1 and current_index=2 are two parts of the same transaction - Input TX. This transaction deducts tokens from the address(es). You can see negative value in the transaction current_index=1
• Why there are two parts? Since the transaction spends tokens it has to be signed in order to validate the ownership. Signature is generated from the private key and the signature can be observed in the field signature_message_fragment. Here is the thing. Do you remember when different security levels were discussed? There are three security levels available and the given level has the direct impact on length of the signature. Since signature_message_fragment is of the fixed size, if SL>1 then the transaction has to be split to be able to accommodate full signature.
• The last transaction current_index=3 moves unspent tokens to the first unused address of the given seed.

The following tasks have to be done behind the curtain in addition to the standard transaction preparation process:

• Search for address(es) with some balance until total amount of tokens available is large enough to be spent. You can use more input addresses if needed
• If there would be some unspent amount of tokens then also search for the first unused address
• Spending transactions (Input TX) has to be properly signed and split in case of SL>1
• There is also some quick check performed whether resulting number of tokens is zero (no more tokens, no less tokens. Number of tokens has to be balanced).

So basically all steps we tried in the chapter had to be done also behind the curtain while using send_transfer extended API call. You can also see that some of those operations may be quite expensive in terms of time while being completely stateless. In real world applications it would be better to save some states (index of last address, used addresses, etc.) to avoid too many expensive operations.

You can review the given broadcasted transactions also in the tangle explorer (for devnet):