IOTA 백서

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
프로젝트로 돌아가기