
In DeFi, automated market makers (AMMs) and collateralized lending protocols have taught users to expect instant redemption: burn LP tokens or cTokens, and the underlying liquidity settles back into the wallet in the same block.
For tokenized real-world assets (RWA), such as private-credit funds, real-estate trusts, green bonds, or institutional commodities, the underlying physical assets lack instant on-chain liquidity. Property transfers require notarization and title registration; private funds must calculate monthly net asset value (NAV); bank transfers through wire, ACH, or SWIFT require T+1 to T+3 settlement.
If a team copies DeFi’s instant-redemption logic on-chain, or implements only a simple off-chain “request redemption” form, the production system can suffer a serious redemption double-spending vulnerability:
A compliant investor holding 10,000 commercial-property RWA tokens submits a redemption request for $100,000 in fiat. The platform begins manual compliance review and bank payment scheduling, which takes 24 hours. Throughout that window, the tokens remain unrestricted in the investor’s on-chain wallet. The investor sells all 10,000 tokens OTC to another unsuspecting compliant investor for full payment. The next day, finance authorizes payment and attempts to burn the original tokens, only to discover that the original holder has redeemed the underlying asset in fiat while the tokens representing ownership remain in secondary circulation on-chain.
To eliminate double-spend cash-outs and NAV front-running that exploits valuation timing differences, the production Aurum RWA system implements an asynchronous redemption workflow. This article examines EIP-712 redemption signatures, on-chain partial freezes (freezePartialTokens), epoch-anchored NAV snapshots, and the complete evidence trail for fiat bank settlement.
The Asynchronous Redemption State Machine: From On-Chain Lock to Fiat Reconciliation

