ID-Based Balance is a blockchain accounting model where a user's token balance is not stored as a standalone number but is instead derived from a unique, on-chain identifier (the ID). This identifier acts as a cryptographic proof of ownership, and the balance is calculated by the protocol based on the properties or history associated with that ID. This contrasts with the UTXO model, where balances are the sum of discrete, unspent transaction outputs, and the Account-Based model (used by Ethereum), where balances are stored as a mutable state variable directly within an account.
LABS
Glossary
ID-Based Balance
ID-based balance is a token accounting model where an account's holdings are tracked per unique token ID, enabling fungible and non-fungible assets in a single contract.
Chainscore © 2026
definition
BLOCKCHAIN ACCOUNTING MODEL
What is ID-Based Balance?
An accounting model where a user's balance is derived from a unique identifier, rather than being stored as a simple numeric value on a UTXO or account.
The core mechanism relies on linking the ID to specific assets or a record of entitlements. For example, in a system using Non-Fungible Tokens (NFTs) to represent fractional ownership, a user's balance of a fungible asset might be determined by which specific NFT IDs they hold in their wallet. The protocol's smart contract logic contains the rules for mapping these IDs to a quantifiable balance, enabling complex conditional logic—such as vesting schedules, loyalty tiers, or access rights—to be intrinsically tied to the asset itself.
This model enables powerful programmability and composability for digital assets. Since the balance is computed, not stored, it can dynamically reflect off-chain data via oracles, governance decisions, or user actions. Key use cases include: - Loyalty points with decaying values or tiered benefits. - Vesting tokens where unlock schedules are embedded in the asset. - Conditional airdrops where eligibility is proven by holding a specific NFT ID. - Soulbound Tokens (SBTs) representing non-transferable reputational balances.
Implementing ID-Based Balance systems requires careful smart contract design to ensure efficient balance lookups and secure derivation logic. Developers must architect the state model to minimize gas costs for frequent balance queries, which can be higher than a simple storage read. Furthermore, the security audit surface expands, as the correctness of the entire system depends on the infallibility of the balance derivation algorithm and the immutability of the ID-to-entitlement mapping.
how-it-works
ACCOUNTING MODEL
How ID-Based Balance Works
A fundamental shift from the UTXO model, ID-based balance is the accounting system used by blockchains like Ethereum, where user accounts hold a single, updatable balance directly on-chain.
ID-based balance, also known as the account model, is a blockchain accounting paradigm where the network's state is organized around accounts, each identified by a unique address (the ID). Each account directly stores its current balance as a single, mutable value within a global state trie. This contrasts with the Unspent Transaction Output (UTXO) model, where value is distributed across discrete, unspent transaction outputs. In this system, transactions are atomic operations that directly debit the sender's account and credit the recipient's, updating the central ledger state. This model underpins smart contract platforms, as contract accounts can also hold balances and execute complex logic.
The mechanics rely on a global state trie (a Merkle Patricia Trie) that maps account addresses to their state objects. An account's state includes its nonce (transaction count), balance, storage root (for contracts), and code hash (for contracts). When a transaction is processed, the network fetches the sender and receiver account states from this trie, validates the sender has sufficient balance, updates the values, and commits the new state root to the block header. This creates a verifiable cryptographic commitment to the entire network state after each block.
Key advantages of the ID-based model include simplified balance calculation—a user's total funds are a single on-chain value—and native support for complex stateful logic within smart contracts. However, it introduces challenges like the need for strict transaction ordering (handled via nonces) to prevent replay attacks and potential state bloat. It also enables certain efficiencies, such as allowing multiple transactions to interact with the same account state within a single block, a concept central to DeFi composability.
A canonical example is an Ethereum transaction sending 1 ETH. The network checks the sender's account balance, reduces it by 1 ETH plus gas fees, increments the sender's nonce, and increases the recipient's balance by 1 ETH. All other accounts remain unchanged. This model is essential for Decentralized Applications (dApps), as it allows contracts to maintain persistent internal state and balances, enabling functionalities like token vesting schedules, lending pool reserves, and automated market maker liquidity.
key-features
CORE MECHANISM
Key Features of ID-Based Balance
ID-Based Balance is a blockchain accounting model where a user's total holdings are tracked via a single, unique identifier, rather than as a sum of individual UTXOs or token balances. This enables novel programmability and state management for assets.
01
Single State Identifier
At its core, ID-Based Balance replaces the UTXO model or separate ERC-20 balance mappings with a single, persistent identifier (the ID) that represents a user's entire state. This ID points to a state object containing all owned assets, permissions, and metadata, allowing for atomic operations across multiple asset types within a single transaction.
02
Programmable Asset Logic
The state object linked to an ID is not just a balance sheet; it contains executable logic. This enables custom transfer rules, time-locks, spending limits, and composability hooks to be baked directly into the asset itself. For example, an asset can be programmed to only be transferable after a governance vote or to automatically split royalties on sale.
03
Atomic Multi-Asset Operations
Because all assets are grouped under one state, complex transactions involving multiple asset types (e.g., swapping Token A for Token B while also paying a fee in Token C) can be executed atomically in a single step. This eliminates the need for cumbersome approval workflows and reduces front-running and settlement risk inherent in multi-step DeFi interactions.
04
Enhanced Composability & Modules
ID-Based systems are often designed with a modular architecture. Developers can deploy state modules (smart contracts) that attach new functionality or asset types to a user's ID. This allows for seamless integration of new financial primitives—like a lending module or a vesting schedule—without requiring users to migrate assets or manage separate contracts.
05
Simplified User Abstraction
For end-users, the ID serves as a unified financial namespace. Instead of managing a wallet with dozens of token balances and NFT holdings, they interact with a single ID that represents their entire portfolio. This abstraction layer can simplify interfaces, enable social recovery mechanisms tied to the ID, and improve the overall user experience in wallet design.
06
Contrast with UTXO and Account Models
- UTXO (Bitcoin, Cardano): Tracks coins as unspent transaction outputs. Complex to sum for balances; good for privacy/verification.
- Account Model (Ethereum, Solana): Tracks balances in a global state mapping (address → balance). Simple for balances, but assets are siloed.
- ID-Based Balance: Unifies all assets under a programmable state object, blending balance simplicity with UTXO-like verifiability and enhanced programmability.
TOKEN STANDARD COMPARISON
ID-Based Balance vs. Other Standards
A technical comparison of token accounting models, highlighting the core architectural differences between ID-based balance, UTXO, and account-based standards.
| Core Feature | ID-Based Balance (e.g., ERC-404, DN-404) | Account-Based (e.g., ERC-20, ERC-721) | UTXO-Based (e.g., Bitcoin, Cardano) |
|---|---|---|---|
Native Fungibility | ERC-20: True ERC-721: False | ||
Native Fractionality | ERC-20: True ERC-721: False | ||
Primary Data Structure | Mapping (owner => balance, ID list) | Mapping (owner => balance) or Mapping (ID => owner) | Unspent Transaction Output (UTXO) graph |
State Complexity | Owner holds balance & manages an internal ID set | Owner holds a balance (fungible) or owns specific IDs (NFT) | Network holds all UTXOs; user holds private keys |
Atomic Swap / Batch Transfer | Requires separate approvals or wrapper contracts | ||
Direct Owner Lookup for an ID | O(1) via central registry | O(1) via token ID to owner mapping | Requires chain traversal |
Gas Efficiency for Simple Transfer | Higher (manages two states) | Low (updates single balance) | Low (creates new UTXOs) |
Typical Use Case | Semi-fungible tokens, fractional NFTs | Fungible currencies or unique collectibles | Peer-to-peer electronic cash |
code-example
PRACTICAL IMPLEMENTATION
Code Example: Querying a Balance
This section demonstrates the technical process of retrieving an account's balance using its unique identifier, a fundamental operation in blockchain interaction.
Querying an ID-based balance programmatically involves calling a specific function on a smart contract or querying a node's API. For ERC-20 tokens on Ethereum, the standard interface defines a balanceOf(address owner) function. A typical call in Solidity would be uint256 myBalance = myToken.balanceOf(msg.sender);, where msg.sender is the address of the caller. In a web3 context using JavaScript, you would use a library like ethers.js: const balance = await contract.balanceOf(userAddress);. This read-only call does not require a transaction fee (gas) as it only queries the blockchain's current state.
The underlying mechanism relies on the blockchain's state trie, a cryptographic data structure that maps account addresses to their state, including the balance. When you query a balance, the node traverses this trie using the provided address as a key. For UTXO-based blockchains like Bitcoin, the process is conceptually different; a wallet must scan the blockchain for all unspent transaction outputs (UTXOs) associated with a given address and sum their values. Most developer APIs abstract this complexity, providing a simple getbalance RPC call.
Best practices for querying balances include caching results for non-critical data to reduce RPC calls, handling network errors gracefully, and being aware of token decimals. An ERC-20 balance of 1000000 might represent 1.0 tokens if the decimal value is 6. Always format the raw balance using the contract's decimals() function. Furthermore, for real-time applications, developers can subscribe to balance change events using filters or websockets to update the UI without constant polling, providing a more efficient user experience.
ecosystem-usage
ID-BASED BALANCE
Ecosystem Usage & Protocols
ID-Based Balance is a mechanism for tracking assets or rights associated with a unique identifier rather than a traditional blockchain address. It enables complex state management for users, assets, and applications.
01
Core Mechanism
An ID-Based Balance system maintains a ledger where the primary key is a unique identifier (ID), not a cryptographic public key. This ID can represent a user, a smart contract, or a virtual account. Balances and states are updated by authorized protocols that verify the ID's rights, enabling off-chain computation and gas-efficient state updates. This is fundamental to account abstraction and intent-based architectures.
02
Soulbound Tokens (SBTs)
A primary use case where balances are non-transferable tokens bound to a Decentralized Identifier (DID) or wallet. They represent credentials, memberships, or reputation.
- Example: A protocol issues an SBT to an ID representing on-chain credit score.
- The balance (e.g.,
1SBT) is permanently associated with that ID, creating a persistent, verifiable record of attributes.
03
ERC-4337: Account Abstraction
This standard enables smart contract wallets where the user's identity is a contract address (the ID). The wallet's balance and transaction logic are managed by the contract's code, not an Externally Owned Account (EOA).
- Allows sponsorship of gas fees by dApps.
- Enables session keys and transaction batching.
- The user's ID-based account holds assets and executes arbitrary logic.
04
Intent-Centric Protocols
Protocols like Cow Swap and UniswapX use ID-based systems to manage user intents. A user submits a signed intent (e.g., 'sell X for Y at best price'), which receives a unique Intent ID. Solvers compete to fulfill it, and the protocol's settlement contract manages the balance escrow associated with that ID until execution or cancellation.
05
Layer 2 State Management
Rollups (Optimistic, ZK) often use ID-based balances for efficient state updates. A user's state (token balances, NFT holdings) is tracked by an ID within the rollup's state tree. Proofs or fraud proofs update these balances in batches on Layer 1, decoupling user identity from frequent, costly mainnet transactions.
examples
ID-BASED BALANCE
Practical Examples
ID-based balance is a mechanism where a user's token holdings are tracked by a unique identifier, not a wallet address, enabling complex financial logic and privacy-preserving applications. These examples illustrate its core use cases.
02
Soulbound Tokens (SBTs) & Reputation
Non-transferable Soulbound Tokens are issued to a user's ID, representing credentials, memberships, or reputation. The balance (e.g., holding a specific SBT) gates access to services.
- Example: A DAO issues a "Contributor" SBT to member IDs, required to vote on proposals.
- Mechanism: The contract checks
balanceOf(id, tokenId) > 0for access control.
03
DeFi with Isolated Credit Lines
A lending protocol can issue a credit line to a user's verified ID, not their EOA. The borrowed amount is an ID-based liability, separate from the user's other wallet assets, enabling undercollateralized loans.
- Risk Isolation: Defaults affect the ID's reputation/balance within the system but not unrelated wallets.
- Portability: The credit line persists if the user changes their underlying wallet address.
04
Cross-Chain Asset Portability
A user's asset balance is mapped to a universal ID (e.g., a decentralized identifier). The system tracks the balance per ID across multiple chains, enabling seamless movement and a unified view.
- User Experience: "My 100 tokens" are accessible from Chain A or Chain B via the same ID.
- Backend: A cross-chain messaging protocol updates the canonical ID-based balance ledger.
05
Subscription & Streaming Payments
A service grants access based on an active time-based balance linked to an ID. Users "stream" tokens to a provider's ID, and the service checks the real-time streaming balance.
- Example:
balanceOfStream(id, providerId)returns how many seconds of service are prepaid. - Advantage: Enables granular, cancel-anytime subscriptions natively on-chain.
06
Game Asset & Skill Tracking
In-game assets, skill points, or achievements are stored as balances on a player's game-specific ID. This allows progression and inventory to be portable across sessions and devices, independent of the wallet holding transaction gas.
- Design: The game client authenticates the player's ID to query their asset balances.
- Interoperability: Assets from one game (as ID-based balances) could be verified as inputs in another.
security-considerations
ID-BASED BALANCE
Security Considerations
ID-based balance systems, where token ownership is linked to a user's identity rather than a wallet address, introduce unique security trade-offs between privacy, compliance, and attack vectors.
01
Centralized Identity Point of Failure
The core security model shifts from securing a private key to securing the identity provider (e.g., a government ID system or a centralized attestation service). A compromise of this provider could lead to mass account takeover or identity theft across all linked assets. This creates a single, high-value target for attackers.
02
Privacy vs. Surveillance Trade-off
While ID-linking enables compliance (e.g., KYC/AML), it inherently reduces financial privacy. All transactions tied to an identity are permanently linkable by the governing authority or any entity with access to the mapping. This creates risks of:
- Transaction graph analysis by adversaries.
- Targeted censorship or freezing of assets based on identity.
- Data breach exposure of sensitive personal financial history.
03
Sybil Resistance & Collusion Attacks
A primary security benefit is Sybil resistance, preventing a single entity from creating many fake identities to manipulate governance or rewards. However, this relies on the infallibility of the identity verification process. Weak verification can be exploited, while overly strict verification may exclude legitimate users (inclusion problems).
04
Key Management & Recovery Complexity
User security depends on both the identity system's recovery (e.g., password resets, customer support) and the cryptographic key management for signing transactions. Loss of the identity credential (e.g., a biometric) or the signing key can each result in permanent loss of access. Recovery mechanisms often reintroduce centralized trust.
05
Regulatory & Legal Attack Vectors
Assets are directly tied to legal identity, making them subject to seizure orders, sanctions enforcement, and tax liens with high precision. This differs from pseudonymous systems where linking assets to an entity requires forensic analysis. The legal attack surface is significantly expanded and automated.
06
Implementation & Oracle Risks
In blockchain implementations, ID-based balances often rely on oracles or trusted state bridges to verify off-chain identity claims on-chain. The security of the entire system then depends on the correctness and availability of these external data feeds, introducing oracle manipulation and bridge exploit risks.
ID-BASED BALANCE
Frequently Asked Questions
A deep dive into the mechanics and implications of using unique identifiers to manage and track assets on-chain, a fundamental concept for modern blockchain applications.
An ID-based balance is a system for tracking assets on a blockchain where ownership is tied to a unique, non-fungible identifier (ID) rather than a simple numeric quantity in a single account. This model underpins Non-Fungible Tokens (NFTs) and semi-fungible tokens, where each token ID represents a distinct asset with its own metadata and ownership history. Unlike a fungible token balance (e.g., 10 ETH), an ID-based balance answers the question "which specific assets does this address own?" by maintaining a list of token IDs. This is typically implemented using smart contract standards like ERC-721 or ERC-1155, which map owner addresses to sets of token IDs and vice-versa.
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall