bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 2쪽 중 1쪽
IOTA Foundation | 30 May 2025
Technical and Tokenomics
Whitepaper
2
IOTA Technical and Tokenomics Whitepaper 30 May 2025
1. Introduction 3
2. Tokenomics 4
2.1. Staking and Rewards 4
2.1.1. Validator Staking Pool Requirements 6
2.2. Fee Structure 7
3. Underlying Tech 10
3.1. Object-Centric Design 11
3.2. Consensus Mechanism 13
3.3. Smart Contracts 13
3.4. Transaction Lifecycle 14
Appendix: Total and Circulating Supply 16
Table of Contents
3
IOTA Technical and Tokenomics Whitepaper 30 May 2025
1. Introduction
IOTA is an open-source distributed ledger technology designed to bring real-world applications
on-chain. Scalable, efficient, and secure, it powers a public goods infrastructure optimized for
enterprise solutions and Web3 innovation. With smart contracts and a modular architecture,
the IOTA mainnet provides a global, permissionless foundation for diverse applications and a
streamlined pathway to market adoption.
Backed by a proven track record in industry and public sector collaborations, IOTA has been
applied to supply chain management, digital identity, energy systems, and more. It also empow-
ers developers to build decentralized applications, DeFi projects, and custom blockchain-based
solutions.
4
IOTA Technical and Tokenomics Whitepaper 30 May 2025
2. Tokenomics
The IOTA token ($IOTA) is the native asset and the foundation of economic activity within the
IOTA network. Its design governs how users interact with the system, how resources are allo -
cated, and how consensus is maintained. The tokenomics of IOTA are carefully designed to align
with its vision, balancing incentives, network security, and sustainable growth.
With the rebase of the IOTA network, a total of 4,600,000,000 IOTA tokens were migrated from
the previous Stardust network. All original tokens are now represented on the IOTA Mainnet
as objects of type 0x2::iota::IOTA. These tokens remain accessible at the same hexadecimal
addresses used on the previous Stardust-based network, and no manual migration is required.
Each IOTA token is divisible into smaller units called NANOs, with one IOTA equivalent to one
billion NANOs. A summary about circulating supply and inflation can be found at Appendix: Total
and Circulating Supply.
$IOTA is also essential for securing the network through staking. Our protocol uses a delegated
proof-of-stake (DPoS) mechanism, meaning that validator influence is determined by delegated
stake. Users delegate their IOTA tokens to validators to support network security and earn a
share of the minted subsidy. At the end of each 24-hour epoch, 767,000 new IOTA tokens are
minted, corresponding to an initial annual minting rate of 6% of the total supply. The number
of newly minted IOTA tokens per epoch is fixed, meaning that, in percentage, the minting rate
changes over time. These tokens are distributed among participants based on validator perfor-
mance, commission rates, and the amount of delegated stake.
The IOTA token has several key functions beyond being a medium of exchange. Firstly, it is used
to pay for transaction fees and storage deposits on the network. Every transaction incurs a small
fee that is automatically burned, reducing the overall token supply. Additionally, transactions
that increase the storage burden on validators require a small locked deposit. This deposit is
returned to the user once this storage demand is released.
Thus, the total supply of IOTA tokens fluctuates over time, influenced by two opposing forces:
the minting of new tokens and the burning of fees. The subsidy minting is handled at the proto-
col level; while burning occurs automatically as a function of network usage. As a result, while
the IOTA token supply is not capped, its growth is designed to remain at most linear over time.
In the sections that follow, we explore each component of the IOTA economy in more detail,
including fees, staking mechanics, and validator dynamics.
2.1. Staking and Rewards
A set of independent validators participate on the IOTA network, each running its own instance
5
IOTA Technical and Tokenomics Whitepaper 30 May 2025
of the IOTA software on a dedicated machine or virtual server. Each validator handles read and
write requests sent by clients, verifying transactions and updating on-chain information. Natu -
rally, these activities are rewarded. In this section, we detail how this is done.
IOTA uses Delegated Proof-of-Stake (DPoS) to determine which validators operate the network
and their voting power. The committee of validators that participate in consensus is formed,
initially, by the 50 top stakers among candidates fulfilling minimum requirements (see 2.1.1. Vali-
dator Staking Pool Requirements). We aim to increase the maximum committee to 150 validators,
enhancing decentralization without compromising performance. Those validators are incentiv -
ized to participate in good faith via staking rewards, which are slashed in case of misbehavior.
We refer to a validator and its delegators by “staking pool”.
IOTA adopts a self-custodial staking, i.e., stakers keep their staked IOTA tokens in their own
account. IOTA token holders are then free to withdraw their IOTA or to change their selected
validator at any time. To mitigate the security risks associated with centralization, a validator’s
voting power is capped at 10%. If a validator receives more than 10% of the total delegated
stake, their effective voting power is limited to this threshold, with the excess stake redistributed
among other validators. In the rest of this document, references to “voting power” or “pool
stake” refer to these capped values.
The operation of the IOTA network is temporally partitioned into non-overlapping, approximate
fixed-duration (~24-hour) epochs. During a particular epoch, the set of validators participating
in the network and their voting power is fixed. At an epoch boundary, reconfiguration might
occur and can change the set of validators participating in the network and their voting power.
When a user stakes with a validator, their stake counts towards the validator’s voting power
starting from the next epoch. Similarly, when a user withdraws their stake, it stops counting from
the next epoch. The distribution of staking rewards are also processed at epoch boundaries.
Specifically, this process happens as follows:
1) At the beginning of each epoch E , the delegated tokens poolStake(i,E) for a given
validator i are added up, and a new validator committee is formed. Following this
action, the protocol computes the total amount of stake totalStake(E) as the sum of the
delegated IOTAs among all the validators.
2) During the epoch, users submit transactions to the IOTA network and validators process
them. For each transaction, users pay the associated computation fees, the storage
deposit and, optionally, a tip for prioritization (see 2.2. Fee Structure). In cases where
users delete previous objects or data within objects, users obtain a rebate of their
storage deposit. Validators observe the behavior of other validators and evaluate each
other’s performance.
6
IOTA Technical and Tokenomics Whitepaper 30 May 2025
3) At the end of each epoch E , the protocol distributes staking rewards to the participants.
This occurs through the following main steps:
a) A maximum amount of stake rewards is assigned to each pool, proportionally to their
stake and the total amount of stake rewards. The stake rewards are composed of a
validator subsidy subsidy —currently set to 767,000 IOTA tokens per epoch—, plus
the total amount of tips tips(E) paid by users during the epoch. The maximum stak-
ing reward maxPoolReward(i,E) for validator pool i at epoch E is computed as
b) The value above is then adjusted to consider validators who have not met minimum
quality requirements. We denote as performance(i,E) the performance factor of a
validator i at epoch E , which corresponds to performance(i,E) = 1 for fully perfor-
mant validators and performance(i,E) < 1 for non-performant validators. This variable
ensures that validators have incurred monetary risk and therefore are incentivized to
operate the IOTA network efficiently. The rewards actually distributed to each pool is
computed as
poolReward(i,E) = performance(i,E) × maxPoolReward(i,E)
c) Now, each pool’s amount of rewards is distributed between the validator and the
other parties. Validators first keep a commission com(i,E) (of maximum 20%) of the
total pool rewards as a fee to cover their costs. The rest of the rewards (i.e., after
discounting the validator’s commission) is distributed among all users proportionally
to their stake. Specifically, let stake(j,E) represent the stake owned by a delegator j ,
and delegated to pool i at epoch E . The rewards for delegator j and for the valida-
tor i itself in this epoch equal
validatorReward(i,E) = com(i,E) × poolReward(i,E)
Consequently, validators can earn more the better their performance and the more delegated
stake they can attract. On the other hand, IOTA token stakers will also receive less rewards when
their selected validator is penalized due to poor performance. An unresponsive validator is thus
doubly exposed to IOTA incentives: they lose directly through slashed rewards and indirectly
through reduced user stake in future epochs as stakers move their tokens to more responsive
validators.
2.1.1. Validator Staking Pool Requirements
There are minimum staking requirements a validator must satisfy to be eligible to be in the
validator committee. More precisely:
maxPoolReward(i,E) = × (subsidy + tips(E)) totalStake(E)
poolStake(i,E)
delegatorReward(j,E) = × (1 − com(i,E)) × poolReward(i,E) poolStake(i,E)
stake(j,E)
7
IOTA Technical and Tokenomics Whitepaper 30 May 2025
– A validator candidate must accrue at least 2M IOTA of delegated stake before they can
request to join the validator set.
– If an active validator’s delegated stake falls below 1.5M IOTA, they have seven epochs of
grace period to gain back the stake before being removed from the validator set.
– If an active validator’s delegated stake falls below 1M IOTA, they are removed from the
validator set at the end of the current epoch boundary.
2.2. Fee Structure
As an inherent part of the IOTA economic model and incentive structure, the IOTA transaction
pricing mechanism achieves two outcomes:
1. Delivering low, predictable transaction fees.
2. Preventing spam attacks.
This enables users to focus on using the IOTA network to provide the best user experience with-
out needing to forecast the current market price of gas fees. Since validators receive subsidies
for doing their job correctly, they are not solely reliant on user fees to incentivize them.
Transaction fees on the IOTA network are intentionally minimal, designed to foster accessibility
while maintaining economic sustainability. A portion of these fees is burned, introducing a defla-
tionary mechanism which counterbalances the inflationary issuance of tokens used for staking
rewards. Another portion of the fees is allocated to cover the cost of data storage on the ledger,
tying the network’s economic incentives to responsible resource usage. When data stored on
the ledger is later freed, the tokens allocated for that storage are fully rebated, incentivizing
efficient use of storage resources and ensuring the ledger remains optimized over time.
The net fees that a user pays equals the computation and storage fees minus the rebates asso-
ciated with data deletion:
net_gas_fees = computation_fee + storage_deposit − storage_rebate .
The information on net gas fees is displayed in the IOTA network explorer for each transaction
block.
While computation fees and storage deposits are considered different payments, they are
conceptually similar in that they each translate computation or storage into IOTA terms by multi-
plying computation or storage units by the relevant price. Since the storage component is 100%
rebatable, the terms storage fee and storage deposit are used interchangeably.
8
IOTA Technical and Tokenomics Whitepaper 30 May 2025
Storage fees
Storage fees vary depending on the amount of new data written into on-chain storage. Each
byte held in storage is mapped into 100 storage units. So, for example, a transaction whose
effects imply the storage of 25 bytes will cost the price of 2,500 storage units. Importantly, the
rebating mechanism incentivizes users to minimize the storage burden they place on all nodes
by reducing their storage requirements and cleaning up unused objects. Finally, the storage fee
for a transaction is given by
storage_fee = storage_units × storage_price ,
where the storage_price is set by the protocol and the storage_units is known by the user in
advance.
Computation fees
Different IOTA transactions require varying amounts of computational efforts for processing and
execution. IOTA translates these varying operational loads into transaction fees by measuring
each transaction in terms of computation units. In general, more complex transactions require
more computation units.
IOTA charges gas consumption by rounding up computation units to the nearest 1,000, meaning
that all transactions consume at least 1,000 computation units. The largest possible consump-
tion is 5,000,000 computation units; if a transaction requires more than that, it aborts. The IOTA
Gas Pricing is such that the computation component is given as follows:
computation_fee = computation_units × gas_price
where the user specifies the gas_price . This value must be greater than or equal to
the reference_gas_price defined by the protocol. The burned portion of these fees is given by
computation_units × reference_gas_price ,
and any additional value not burned is considered a tip to validators and distributed together
with rewards. Specifically, the tip value of
tip = (gas_price − reference_gas_price) × computation_units 0
is not burned and, instead, is distributed among participants (see 2.1. Staking and Rewards; note
that the rewards distributed at epoch E are proportional to subsidy + tips(E) ). However, during
regular network operations, users can expect to have their transactions promptly included by
paying only the burnt portion of the fees (i.e., by setting gas_price = reference_gas_price ).
Additionally to gas_price , the user must define a gas_budget . This provides a cap to the
9
IOTA Technical and Tokenomics Whitepaper 30 May 2025
amount of gas fees paid, since it is not possible to perfectly forecast how much a transaction
costs before the user submits it to the IOTA network. The gas budget for an IOTA transaction is
defined in IOTA units, and transactions are successfully executed if:
gas_budget {computation_fees, net_gas_fees} .
Ultimately, a successful transaction requires the end user to pay the transaction’s net_gas_fees .
However, storage fees and rebates can only be calculated after the transaction is completely
executed, meaning that, during execution, nodes can estimate lower bounds for computation_fees
but not for net_gas_fees . The gas budget checks happen as follows:
– During execution, lower bounds for computation_units (and consequently,
for computation_fees ) are periodically calculated. The transaction will abort whenever
its gas_budget cannot pay for these computation fees. In this case, the whole gas_budget
is charged.
– In case the execution was not aborted (which means that gas_budget was large enough
to cover computation_fees ), the storage fees and rebates are calculated given the trans-
action effects.
– If storage rebates are at least as large as the storage fees,
net_gas_feescomputation_fees, meaning that the budget set by the user will certainly
be high enough. In this case, the execution is successful and the user will be
charged net_gas_fees .
– If storage rebates are smaller than storage fees (meaning that
net_gas_fees > computation_fees ) and the budget set by the user is enough
to pay for these net_gas_fees , the execution is successful and the user will be
charged net_gas_fees .
– Finally, if net_gas_fees > computation_fees but the budget set by the user not
is enough to pay for these net_gas_fees , the transaction will fail. In this case,
computation_fees are charged, as the storage fees associated with mutating the
transaction’s input objects.
Note that in some cases—especially in the presence of high storage rebates, and thus, negative
net storage fees—the total gas fees the user pays (i.e., net_gas_fees ) might be lower than the
computation fees. Thus it is often the case that a transaction only goes through if the gas budget
is considerably higher than the net gas fees that a user ultimately pays.
Importantly, the minimum gas budget is 1,000,000 NANOS or 0.001 IOTA (recall that any trans-
action uses at least 1,000 computation units and assuming that reference_gas_price is 1,000
NANOS).
10
IOTA Technical and Tokenomics Whitepaper 30 May 2025
3. Underlying Tech
IOTA is a next-generation distributed ledger technology designed to address the scalability,
programmability, and decentralization limitations of earlier blockchain systems. Building on
nearly a decade of research and development, IOTA integrates advanced innovations such as
the Move Virtual Machine (MoveVM) to its architecture, creating a secure, scalable, and efficient
platform for global financial and industrial applications.
IOTA employs a Byzantine Fault Tolerant consensus protocol (Mysticeti) to ensure robust
network security and high throughput, achieving sub-second transaction finality and supporting
tens of thousands of transactions per second. Mysticeti’s underlying DAG structure eliminates
traditional blockchain bottlenecks, ensuring the system remains efficient under high demand.
Native digital asset functionality allows users to create and manage tokens directly within the
protocol without reliance on smart contracts, reducing complexity and costs.
The IOTA ecosystem enables programmability in both Layer 1 and Layer 2 using Move and EVM/
Solidity smart contracts respectively:
Layer 1
Move is a powerful, secure programming language designed specifically for digital asset
management and smart contracts. Its unique features make it an ideal choice for developers
working in the blockchain space. Here are the key features of Move on IOTA:
– Object-Centric Design: Move is fundamentally object-centric, allowing developers to
intuitively model complex data structures and interactions. In Move, you can define objects
representing assets, users, contracts, and more, facilitating a natural and straightforward
way to manage state and behavior.
– Performance: Move on IOTA is based on the object model, not a shared global state. This
allows transactions to be executed in parallel, which translates into a network with high
throughput, less congestion, and therefore lower gas fees.
– Security: Move prioritizes safety and efficiency, with Rust’s ownership model inspiring
Move’s approach to memory management and resource control. The compiler enforces
strict rules to prevent common programming errors, ensuring that assets remain secure
within user accounts and cannot be accessed without the correct keys. While the compiler
catches many potential issues before deployment, developers should still be mindful of
logical errors, arithmetic overflows, and other runtime concerns when implementing smart
contracts.
Layer 2
EVM stands for “Ethereum Virtual Machine” and is currently the tried and tested virtual machine
11
IOTA Technical and Tokenomics Whitepaper 30 May 2025
running most smart contract networks. Solidity is the programming language of choice for the
EVM. It was created for this specific purpose. The main b프로젝트로 돌아가기