In Aurum RWA’s full-stack architecture, redemption is a five-stage state machine spanning smart contracts, NestJS approval workflows, and the custodian bank:
+-----------------------------------------------------------------------------------+
| Aurum RWA Asynchronous Redemption Lifecycle |
+-----------------------------------------------------------------------------------+
| 1. Quote & EIP-712 Authorization |
| - Investor requests quote: tokenAmount -> lock current NAV estimate and fees |
| - Sign EIP-712 lockDigest: bind operationId, slotId, termsHash, deadline |
+-----------------------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------------------+
| 2. On-Chain Atomic Lock: LockState.LOCKED |
| - LOCK_OPERATOR submits transaction: AgentController.sol lockRedemption |
| - freezePartialTokens freezes wallet units and immediately reduces availability|
| - Stop resale: walletBalance - frozenTokens < q; OTC transfers 100% Revert |
+-----------------------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------------------+
| 3. Compliance Review & Dual-Approval |
| - Verify off-chain evidence: bank beneficiary must match investor KYC claims |
| - Two-Person Rule: requester and approver must be separate (no self-approval)|
| - State transition: REVIEWING -> APPROVED -> READY_TO_BURN |
+-----------------------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------------------+
| 4. Atomic Unfreeze and Burn: LockState.BURNED |
| - BURN_OPERATOR calls burnRedemption: unfreezePartialTokens + token.burn |
| - Strict before/after invariants: balanceOf and totalSupply decrease exactly q|
| - Terminal state: LockState.BURNED (irreversible; prevents duplicate burns) |
+-----------------------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------------------+
| 5. Fiat Settlement & Finality |
| - Custodian bank executes actual fiat wire or stablecoin transfer |
| - Submit bank reference and reconciliation evidence: rwa_settlement externalReference|
| - Independent audit approval marks COMPLETED and closes the lifecycle |
+-----------------------------------------------------------------------------------+
Why Use freezePartialTokens Instead of Transferring to Escrow?
In early RWA systems and DeFi variants, developers often prevent redemption double spending by using transferFrom to move the user’s tokens into a third-party custody contract, RedemptionEscrow.
In strictly regulated tokenized securities, however, this has two critical flaws:
- Distorting the holder’s legal identity: securities holders directly possess trust interests, dividend rights, and shareholder voting rights. A redemption request alone does not complete legal settlement. Transferring tokens to escrow records the contract as the on-chain holder, disrupting that month’s interest distributions and voting allocations;
- Unnecessary gas and compliance checks: transferring tokens to escrow is a full secondary-market transfer. The
ComplianceModulemust execute an expensive complete check, including escrow KYC, accredited-investor status, and country eligibility. Rule conflicts can easily reject legitimate redemptions.
The Solution: In-Place Partial Freezing
ERC-3643 and Aurum RWA use in-place partial freezing. Tokens remain legally registered to the investor’s own wallet, without a change in ownership. The contract ledger precisely reduces the transferable balance:
transferableBalance = balanceOf(investor) − frozenTokens[investor]
When the investor attempts a private OTC transfer, the underlying transfer function enforces the available-balance check:
// Excerpt from aurum-rwa/contracts/lib/trex/contracts/token/Token.sol
require(_amount <= balanceOf(msg.sender) - (_frozenTokens[msg.sender]), "Insufficient Balance");
If all 10,000 tokens are frozen, the available balance immediately falls to zero. Every OTC transfer must revert at the first check, eliminating the opportunity to cash out twice.
Core Contract: The AgentController.sol State Machine
In aurum-rwa/contracts/src/AgentController.sol, every redemption, lock, and burn must be initiated by a controlled operator with a strict role and bound to an immutable off-chain request hash.
1. Structures and Strict EIP-712 Signature Binding
To request redemption, investors use their hot or cold wallet’s private key to sign EIP-712 structured data containing the operation ID, slot ID, redemption quantity, legal terms hash, and expiry timestamp:
// Excerpt from aurum-rwa/contracts/src/AgentController.sol
enum LockState {
NONE, // Initial state
LOCKED, // Units frozen and locked
RELEASED, // Redemption cancelled; units unfrozen and returned
BURNED // Units destroyed on-chain
}
struct Request {
bytes32 operationId;
uint64 deadline;
address expectedWallet;
uint64 expectedSlotEpoch;
}
struct Slot {
address identity;
address currentWallet;
uint64 epoch;
uint256 redemptionTotal;
uint256 complianceTotal;
bool freezeCoverageComplete;
}
struct Redemption {
bytes32 slotId;
uint256 quantity;
bytes32 termsHash;
LockState state;
bytes32 lockOperationId;
}
function lockDigest(Request calldata r, bytes32 redemptionId, bytes32 slotId, uint256 q, bytes32 terms)
public
view
returns (bytes32)
{
return _hashTypedDataV4(
keccak256(
abi.encode(
LOCK_TYPEHASH,
r.operationId,
redemptionId,
slotId,
r.expectedWallet,
r.expectedSlotEpoch,
q,
terms,
r.deadline
)
)
);
}
2. The Redemption Lock Entry Point (lockRedemption)
After receiving an investor-signed request, the LOCK_OPERATOR calls the on-chain contract. The contract verifies the investor’s signature and calls freezePartialTokens to lock the units in place:
// Excerpt from aurum-rwa/contracts/src/AgentController.sol
function lockRedemption(
Request calldata r,
bytes32 redemptionId,
bytes32 slotId,
uint256 q,
bytes32 terms,
bytes calldata signature
) external role(LOCK_OPERATOR) nonReentrant {
_begin(r, 3);
Slot storage s = _slot(slotId, r);
// 1. Verify basic asset state
if (token.paused()) revert TokenPaused();
if (token.isFrozen(s.currentWallet)) revert WalletFrozen();
module.checkEligible(s.currentWallet);
_free(s, q); // Assert sufficient available balance
if (redemptionId == bytes32(0) || _redemptions[redemptionId].state != LockState.NONE) {
revert BusinessKeyAlreadyUsed();
}
if (terms == bytes32(0)) revert InvalidAmount();
// 2. Recover and verify the investor signature (prevent administrators from fabricating redemptions)
(address signer, ECDSA.RecoverError err) =
ECDSA.tryRecover(lockDigest(r, redemptionId, slotId, q, terms), signature);
if (signature.length != 65 || err != ECDSA.RecoverError.NoError || signer != s.currentWallet) {
revert InvalidInvestorSignature();
}
// 3. Record the locked order and update slot totals
_redemptions[redemptionId] = Redemption(slotId, q, terms, LockState.LOCKED, r.operationId);
s.redemptionTotal += q;
// 4. Execute the in-place partial freeze on-chain
token.freezePartialTokens(s.currentWallet, q);
_accounting(s);
emit RedemptionLocked(redemptionId, slotId, r.operationId, s.currentWallet, q, terms);
}
3. Controlled Unfreezing and Atomic Burning (burnRedemption)
Once off-chain compliance review passes and fiat payment is assured, the BURN_OPERATOR triggers the on-chain burn. The system first unfreezes the units, atomically calls token.burn, and verifies the exact decrease in balance and total supply:
// Excerpt from aurum-rwa/contracts/src/AgentController.sol
function burnRedemption(Request calldata r, bytes32 redemptionId, bytes32 approvalRef)
external
role(BURN_OPERATOR)
nonReentrant
{
_begin(r, 5);
if (approvalRef == bytes32(0)) revert InvalidAmount();
Redemption storage lock = _redemptions[redemptionId];
// Strictly require the order to be LOCKED
if (lock.state != LockState.LOCKED) revert LockNotActive();
Slot storage s = _slot(lock.slotId, r);
if (token.isFrozen(s.currentWallet)) revert WalletFrozen();
_accounting(s);
uint256 beforeBalance = token.balanceOf(s.currentWallet);
uint256 beforeSupply = token.totalSupply();
uint256 q = lock.quantity;
// Move the order to terminal BURNED state
lock.state = LockState.BURNED;
s.redemptionTotal -= q;
// Unfreeze and atomically destroy the tokens
_context = ExecutionContext(5, s.currentWallet, address(0), q, r.operationId);
token.unfreezePartialTokens(s.currentWallet, q);
token.burn(s.currentWallet, q);
delete _context;
_accounting(s);
// Strict conservation invariant: actual balance and total supply must decrease by exactly q
if (token.balanceOf(s.currentWallet) != beforeBalance - q || token.totalSupply() != beforeSupply - q) {
revert InvalidAmount();
}
emit RedemptionBurned(redemptionId, lock.slotId, r.operationId, s.currentWallet, q);
}
If a compliance officer rejects redemption, the system calls releaseRedemption to unfreeze the tokens and fully restore the investor’s available balance.
Preventing NAV Front-Running with Epoch Batches and Snapshot Settlement
RWA private-credit and property-fund NAVs are usually updated monthly or weekly—for example, publishing the previous month’s audited NAV on the first day of each month.
If investors can request redemption at any time and settle immediately at the displayed estimated NAV, sophisticated arbitrageurs can front-run NAV updates. On learning that a borrower is about to default on interest or a property is about to be marked down, they redeem on-chain at the old, higher valuation, shifting the loss to investors who remain.
Aurum RWA’s Epoch Batch Alignment
The business layer introduces an epoch snapshot mechanism to prevent this front-running:
- A common cut-off date: all redemption requests submitted during Epoch T have their units frozen on-chain immediately, but the final settlement price is not yet determined;
- Publish audited NAV after lockup: after the epoch cut-off, the fund’s accountants issue an audited snapshot of actual NAV;
- Batch reconciliation against the historical snapshot: the server calculates fiat payable from the officially published immutable NAV snapshot: SettlementAmount = RedeemedTokens × NAVEpoch − RedemptionFee
- Any request submitted just before the announcement must settle at the next epoch’s new NAV, closing the information-arbitrage opportunity through both policy and code.
Database Review and Audit: TypeORM DDL and the Evidence Trail
The backend separates on-chain lock facts, token-burn facts, and bank fiat-payment facts into independent entities stored in dedicated tables with version numbers and unique keys:
-- Excerpt from aurum-rwa/server/src/migrations/1900000006000-RedemptionSettlement.ts
-- 1. Core redemption order table
CREATE TABLE rwa_redemption (
id CHAR(36) PRIMARY KEY,
token_id CHAR(36) NOT NULL,
investor_id CHAR(36) NOT NULL,
requested_wallet_id CHAR(36) NOT NULL,
slot_id BINARY(32) NOT NULL,
token_amount BINARY(32) NOT NULL,
amount_snapshot JSON NOT NULL,
terms_hash BINARY(32) NOT NULL,
beneficiary_snapshot_encrypted LONGBLOB NOT NULL, -- Encrypted bank beneficiary details
status VARCHAR(32) NOT NULL DEFAULT 'REQUESTED',
lock_operation_id CHAR(36), -- Linked on-chain lock transaction
burn_operation_id CHAR(36), -- Linked on-chain burn transaction
burn_tx_hash BINARY(32), -- Actual on-chain burn transaction hash
completed_at DATETIME(6),
UNIQUE(organization_id, business_key),
CHECK(status IN (
'REQUESTED','LOCKING','LOCKED','REVIEWING','APPROVED',
'BURNING','BURN_CONFIRMED','SETTLEMENT_PENDING',
'SETTLEMENT_REVIEW','SETTLEMENT_FAILED','COMPLETED',
'UNLOCKING','CANCELLED','REJECTED','ACTION_REQUIRED'
))
);
-- 2. Off-chain fiat/stablecoin settlement evidence table
CREATE TABLE rwa_settlement (
id CHAR(36) PRIMARY KEY,
redemption_id CHAR(36) NOT NULL,
amount_minor DECIMAL(65,0) NOT NULL, -- Settlement amount in smallest currency units
currency CHAR(3) NOT NULL, -- USD / EUR / SGD
provider VARCHAR(16) NOT NULL, -- MANUAL / BANK_WIRE
status VARCHAR(16) NOT NULL DEFAULT 'PENDING',
external_reference VARCHAR(128), -- Actual bank wire reference (unique index)
evidence_refs JSON NOT NULL, -- Bank receipt document hashes
UNIQUE(organization_id, redemption_id),
UNIQUE(organization_id, provider, external_reference),
CHECK(status IN ('PENDING','REVIEW','CONFIRMED','FAILED'))
);
During settlement approval (aurum-rwa/server/src/modules/redemption/service.ts), the system enforces the two-person rule: the finance operator submitting the bank receipt and the compliance manager confirming reconciliation must be different users. The code explicitly blocks self-approval:
// Excerpt from aurum-rwa/server/src/modules/redemption/service.ts
check(String(ap.requester_id) !== a.id, 'SELF_APPROVAL_FORBIDDEN', 403);
Foundry Test-Suite Validation
In aurum-rwa/contracts/test/Core.t.sol, the system rigorously tests the full redemption-and-burn lifecycle and failure rollback.
1. Blocking Excess OTC Transfers After a Freeze
Scenario: Alice holds 100 tokens and locks 30 for redemption. She then attempts to transfer 71 to Bob. With only 70 available, transferring 71 must revert, while exactly 70 must succeed:
// Excerpt from aurum-rwa/contracts/test/Core.t.sol
function testEndToEndMintTransferRedemptionBurn() public {
_mint(alice, 100);
// Request redemption of 30 units and lock them on-chain
bytes32 order = _lock(alice, ALICE_KEY, 30);
_frozen(alice, 30); // Confirm 30 units are partially frozen
// Attempt to transfer 71 units, exceeding available balance; must revert
vm.expectRevert();
vm.prank(alice);
token.transfer(bob, 71);
// Transferring exactly the remaining 70 available units is valid
_transfer(alice, bob, 70);
_transfer(bob, alice, 70);
// Execute the on-chain burn
controller.burnRedemption(_req(alice), order, REF);
// Assert final burn result: Alice balance 70, total supply 100 -> 70, frozen count zero
require(token.balanceOf(alice) == 70 && token.totalSupply() == 70, "burn result");
require(controller.getRedemption(order).state == AgentController.LockState.BURNED, "completed");
_frozen(alice, 0);
}
2. Atomic State Rollback When Burning Fails
Scenario: a burn call reverts because of a token-contract fault or exhausted gas. The test requires the unfrozen tokens to become frozen again automatically and the order to remain LOCKED, preventing an accounting failure in which tokens are unlocked but not burned and the user can move them away:
// Excerpt from aurum-rwa/contracts/test/Core.t.sol
function testAtomicBurnRollbackAfterUnfreeze() public {
_mint(alice, 100);
bytes32 order = _lock(alice, ALICE_KEY, 30);
AgentController.Request memory r = _req(alice);
// Simulate a critical failure in the underlying token contract's burn function
vm.mockCallRevert(
address(token),
abi.encodeCall(token.burn, (alice, 30)),
abi.encodeWithSignature("Error(string)", "burn fault")
);
// Execute burn and assert that the entire transaction reverts
vm.expectRevert();
controller.burnRedemption(r, order, REF);
vm.clearMockedCalls();
// Check rollback: freeze remains, order stays LOCKED, and assets cannot escape
_frozen(alice, 30);
require(token.balanceOf(alice) == 100, "atomic balance");
require(controller.getRedemption(order).state == AgentController.LockState.LOCKED, "atomic order");
require(controller.operationState(r.operationId) == AgentController.OperationState.NONE, "atomic operation");
// Once the fault is removed, retrying the burn succeeds
controller.burnRedemption(r, order, REF);
}
Four Engineering Requirements for Production RWA Redemption
- Never schedule off-chain payment before locking tokens: freeze the on-chain units with
freezePartialTokensas soon as the investor submits the request, removing every opportunity for double spending during the waiting window; - Avoid distorting legal holder rights through escrow transfers: prefer in-place partial freezes so assets remain in the investor’s own wallet until settlement, avoiding confusion over the legal recipient of votes and dividends;
- Use epoch batch alignment to stop NAV front-running: structurally separate redemption-request submission from publication of actual NAV, preventing informed institutions from exiting just before a default;
- Enforce the two-person rule and unique bank references: forbid self-approval during off-chain reconciliation and add a database unique index on bank wire references (
external_reference) to prevent duplicate reimbursement and false reconciliation.
Enterprise RWA Tokenization and Compliance Delivery
Fone builds full-stack RWA tokenization systems meeting SEC / MAS / MiCA requirements for institutional property funds, supply-chain private-debt trusts, commodities, and gold. Our Aurum RWA solution has implemented a complete industrial-grade production lifecycle from investor due diligence and dynamic transfer compliance to asynchronous NAV redemption and automated bank reconciliation:
- Read the full-stack compliant asset portal architecture: Building a Compliant RWA Asset Portal with React, NestJS, and Foundry
- Read about secondary-transfer compliance controls: RWA Token Transfer Controls: Investor Eligibility and Jurisdiction Restrictions
- Explore ready-to-use multichain stablecoin collection and reconciliation: StableIn Payment Infrastructure
- Book a senior RWA architect for smart-contract auditing and custom solution assessment: Contact Fone Engineering