Should Senior and Junior Tranches Share One ERC-1400 Token?
ERC-1400 partitions are named sub-balances inside one security token contract, so a single token can hold a senior and a junior credit tranche for the same investor. In the Consensys reference implementation, every ERC-20 view adds those sub-balances together: balanceOf and totalSupply report one figure across all tranches, and a plain transfer draws from default partitions in a fixed order.
TL;DR — Key Takeaways
- ✓The interface: The ERC-1410 draft requires balanceOf to equal the sum of all partitions. In the Consensys reference ERC1400.sol, balanceOf, totalSupply, name, symbol and decimals (fixed at 18) are one value for every tranche in the contract.
- ✓Transfers: transfer and transferFrom drain the owner-set default partitions in array order. If senior and junior are both defaults, one ERC-20 transfer can move a mix of tranches; if neither is, ERC-20 transfers of them revert.
- ✓Reclassification: operatorTransferByPartition counts the holder as its own operator, and a 0xff flag in data changes the destination partition. Without a validator rule, a holder could move junior units into the senior partition.
- ✓Waterfall: No design puts the payment waterfall in the token. Partitions are bytes32 labels with balances; priority of payment sits in the documents and the distribution process.
- ✓The choice: Partitions fit restrictions on the same claim (locked vs unlocked, Reg S vs 144A lots). Different claims, with different prices and loss positions, are easier to keep apart as separate token contracts.

