Can Two Investors Share a Vault Request ID?
An ERC-7540 request ID ledger key is the combination of fields an issuer or administrator uses to identify one investor's asynchronous vault request. The standard lets many requests share one requestId and tells vaults to tell them apart by requestId and controller together. A safe key adds chain, vault and direction, and keeps request events apart from the aggregated entitlement the vault reports.
TL;DR — Key Takeaways
- ✓Specified: ERC-7540 allows many requests to share one requestId. A request is identified by requestId and controller together, never by requestId alone.
- ✓Zero: When a vault returns requestId 0, it must aggregate each controller's Pending and Claimable amounts, so per-request detail exists only in your own records.
- ✓Key: Use chain, vault, direction, controller and requestId as the entitlement key, and keep submission events in a separate lot table.
- ✓Record three layers apart: what the interface specifies, what the deployed vault does and what the fund terms say about allocation.

Can two investors hold the same requestId?
Yes. ERC-7540, a Final standard created in October 2023, says multiple requests may have the same requestId, so a request is identified by requestId and controller together. A ledger keyed on requestId alone merges different investors.
The requestId is the value that requestDeposit or requestRedeem returns. Nothing in the specification makes it a global counter. A vault can number requests one by one, assign one ID per settlement batch, or return 0 for everything. The design is deliberate: the rationale section says pairing an ID with an address lets NFT-like or batch-like request handling be built at an external layer without bloating the core interface.
Shared nonzero IDs come with a hard rule. Requests with the same requestId must be fungible with each other. They must move from Pending to Claimable at the same time and receive the same exchange rate between assets and shares. If one becomes partially claimable, all requests with that ID must become claimable at the same pro-rata rate. Requests with different IDs carry no such link and may settle at different times and prices. Which event fixes that price for a redemption is a separate vault choice, set out in how a pending ERC-7540 redemption is priced. The ERC-7540 settlement lifecycle for tokenized funds covers the Pending, Claimable and Claimed states this rule applies to.
“Multiple requests may have the same requestId, so a given Request is discriminated by both the requestId and the controller.”
ERC-7540 specification, Request Ids
Why is controller, not owner, the ledger key?
ERC-7540 defines the controller as the owner of the Request: the address that manages it and claims the assets or shares. All four pending and claimable views take controller as input, so entitlement must be booked to the controller.
One request can involve four different addresses. The sender calls requestDeposit or requestRedeem. The owner supplies the assets or shares. The controller holds the right to claim. The receiver gets the output when the claim runs. The DepositRequest and RedeemRequest events index controller, owner and requestId, and carry sender as a plain field. On the claim side, the specification requires the first parameter of the Deposit event to be the controller and the second the receiver.
| Address | Role in ERC-7540 | Ledger use |
|---|---|---|
| sender | Caller of the request function; may differ from owner | Audit field: who initiated |
| owner | Source of the assets or shares taken at request time | Funding source, not entitlement holder |
| controller | Owner of the Request; claims or appoints operators to claim | Part of the entitlement key |
| receiver | Address named at claim time to receive shares or assets | Delivery field on the Claimed record |
A ledger that books by owner breaks the first time a custodian funds a request on behalf of a client controller, or a transfer agent sets itself as owner for operational reasons. The vault will report the entitlement under the controller, and the two records will not match. Operators add one more layer: an approved operator may claim for a controller, which is why operator revocation on pending fund claims needs the controller identified first.
What changes when the vault returns requestId 0?
With requestId 0, the vault must track state by controller alone and aggregate all of that controller's Pending and Claimable amounts. A vault that returns 0 once must return 0 for every request, so per-request detail leaves the vault entirely.
The fungibility rule for shared IDs does not apply here. The specification exempts requestId 0 from it, and its rationale notes that such vaults suit ERC-4626 claim methods because no ID-level discrimination exists. The reference implementation in the specification takes this route: it sets requestId to 0 and adds each deposit to pendingDepositRequest for the controller.
For reconciliation, this means the vault answers one question per controller and direction: how much is pending and how much is claimable in total. It cannot say which of two requests filled first. The only per-request trace is the DepositRequest or RedeemRequest event, identified by transaction hash and log index. The issuer's ledger has to hold those lots and apply an allocation rule when the aggregate moves.
“When requestId==0, the Vault MUST use purely the controller to discriminate the request state. The Pending and Claimable state of multiple requests from the same controller would be aggregated.”
ERC-7540 specification, Request Ids
How do the numbers reconcile in a worked example?
In an illustrative batch, two investors share requestId 41 and a 50% fill gives each half of the request. Under requestId 0, one investor with two requests sees a single total, and the lot split depends on a rule the standard does not set.
Case one, shared nonzero ID. Assume, for illustration only, that controller A requests a deposit of 600,000 assets and controller B requests 400,000, and the vault assigns both requestId 41. The administrator fills half the batch. Because the requests share an ID, both must become claimable at the same pro-rata rate: claimableDepositRequest(41, A) reads 300,000 and claimableDepositRequest(41, B) reads 200,000, with the same amounts still pending. At an assumed price of 1.25 assets per share, A can claim 240,000 shares and B 160,000. A ledger keyed on requestId 41 alone would show one row of 500,000 claimable and no way to say whose it is.
Case two, requestId 0. Controller C submits 250,000 on day 1 and 350,000 on day 3. pendingDepositRequest(0, C) reads 600,000. The vault then moves 300,000 to Claimable. The view shows 300,000 claimable and 300,000 pending, and nothing else.
| Lot (controller C) | Requested | Filled under first-in, first-out | Filled under pro-rata |
|---|---|---|---|
| Day 1 request | 250,000 | 250,000 | 125,000 |
| Day 3 request | 350,000 | 50,000 | 175,000 |
| Vault view | 600,000 | 300,000 | 300,000 |
Both splits match the vault. They differ by 125,000 on each lot, which matters if the fund terms tie a dealing date, a fee or a cancellation right to the individual request. ERC-7540 does not choose between them. The allocation rule belongs to the offering documents and the administrator's procedures, and the ledger must name it.
Two lots of 250,000 and 350,000 under requestId 0, with 300,000 made claimable, can be split 250,000 and 50,000 or 125,000 and 175,000. The vault view is identical in both cases.
ERC-7540 Request Ids and view methods; illustrative editorial calculation
What composite key should the ledger use?
Use five fields for entitlement: chain ID, vault address, direction, controller and requestId. Keep submission events in a separate lot table keyed by chain ID, transaction hash and log index, and link each lot to its entitlement row.
Each field closes a specific gap. The specification does not say that deposit and redeem IDs come from separate number spaces, so direction must be part of the key. Pending and claimable views are separate per direction: pendingDepositRequest and pendingRedeemRequest are different functions. Vault address matters because ERC-7540 vaults must implement ERC-7575, which allows several vault entry points, one per asset, to share one share token. Keying on the share token would merge requests made through different entry points. Chain ID guards against the same vault address existing on more than one network.
The two tables answer different questions. The lot table is append-only and records what was asked: sender, owner, controller, requestId and amount from each request event. The entitlement table mirrors what the vault reports through its views, read on a schedule, because no event marks the move to Claimable. Reconciliation compares the sum of open lots for a key with the pending plus claimable amounts the vault returns for that key.
What should an operational acceptance test cover?
Before go-live, the ledger should pass six cases: shared nonzero IDs, a partial fill, owner different from controller, a requestId 0 vault, one controller across two entry points, and an operator claim. Each has a pass condition the vault views can confirm.
| Case | Pass condition | Layer it tests |
|---|---|---|
| Two controllers, one nonzero requestId | Two entitlement rows; each matches its own view | Specified interface |
| Partial fill of a shared ID | Same pro-rata rate on every row with that ID | Specified interface |
| Owner differs from controller | Entitlement booked to controller; owner kept as funding source | Specified interface |
| requestId 0, two lots from one controller | Lot sum equals view total; named allocation rule applied | Product terms |
| One controller, two entry points sharing a share token | Separate rows by vault address | Implementation behavior |
| Claim by an approved operator | Claim matched by the controller parameter, receiver recorded | Specified interface |
These are proposed acceptance criteria, not findings about a named deployment. The third column matters when something goes wrong. The interface sets the key and the fungibility rule. The deployed vault decides how IDs are assigned and when requests become claimable. The fund terms decide allocation, cut-offs and cancellation. The RWA investor reporting and disclosure requirements assume the issuer can explain each investor's position; with a correct key, the issuer, custodian and administrator records can show why a given investor received a given amount on a given date, not only a transaction hash.
Sources: ERC-7540 specification (Request Ids, controller definition, view methods, DepositRequest and RedeemRequest events, Deposit event parameters, no event for Claimable state, reference implementation); ERC-7575 specification (multi-asset vaults sharing one share token). Sources checked October 30, 2026. Numerical scenarios, allocation rules and acceptance procedures are editorial analysis, not reports of live fund incidents.
Frequently Asked Questions
Is an ERC-7540 requestId unique to one investor?
No. The specification says multiple requests may have the same requestId, so a request is discriminated by both the requestId and the controller. A vault can give one ID to every request in a settlement batch. Requests that share a nonzero ID must become claimable at the same time and at the same exchange rate, and a partial fill must apply the same pro-rata rate to all of them.
Why key a ledger on controller instead of owner?
ERC-7540 defines the controller as the owner of the Request, the address that can manage it and claim the assets or shares. The owner field is only the address whose assets or shares were taken at request time. The pending and claimable views take controller as input, so a ledger keyed on owner cannot be reconciled against vault state when the two addresses differ.
What does requestId 0 mean for reconciliation?
A vault that returns 0 must track request state by controller alone and aggregate the Pending and Claimable amounts of all that controller's requests. If it returns 0 for any request, it must return 0 for all of them. The views then show one total per controller, so the ledger must keep each request lot itself and apply a documented rule to allocate partial fills.
Does the vault emit an event when a shared requestId is fulfilled?
No event is required. ERC-7540 mandates DepositRequest and RedeemRequest events at submission, and claims run through ERC-4626 deposit, mint, redeem and withdraw methods with their events. The move from Pending to Claimable happens at the implementation level, and the specification calls a required event impractical. A ledger confirms fulfillment by reading the claimable views for each controller and requestId pair.
Related Articles
Why Did a Claimable Vault Exit Produce No New Event?
ERC-7540 claimable state polling is the indexer practice of reading a vault's claimable request views on a bounded schedule, because the standard does not require any event when a request moves from Pending to Claimable. An exit can become claimable with no log at all, so an event-only indexer keeps showing it as pending.
How Do You Detect Which Vault Flows Are Asynchronous?
ERC-7540 interface detection identifies whether a vault advertises asynchronous deposits, asynchronous redemptions or both. These capabilities require different transaction paths and preview handling. An integration should detect each direction independently, then validate the behavior it will use instead of assigning every vault a single synchronous or asynchronous label.