The IOTA protocol is getting some groundbreaking updates in the coming months. Some features will be removed or added in the future. IOTA 1.0 is the current state, IOTA 1.5 (Chrysalis) will be implemented in Q1 2021 and the coordinator shutdown is planned with IOTA 2.0 (Coordicide) towards the end of Q2 2021. Accordingly, I will mark subsequent statements.
- Account Model (IOTA 1.0): An address is like an account (credit model) that belongs to a seed and has a balance of 0 or more IOTA tokens. Addresses are the public part of a public / private key pair. To transfer IOTA tokens from one address to another, you sign a transaction using the private key to prove to the nodes that you are the owner. As such, you can share addresses with anyone since only the owner of the seed knows the private key.
- Address Checksum: Checksum validation is a way to determine if an address is valid and does not contain typos.
- Autopeering (IOTA 1.5): A mechanism that allows nodes to automatically select their neighbors without manual intervention by the node operator.
- API interface: To send data transactions (value 0) and query the tangle.
- Atomic Transactions (IOTA 1.5): Instead of the bundle construct, IOTA 1.5 uses simpler Atomic Transactions. This reduces network overhead and signature verification load, improves spam protection and rate control, and shortens the length of Merkle proofs (for future sharding). It also reduces implementation overhead and increases maintainability of the core node software.
- Application Layer (IOTA 2.0): The top layer of the 3-layer communication protocol that hosts all internal and external applications.
- Balance: Funds on the addresses (account). These are always available and cannot be deleted or forgotten.
- Blockchain Bottleneck: The more transactions are issued, the more the block rate and size becomes a bottleneck in the system. It is no longer possible to capture all incoming transactions in a prompt manner. Attempts to speed up block rates result in more orphaned blocks (blocks are left behind) and reduce the security of the blockchain.
- Branch / Trunk: Two transactions referenced and validated by another transaction. As of IOTA 2.0 (Coordicide), these are renamed Parents.
- Bundle (IOTA 1.0 only): A transaction is a single instruction to send output transactions or receive input transactions. To transmit transactions, you need both input and output transactions combined in a package (bundle). Either all transactions in the bundle are accepted or none at all.
- Bee (IOTA 2.0): Production-ready implementation of the core client without coordinator in the Rust programming language. All previous developments and ideas from IRI, Ict, Hornet and Go Shimmer are merged into a unified platform.
- Bootstrapping attack: An attack in which a node downloads malicious snapshot files, including invalid transactions and balances.
- Blowball attack: A subtangle in which a large group of tip transactions points to a central transaction, which is often a milestone.
- Curl: This is the main hash function currently in use. It is based on the “sponge” construction of the Keccak inventors (SHA-3).
- Confirmed: Confirmed transactions. In IOTA 1.0 & 1.5, transactions are still confirmed by the coordinator (milestones).
- CTPS: Confirmed transaction per second.
- Cumulative Weight: A system for valuing transactions. Each additional transaction that references a transaction increases its cumulative weight. When tips are selected, a path through transactions that has a higher cumulative weight is preferred.
- Comnet: The Comnet is a test-only network and is similar to the Devnet except that it is maintained by the IOTA community. The Hornet nodes (no longer IRI nodes) in the Comnet continue to use a coordinator operated by the IOTA community.
- Chronicle: Official permanode solution of the IOTA Foundation. It allows to store all transactions reaching a node in a distributed database that is secure and scales well. Chronicle is used to store the Tangle’s unlimited data flow and make it queryable. In other words, permanence allows the entire history of the Tangle to be stored indefinitely and makes that data easily accessible.
- Consensus: Agreement on a specific date or value in distributed multi-agent systems, in the presence of faulty processes.
- Coordinator (only up to IOTA 2.0): A trusted entity, as protection against malicious transactions. The Tangle is not yet a final product, it is still in beta. The network currently relies on a kind of shield, the so-called coordinator called “Compass”. It is open-source and runs on a Hornet node. The COO acts as a centralized, voluntary and temporary alternative consensus mechanism for the Tangle. To do this, the COO sends honest transactions to the full nodes at regular intervals. These packets contain a signed transaction with no value, called a milestone. The fullnodes in the Tangle consider a transaction as confirmed only if it is approved by a milestone. Important: The coordinator can only confirm transactions, but he cannot bypass the consensus rules. To create, freeze or steal tokens is not possible for him. This fixed rule and the COO address is hardcoded on each full node, so the coordinator’s influence on the tangle is very limited, since the tangle is also constantly monitored by all the other fullnodes. > The Coo will be switched off with the IOTA 2.0 upgrade.
- Communication Layer (IOTA 2.0): The Communication Layer (Message Tangle) creates a standardized platform for storing and communicating information. This layer contains the distributed ledger or tangle, as well as the rate control and time stamp.
- Core Object type (IOTA 2.0): An object type that must be parsed by all nodes. Parsers are computer programs responsible for decomposing and converting an input into a format more suitable for further processing.
- Core Application (IOTA 2.0): Core application that must be executed by all nodes, for example the value transfer application.
- Child (IOTA 2.0): A transaction that directly references two others in the Tangle, referred to as parents.
- Data: The tangle is a way of proving the integrity of data (verifiability of completeness and origin) in a trustworthy manner. At present, there are several cryptographic methods that make this possible, but security gaps are repeatedly discovered here, making data vulnerable to manipulation. This is a major problem, especially in cloud computing, where third-party audit tools are sometimes even used (for a fee) to ensure this data integrity. This is exactly where IOTA comes in and offers a relatively easy way to escape this with its protocol and without fees.
- Data storage: Just like the internet, the IOTA protocol does not store data or in other words, the Tangle is not a data storage. If someone wants to store the history of transactions in a decentralized way, they can build a second-layer solution for this themselves or pay third parties for this storage. For the basic layer, IOTA focuses on performance, throughput, and security rather than building a global database.
- Distributed Ledger Technology (DLT): This is a database architecture that allows owners of digital assets to transfer and document them from peer to peer. Each transfer in a DLT is stored as a record in a distributed ledger (database). This database is stored in all nodes of a network.
- Devnet: The Devnet (engl. developer network) is a pure test network. It is similar to the Mainnet except that the tokens are free and it takes less time and computing power to create and send a transaction.
- Decay: Both Mana and Pending Mana decay proportionally to its value, preventing Mana from growing indefinitely over time.
- Double-spending: Double-spending is a potential flaw in a digital money system where the same single digital token can be spent more than once. Unlike physical money, a digital token consists of a digital file that can be duplicated or counterfeited.
- dRNG (Decentralized Random Number Generator): This random number generator is required in Fast Probabilistic Consensus (FPC) to make the consensus model more resilient to attacks. In the case of conflicting transactions, the FPC votes on the transactions in question in several rounds. The threshold at which a node changes its mind in this vote is 50% +/- a small random deviation (using dRNG). In order to avoid stalemate or a specific outcome in the voting, this additional random component prevents potentially malicious nodes from influencing the voting process.
- Dust-Spending (IOTA 1.5): Someone who wants to harm IOTA could automatically send 1i for years to repeatedly recreated addresses, driving up the ledger’s memory requirements to the point where a full-node would eventually only run on large servers. Some kind of pledge solution will be implemented after the Chrysalis update: Only if the value transfer is less than the equivalent of 0.003 cents must the receiving address be previously charged with a certain minimum balance, otherwise the value transaction will not be accepted. This means that only the one who wants to make microtransactions must “previously” charge the destination address with 1 Ki. So the first transaction must be a 1 Ki initial transaction for the following microtransactions. This will probably be able to be regulated automatically by the Wallet. Also the addresses with Colored Coins have to be tokenized. After the Coordicide, there will be another solution for IOTA 2.0.
- Eclipse attack: A cyber attack that aims to isolate a specific user rather than attack the entire network.
- Entropy: In cryptology, this term represents a measure of the “disorder” in texts. Entropy is usually abbreviated with the Greek capital letter Η.
- Finality: The property that once a transaction has been completed, there is no way to reverse or change it. This is the moment when the parties involved in a transfer can consider the transaction completed. Finality can be deterministic or probabilistic.
- Faucet: A pool of tokens (funds). Upon uncomplicated request, one gets a limited number of tokens for testing, especially for developers of own apps this is a great help.
- Fullnodes (Hornet, Bee): They form the core (infrastructure) of the IOTA network. In order to participate in the peer-to-peer network, the fullnode must always be online and connected to neighbors (other fullnodes). In addition, the transaction database must be synchronized with all other fullnodes in the network. The role of fullnodes is to interact with clients (wallets, DApps, etc.) and attach their transactions to the ledger, make transactions known to all other fullnodes in the network, validate transactions and store them in the ledger.
- Future Cone: A group of transactions that directly or indirectly reference a child transaction in the Tangle, including the child transaction.
- Fork: In IT, this is a new development branch after a project is split into a second follow-on project; the source code or parts of it are developed independently of the original parent project.
- Genesis transaction: The Genesis transaction is the first transaction that created all IOTA tokens and distributed them to the addresses of the buyers.
- GoShimmer (No Mainnet): Prototype of Shimmer in the Go programming language. With this node-testing software, consensus is already reached without a coordinator. GoShimmer implements the various modules of Coordicide, such as autopeering, node identities, Mana, etc. GoShimmer serves as a test environment for the first alpha version and the test network. Everything tested here will be gradually merged with Hornet and later implemented in Bee.
- Generic Data Object (IOTA 2.0): The most basic object type. All unrecognized data objects are treated this way.
- History: The list of transactions that were directly or indirectly authorized by a particular transaction.
- Hash values: Checksums that are applied to the encryption of messages of variable length. Hash values are like fingerprints of a very long data set. Each message is assigned a very specific hash value.
- Hornet Node (IOTA 1.5): A completely new implementation of the core client in the Go programming language. The goal is to have a new core client which should contribute massively to the scaling of the network with a significantly increased performance. Hornet will use the architecture and modular concept of GoShimmer and is intended for low-end devices such as a Raspberry Pi. In addition, the coordinator will also run as a plugin via Hornet.
- Inclusion state: Used to determine if a transaction has been accepted and confirmed by the network. Especially for a transaction and a list of tips: Inclusion state is true if the tip refers to this transaction.
- Index: The index number can be selected in the wallet during account creation. It is an address index. New addresses are calculated with a combination of seed and this key index number. If the key index number changes, the address generation is shifted and other new addresses are generated.
- Local Snapshots: Local snapshots are urgently needed to limit the memory requirements of the full nodes to a common size. For this purpose on the individual nodes old, already confirmed, transactions are deleted from the database. What remains is only a small file (list) with the credits on the respective addresses. fullnodes perform the snapshot independently and at their own discretion. This feature allows faster synchronization, lower system resource requirements and no more waiting for global snapshots to clean up the database.
- Layer: In DLT a 2nd-layer refers to a secondary framework or protocol built on top of an existing distributed ledger. On these second layers, other applications can be executed without putting too much strain on the base layer. In IOTA, for example, these are the Smart Contracts and IOTA Streams.
- Local Modifiers: User-defined conditions that can be taken into account by nodes during tip selection. In IOTA, nodes do not necessarily have the same view of the tangle. Different types of information that are only available to them locally can be used to strengthen security.
- Lightnode: these are wallets or apps that, unlike fullnodes, do not have a full copy of the ledger (Tangle). Therefore they cannot verify and store transactions. A lightnode only manages addresses. It can be used to retrieve the ledger’s data, for example, to display credit balances or to start its own transactions and sign them with the private key. These transactions are distributed in the network and verified by the fullnodes. If everything is in order, the recipient’s address is linked to the credit and stored in the ledger.
- Minig races: In PoW-based DLTs, the competition between miners for mining rewards and transaction fees is called a mining race. In this race, the fastest and most efficient hardware always wins.
- Merkle Tree: A Merkle tree is a data structure used in computer science applications. In cryptocurrencies, Merkle trees are used to encode more efficiently and securely.
- Mainnet: The public usable IOTA network, in which the IOTA tokens are used that are traded on cryptocurrency exchanges.
- Milestone (IOTA 1.x): Milestones are transactions that are signed and issued by the coordinator. Their main goal is to help the Tangle grow healthily and guarantee finality. When milestones directly or indirectly approve a transaction in the Tangle, nodes mark the status of that transaction and its entire history as confirmed.
- Message (IOTA 2.0): The type of object that is gossiped about between neighbors. All gossiped information is contained in a message.
- Message overhead: The additional information (metadata) that must be sent along with the actual information (data). This can include signatures, polls and anything that is transmitted over the network but is not the transaction itself.
- Mana (IOTA 2.0): When a value transaction is processed, a quantity called Mana will be “pledged” to a specified node ID. This quantity is related to the amount of IOTA moved into the transaction. The only way to gain Mana is to convince some token holder to pledge it to you. In this sense, Mana is Delegated Proof of Token Ownership. Mana, therefore, provides adequate Sybil protection because it is difficult to acquire it in arbitrary amounts.
- Nakamoto Consensus: Named after the creator of Bitcoin, Satoshi Nakamoto, the Nakamoto Consensus describes the replacement of coordination / communication between known agents with a cryptographic puzzle (Proof-of-Work). Completion of the puzzle determines which agent acts next.
- Neighbors: Network nodes that are directly connected and can exchange messages without intermediate nodes.
- Nodes: The Tangle works with different types of nodes, such as fullnodes (Hornet, later Bee), lightnodes (Wallets), permanodes (Chronicle), or smart contract nodes (Wasp).
- Network Layer (IOTA 2.0): The most basic layer of the 3-layer protocol that manages the connections and gossip between neighbors.
- Network ID: The network ID enables user-specific subtangles in which nodes can only recognize messages from the network ID listed in their configuration file. See also ZebraNet.
- Orphan: A transaction (or block) that is not referenced by any subsequent transaction (or block). An orphan is not considered confirmed and will not be part of the consensus.
- Object (IOTA 2.0): the most basic unit of information in the IOTA protocol. Each object has a type and size and contains data.
- Parents: A transaction that is directly referenced by at least one other transaction in the tangle, called a child.
- Past Cone: A group of transactions that is directly or indirectly referenced by a child transaction in the Tangle, including the child transaction.
- Parasite Chain Attacks: A double spending attack on the Tangle. Here, an attacker attempts to reverse a transaction by setting up an alternate Tangle in which the funds were not spent. He then tries to get the majority of the network to accept the alternative Tangle as the legitimate one.
- Parsing: Parsers are computer programs responsible for breaking down and converting an input into a format more suitable for further processing.
- Permanode: This type of node permanently stores the entire transaction history, possibly with the help of external storage solutions, and possibly only its own transactions (selective permanode).
- Pending: A transaction has been seen by the network but not yet confirmed.
- Peer to Peer Network: A decentralized network of different network nodes that are connected to each other and exchange data.
- Peering: The process of discovering and connecting to other network nodes.
- Payload (IOTA 2.0): A field in an object that can only be filled by another object.
- Private Tangle: A private tangle is comparable to a test network under complete control of the operator. This allows companies and developers to test their applications under self-defined environment variables without external influences and protected from prying eyes. There is no interoperability between a private Tangle and the IOTA Tangle. So sending from one to the other does not work either. Each private Tangle is an independent network with its own nodes, tokens and coordinator.
- Proof of Work (PoW): A time-consuming (expensive) mathematical calculation that uses computational power to prevent spam attacks. It consists of a difficult cryptographic puzzle that is easy to verify.
- Proof of Inclusion (PoI): With PoI, one is able to provide evidence that a transaction was indirectly referenced by another transaction without having to present the full chain of actual transactions between the two transactions. This is done by using a sequence of hashes instead of the actual transaction data to prove the inclusion of a transaction (inclusion) in the referenced subtangle.
- Promote (only up to IOTA 2.0): Strategies of IOTA to reintroduce orphaned transactions. The command issues a single new zero-value transaction that confirms both your transaction and the last milestone. In some cases, it will not approve this transaction directly, but indirectly: It will perform a MCMC walk (Markov chain Monte Carlo procedure) from your transaction as well as a MCMC walk from the last milestone. The randomly selected “tips” will be used as tips for the new transaction. In this way, the weight of the new transaction is increased and the chance that your tip will be chosen later is improved. Also, if you promote a transaction that has already been promoted (and is not referenced by other transactions), your second promotion will promote the first promotion and reduce the number of tips.
- Pruning: In computer science, this is a term for simplifying, shortening, and optimizing decision trees. In IOTA, this is done by local snapshots on each fullnode. Old transactions that have already been confirmed are deleted from the database, leaving only a file (list) of credits on each address.
- Public & private keys: These are used in cryptographic systems which use key pairs. There are public keys and private keys which are known only to the owner. The generation of such keys depends on cryptographic algorithms based on mathematical problems to generate one-way functions. Effective security requires keeping the private key (seed) private; the public key (address) can be distributed openly without compromising security.
- Random Walk: An algorithm to find the pair of transactions to validate. A mathematical object that describes a path consisting of a sequence of random steps in a mathematical space.
- Reattach (only up to IOTA 2.0): Resending a transaction by reselecting tips and referencing newer tips by re-executing PoW. The command does this by selecting two new random tips and creating a copy of your transaction bundle attached to them. This initially requires more PoW (one PoW per transaction in the bundle) and basically results in a “double-spend” situation. But, only either the original or the reattached transaction can be committed. If a transaction is reattached too early, it creates a 50 / 50 situation for the nodes, meaning there is now a 50% chance that the nodes will join the wrong transaction, which would make that transaction an unconfirmed transaction (and require reattachment). In rare cases, the reattachment may be attached to one of the reattached transactions (making it impossible for the reattached transactions to ever be confirmed, orphaning those files.
- Remainder Address: When a subtotal of funds is spent at an address, all remaining unspent funds should be sent to a new address (called remainder address) at the same time. This way, these remaining funds can be safely spent from the new (remainder) address in the future.
- Rebroadcast: Repeats the sending of a transaction. While a transaction is being sent to an IOTA node, it may go offline. In this case, the IOTA node may not forward the transactions to its neighbors, and the rest of the network will never see these transactions. As a result, that transaction will never be referenced by the coordinator and thus never confirmed. Resending a bundle means resending the same bundle to an IOTA node. This way you give your transactions another chance to be forwarded to the rest of the network.
- Reusable Addresses (IOTA 1.5): With the implementation of the new signature topic Ed25519 through the IOTA 1.5 Chrysalis upgrade, reusable addresses are supported.
- Salt: In cryptography, salt is a randomly chosen string of characters that is appended to a given plaintext before it is further processed to increase the entropy (disorder) of the input. It is often used for storing and transmitting passwords to increase information security.
- Software as a Service (SaaS): The SaaS model is a subset of cloud computing. It is based on the principle that the software and IT infrastructure can be operated by an external service provider and rented by the customer as a service.
- Smart Contract Chain: Smart contracts are processed via a so-called contract chain, the representation of the contract state. A smart contract writes its state every time it is requested and a new block is added for each of these state updates. All these updates are collected and confirmed in one block. So the Chain also contains all the past states. The Chain can contain many Smart Contracts, all working on the same global state of the Chain. From this perspective, the Contract Chain is essentially a blockchain anchored on the Tangle. IOTA Smart Contracts can be considered “classic” Smart Contracts, but with the added feature that you can have multiple such parallel Chains all using the same native IOTA token and trading between them in a trusted manner on the Tangle. This enables trusted interoperability between different applications.
- Small-world network: a network in which most nodes can be reached from any other node through a small number of intermediate steps.
- Solidification time: The time of solidification when the entire history of a transaction has been received by a node.
- Splitting Attacks: An attack in which a malicious node attempts to split the tangle into two branches. As one of the branches grows, the attacker publishes transactions on the other branch to keep both alive. Splitting attacks attempt to slow down the consensus process or perform double spending.
- Sharding: IOTA nodes have an upper limit on transactions per second (TPS) they can process. Through a type of database partitioning (breaking a very large database into smaller ones) into more manageable segments (shards), each shard would contain a unique set of account balances and nodes would then be assigned to individual shards to validate transactions. The goal is that by dividing into more manageable segments, it will increase transaction throughput and thus overcome scalability issues.
- Signatures: Signatures prove ownership of an address. Clients (Wallets) need this proof before nodes validate a transaction. To prove ownership, input transactions must be signed with the private key used to create the address. A signature is created from both the private key of an address and the bundle hash (IOTA 1.0) of the transaction issued by the address.
- Seed: This is the secret master key, with which private and public keys are generated. It must have exactly 81 digits. All capital letters and the number 9 (81 TRYTES (A-Z,9) = 384 bits) are allowed. Create your seed exclusively with the new Trinity wallet. Your seed proves that you have an address and allows nodes to verify your transactions. You must keep your Seed secure. You are responsible for its security. If you lose your Seed, you will not be able to recover it. The maximum number of possible seed combinations is 27^81=8.7×10^115 seeds. This is a more than astronomically high number. The total number of all atoms in the universe is about 10^80 and the number of IOTA seeds is 10^35 times higher. A single seed can generate a high number of addresses (9,007,199,254,740,992 to be exact)
- Subseed: This is created by combining the seed and the index. It is the origin of each address. If a seed is unused, then the index is 0 and the subseed corresponds exactly to the seed. A new address is created with a new index. If the index is 1, then 1 is added to the seed in trits, so that a completely new address is created from it via multiple hashing. The origin is still reproducible with the original seed. Example: In the IOTA Tryte alphabet the character 9 corresponds to the trits 0,0,0 and an A is 1,0,0. A seed begins with 9AA, this corresponds in trits 0,0,0,1,0,0,1,0,0,0. If one adds now to the first trit a 1, then one receives 1,0,0,1,0,0,1,0,0. So the new subseed begins now “translated” with AAA. The address hashed from it looks completely different, but you can generate the “new seed” at any time without problems another time, because the “first seed” is known. When restoring funds in the wallet, this is exactly what happens. The wallet simply checks quite a few seeds that follow the original one and can restore the balance. If all credit is on a known index, then you can also calculate the subseed and simply use it as a new seed directly.What was index 1 for address 9AA…, that is simply index 0 for address AAA…!
- Subtangle: A consistent section of the tangle (i.e. a subset of messages / value objects) such that each contained message / value object also contains its referenced messages / value objects.
- Streams: IOTA Streams is a multifunctional second layer data transfer protocol that can be used for various types of data transfer (e.g., streaming data). For example, it allows sensors and other devices to encrypt entire data streams and anchor them in the IOTA Tangle. IOTA’s consensus protocol adds integrity and authenticity to these message streams. Given these characteristics, IOTA Streams fills an important need in industries where integrity, privacy, and immutability collide.
- Sybil Attack: An attempt to gain control of a peer-to-peer network by forging multiple false identities.
- Snapshot: A special feature of the Tangle. A snapshot deletes all transactions. Only transactions with a balance > 0 are kept. The metadata such as tags and messages are also deleted. What is left behind is just a list of addresses and balances. After a snapshot, the nodes use this list as “genesis”, a new starting point for the tangle. This reduces the size of the tangle network, allowing IOTA nodes to use less memory. Fullnodes perform what are called “Local Snapshots” independently and at their own discretion. This means faster synchronization, lower system resource requirements, and no more waiting for global snapshots to clean up the database. Local snapshots are urgently needed to limit the storage requirements of the full nodes to a common size. By default, nodes store about 30 days of transaction data. This can be changed individually. However, the fullnode operator must be careful not to snapshot locally too frequently. If they snapshot too quickly they risk building a subtangle that can fall out of consensus. This would be like a miner in the blockchain that only stores information contained in the last block in the blockchain – it is possible that this block will eventually not become part of the longest chain and this miner will build on an abandoned chain.
- Tangle: The Tangle is the underlying core data structure. In mathematical terms it is a directed acyclic graph (DAG). The Tangle is the distributed ledger of IOTA that stores all transactions.
- Tag: A short message which can be attached to a transfer. It can be searched for in the Tangle.
- TPS: Transaction per second
- Ternary system: A trit (trinary digit) can have exactly three states (3 x 1 = 3): -1, 0 and 1. Three trits result in one tryte (33 = 27) and can thus represent 27 combinations. In IOTA, the letters A-Z (26 pieces) and the number 9 are used for this purpose.
- Tail Transaction (IOTA 1.0): The transaction that appears as tip is always the tail transaction of a bundle. Transaction 0 in a bundle is always the tail transaction of the bundle.
- Token: The digital currency form (cryptocurrency). It is a powerful tool for value transfer between people and machines. Total number: 2,779,530,283,277,761 IOTA. The base units are pi, ti, gi, mi, ki, i
- Troika: A ternary hash function (not in use, ternary vision).
- Tip: A transaction that has not yet been approved.
- Tip Selection: The process of selecting previous transactions to be referenced by a new transaction. In these references, a transaction links to the existing data structure. IOTA only enforces that a transaction approves two other transactions. The tip selection strategy is left to the user (with a good default provided by IOTA).
- Tip Transaction: A solid end transaction that is not yet a parent.
- Transaction: A transaction that transfers funds or information between two nodes. A transaction is called “solid” if its entire history is known.
- Transaction (IOTA 2.0): The payload of a value object. It contains the details of a money transfer.
- Transaction history: Please read on here.
- UTXO model (IOTA 1.5): This is a so-called addressing model. UTXO stands for “unspent transaction output”, which simply means that you not only keep track of the credits on the address, but also keep track of where the credits come from and where they are sent when they are spent. Each token on an address is thus uniquely identifiable and each issue names the exact token they want to move. This enables faster and more accurate conflict handling and improves the resilience and security of the protocol.
- Value object (IOTA 2.0): The basic object of the value transfer application.
- Value Tangle (IOTA 2.0): The collection of all value objects (application layer).
- Value Transfer Application (IOTA 2.0): The application that maintains the state of the ledger.
- Version Number (IOTA 2.0): Indicates the correct format of each type.
- Winternitz one-time signature (WOTS, IOTA 1.0): A quantum robust signature that authorizes value transactions from an address. It involves signing with the private key. Since it is a one-way signature, the holdings of IOTA on an address are increasingly compromised if the same key is signed multiple times. Therefore, with IOTA you must not reuse an address from which IOTA was sent, because the signature is already known in the network. As of IOTA 1.5, WOTS is replaced by the signature scheme Ed25519, which allows reusable addresses.
- White-flag approach (IOTA 1.5): Used to calculate credits. A simpler, conflict-avoiding approach that improves the speed and efficiency of tip selection, eliminates certain attacks, and significantly reduces the need for reattachments.
- Wasp: A node for IOTA Smart Contracts.
- Zebranet: A user-specific subtangle. In the future, Zebra Technologies and the IOTA Foundation will deploy a dedicated IOTA DLT network called Zebranet for Zebra customers. The Zebranet is a 2nd-layer scaling in the form of logically separated subtangles with a unique network ID. Within the subtangle, nodes can only recognize messages from the network ID listed in their configuration file. Activity in these subtangles can be context-specific and need not compete with throughput in the mainnet. However, the token supply remains global. To make value transactions in these subnets, IOTA tokens must first be deposited into the subtangle, which then disappear from the mainnet (tokens can be transferred back and forth). This type of 2nd-layer scaling will be introduced for data first, with support for value transfers added later. The ability to create context-specific subnets (2nd-layer scaling) does not mean that fluid sharding (1st-layer scaling) can be dispensed with. It is a complementary concept that can be used if it makes sense for the use case.
Last Updated on 16. February 2021