What is an ERC-1400 partition?
A partition is a named sub-balance inside one ERC-1400 token: each holder's balance is split across bytes32 keys such as “senior” or “junior”, and tokens are fungible only within the same key.
ERC-1400 is an umbrella of security token interfaces; ERC-1410 is the part that defines partitions. Neither became a final standard. The ethereum/EIPs discussion issues were closed on 11 June 2022 (#1411) and 18 December 2021 (#1410), and the working text lives in the SecurityTokenStandard EIP-Spec repository, last changed on 15 March 2021. For where ERC-1400 sits next to ERC-3643 and other standards, see the RWA token standards guide.
Because the standard is a draft, behaviour depends on the implementation. This article reads one: the Consensys UniversalToken ERC1400.sol at commit 54320c6, the latest commit on the repository (23 January 2024). Line numbers below refer to that commit. Other ERC-1400 variants were not reviewed and may behave differently. No fork test was run; everything below is a code reading.
“Each token belongs to a class (sometimes also called category/partition/tranche). Inside a given class, all tokens are the same: they are fungible. But tokens from different classes can be distinguished from each other.”
Consensys UniversalToken README, commit 54320c6
The README uses “tranche” as a synonym for partition. In credit, a tranche is a different claim on the same pool: a senior note is paid first, a junior note absorbs losses first, and the two trade at different prices. The question is whether the token's interface keeps those claims apart.
What does balanceOf return for a holder of two tranches?
The sum. A holder with 1,000 senior units and 400 junior units has a balanceOf of 1,400, and totalSupply is one figure across every tranche in the contract.
This is a requirement of the draft, not a quirk of one codebase. The ERC-1410 text says balanceOf “MUST count the sum of all partition balances assigned to a token holder” and totalSupply “MUST count all tokens tracked by this contract.” The reference implementation follows it: totalSupply() returns _totalSupply and balanceOf() returns _balances[tokenHolder] (L215-225), both single numbers per contract.
The per-tranche figures exist, but only behind ERC-1400-specific calls: balanceOfByPartition (L356), partitionsOf (L364), totalPartitions (L693) and totalSupplyByPartition (L701-703). A wallet, explorer, custodian dashboard or collateral oracle that speaks ERC-20 calls none of them.
| ERC-20 field read by integrations | Value in a two-tranche ERC-1400 (reference code) | What it hides |
|---|---|---|
| balanceOf | Senior + junior, one number (L223-225) | The holder's position in the capital stack |
| totalSupply | All tranches combined (L215-217) | Size of each tranche and the subordination ratio |
| name / symbol | One name and ticker set in the constructor | Which note a unit belongs to |
| decimals | Always 18 (L679-681) | Any tranche-specific unit; divisibility is set by one granularity value |
| Transfer event | from, to, value; no partition field (L870) | Which tranche moved; explorers build one merged holder list |
The practical result is a valuation error. If an integration prices the token from one feed, it applies that price to senior and junior units alike. If the junior note is marked below the senior note, which is the usual case for a first-loss position, every holder of junior units is overstated and every holder of senior units is understated. The decimals row is a separate unit problem, covered in how token decimals can corrupt an RWA subscription amount.
What does a plain ERC-20 transfer do with two tranches?
It drains the default partitions in array order until the amount is filled. With defaults set to senior then junior, a 1,200-unit transfer from a holder with 1,000 senior and 400 junior sends 1,000 senior and 200 junior.
The ERC-1400 draft leaves default partitions as “an implementation detail.” In the reference code, the list is set in the constructor and changed by the contract owner with setDefaultPartitions (L774-776). transfer() (L232-235) and transferFrom() (L264-276) both call _transferByDefaultPartitions (L929-956), which loops through the list, moves whatever the sender holds in each partition, and stops when the amount is met. The recipient receives each slice in the same partition it left, and the contract emits one ERC-20 Transfer event per slice. redeem() uses the same loop for burns (L1278-1303).
- Both tranches are defaults: a holder or a DvP contract using ERC-20 calls cannot choose which tranche moves. The array order decides.
- Only senior is a default: ERC-20 transfers move senior units and revert with code “52” (insufficient balance) once the senior balance runs out. Junior units can move only through transferByPartition.
- The default list is empty: every ERC-20 transfer reverts with code “55” (L938). The token is then ERC-20 compatible in its read functions only.
Allowances split the same way. ERC-20 approve and allowance (L242-256) feed the default-partition loop, while approveByPartition and allowanceByPartition (L788-803) govern transfers out of a named partition. A settlement contract approved through ERC-20 can pull from default partitions only. To settle a junior trade, it needs a partition allowance and has to call operatorTransferByPartition.
Who can move value from the junior to the senior partition?
In the reference contract alone, the holder can. operatorTransferByPartition treats the holder as its own operator, and a transfer whose data starts with the 0xff flag lands in a different partition from the one it left.
The mechanism is in _transferByPartition (L883-919). The destination starts equal to the source. It changes only when operatorData is non-empty and data is at least 64 bytes; then _getDestinationPartition (L967-980) checks whether the first 32 bytes of data are all 0xff and, if so, reads the next 32 bytes as the destination. Its comment calls that value “the destination tranche.” The contract then emits ChangedPartition.
transferByPartition, the holder-facing call, passes empty operatorData, so it cannot change partitions. operatorTransferByPartition (L434-460) can. Its permission check, _isOperatorForPartition, falls back to _isOperator, which returns true when operator == tokenHolder (L1148). It also passes for an authorized operator, a controller while the token is controllable, and any spender within an approveByPartition allowance. So a junior holder can call it on its own address with junior as the source, the flag plus “senior” in data and any non-empty operatorData, and the reference contract will move the units into the senior partition and shift totalSupplyByPartition with them.
“By convention, a partition change is requested ONLY when 'data' starts with the flag: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff”
Consensys ERC1400.sol, comment on _getDestinationPartition, commit 54320c6
The only thing that can stop it is an extension. Before moving balances, the contract calls a validator registered through ERC-1820 (L903-904, L1091-1107). The reference ERC1400TokensValidator checks certificates, allowlist and blocklist, pause status, granularity and holds. Its certificate mode, when switched on, requires a certificate signed by the issuer's signer for each call by a non-signer, which would block a self-made reclassification. Its other checks do not look at the destination partition. An issuer that puts tranches in partitions should either run certificate validation or add a validator rule that rejects any partition change not made by a named controller, and should test it on a fork before issuance.
A reclassification between tranches is a corporate action. It should be rare, approved and logged, and it changes the subordination ratio for every other holder. In a separate-token design, the same action is a redemption on one contract and an issuance on another, and issuance is a minter-only call in the reference code (issueByPartition, L574-581), so a holder cannot complete it alone.
Do partitions encode the payment waterfall?
No. A partition is a bytes32 key with a balance; nothing in the reference ERC1400.sol ranks partitions, routes cash or allocates losses. The only order in the contract is the default-partition array used for ERC-20 transfers and redemptions.
The ERC-1410 draft says the metadata behind a partition key “does not form part of this standard,” and that the same key may carry different metadata for different holders. Seniority, coupon, maturity and loss priority therefore live in the note documents and in whatever process calculates distributions. That process reads balanceOfByPartition at a record date, or rebuilds positions from indexed TransferByPartition and ChangedPartition events, since the reference contract keeps no balance snapshots.
This is the same in every design. A token only answers “who holds which tranche, and how much.” Separate contracts answer that question through the standard ERC-20 interface; partitions answer it through ERC-1400 calls that fewer tools read. When the pool takes losses, the allocation runs off-chain and lands back on-chain as payments or write-downs, as described in what happens when tokenized private credit defaults.
One partitioned token, separate tokens, or both?
Separate contracts per tranche keep price, supply and holder lists distinct at the ERC-20 interface; one partitioned contract saves deployments but merges them. A hybrid uses one contract per tranche and keeps partitions for lot-level restrictions.
The table below is analysis of the three designs against the reference code, not a survey of live deals. No public dataset of tokenized credit products by token design was found, so this article makes no claim about which design the market prefers.
| Criterion | (a) One ERC-1400, one partition per tranche | (b) One permissioned token per tranche | (c) One ERC-1400 per tranche, partitions for lots |
|---|---|---|---|
| Price per token | One contract address, two prices; ERC-20 readers apply one | One price per contract | One price per contract |
| Supply reporting via ERC-20 | totalSupply combines tranches | totalSupply = tranche size | totalSupply = tranche size |
| Holder list per tranche | Needs an indexer reading TransferByPartition | Standard Transfer events per contract | Standard Transfer events per contract |
| Collateral or DvP eligibility | ERC-20 calls move default partitions only | Accept or reject each tranche by address | Accept or reject each tranche by address |
| Tranche reclassification | Partition change; needs a validator rule | Redeem on one contract, issue on the other; issuance is minter-only | Redeem on one contract, issue on the other; issuance is minter-only |
| Waterfall execution | Off-token in all designs | Off-token | Off-token |
| Deployment and upgrades | One contract to deploy, audit and migrate | One per tranche; one validator can serve several tokens, since the reference validator keys its settings by token address | One per tranche, plus partition logic in each |
Where tranche eligibility differs
Junior notes are often limited to a narrower set of investors than senior notes. With one contract per tranche, each contract carries its own transfer rules, so the junior token can require a stricter eligibility claim than the senior token while both point at the same identity registry. Holder lists, investor reports and transfer approvals then stay separate per tranche, and the vehicle-level register is the union of the two contracts. With partitions, the same split has to be written into validator logic keyed on the partition, which the reference validator does not do out of the box.
When does a single partitioned token still make sense?
When every partition is the same economic claim with a different restriction, such as locked and unlocked units, or Reg S and Rule 144A lots of one note. Then the ERC-20 sum is a correct number and only transferability differs.
The ERC-1410 draft's own examples point that way: vesting or lockup on part of a balance, restrictions attached to a share, and provenance tracking. In each case the units are worth the same, so adding them together in balanceOf misstates nothing. The default-partition list can then hold the “unrestricted” partition, which is the example the reference code gives in its comment on getDefaultPartitions (L760-768).
- Fits partitions: one note with lockup lots, jurisdiction lots or a pending-settlement state; one share class with vested and unvested units.
- Fits separate contracts: senior and junior notes, A and B share classes with different fees, or any two claims that a lender or custodian would price differently.
- Fits the hybrid: separate tranche contracts where each tranche also needs lot-level restrictions, such as a senior note sold under both Reg S and Rule 144A.
The decision has to be made before the first issuance. Moving a live tranche from a partition into its own contract means redeeming and reissuing every unit, updating every integration that holds the old address, and reconciling the register across both. This analysis applies to the Consensys reference implementation at commit 54320c6; a different ERC-1400 codebase may change default-partition handling, the partition-change flag or operator rules, so the same questions need to be checked against the contract actually deployed.
Frequently Asked Questions
Is ERC-1400 a final Ethereum standard?
No. ERC-1400 (ethereum/EIPs issue #1411, opened 13 September 2018) was closed on 11 June 2022, and ERC-1410 (issue #1410) was closed on 18 December 2021. Neither has a file in the ethereum/ERCs repository. The working specification is the SecurityTokenStandard EIP-Spec repository, last changed on 15 March 2021. Implementations can differ, so read the contract you deploy, not only the interface.
What does balanceOf return on an ERC-1400 token with partitions?
The sum of all partitions. The ERC-1410 draft says balanceOf MUST count the sum of all partition balances, and the Consensys reference implementation returns one stored figure, _balances[tokenHolder]. A holder with 1,000 senior units and 400 junior units shows 1,400 to any wallet, custodian screen or explorer that reads the ERC-20 interface. Only balanceOfByPartition separates them.
Can an ERC-20 transfer move junior tranche tokens by mistake?
Yes, if the junior partition is in the default list. In the Consensys reference implementation, transfer and transferFrom loop over the owner-set default partitions in order and drain each one until the amount is filled. With defaults set to senior then junior, a 1,200-unit transfer from a holder with 1,000 senior units moves 1,000 senior and 200 junior. Partitions not in the default list cannot move through ERC-20 calls at all.
Can a token holder move value from the junior to the senior partition?
In the Consensys reference contract on its own, yes. operatorTransferByPartition treats the holder as its own operator, and a non-empty operatorData plus a data field that starts with 32 bytes of 0xff and then the target partition changes the destination partition. Only a validator extension, such as certificate checks in the reference validator, stops it. Test this before issuance.
Do ERC-1400 partitions enforce a senior/junior payment waterfall?
No. Nothing in the reference ERC1400.sol ranks partitions by seniority or routes cash. A partition is a bytes32 label with a balance. The waterfall, loss allocation and coupon calculation live in the fund documents and in a separate distribution process that reads balanceOfByPartition or indexed TransferByPartition events. This holds whichever token design you choose.
Related Articles
Evolving RWA Token Standards: How Institutions Can Future-Proof Compliance
How institutions plan for changes in RWA token standards without migrating every issued token.
How Investment Managers Tokenize Private Credit Portfolios
The issuance side of a tokenized private credit vehicle, from structure to investor onboarding.
Who Really Controls an ERC-3643 Token's Agent Keys?
ERC-3643 agent keys can move or freeze holdings, yet the standard requires no multisig or timelock for them.
How Private Credit Fund Managers Tokenize Loan Portfolios
How GPs approach LP transfer restrictions, waterfall distributions and regulatory classification in a tokenized credit fund.