ERC-7540 — Asynchronous Vaults

Back to DeFi Building Blocks

ERC-7540: Asynchronous ERC-4626 Vaults

ERC-4626 assumes deposits and withdrawals settle synchronously in the same call. But many real-world vaults — RWA tokenization, off-chain CeDeFi strategies, restaking protocols with unbond periods — require asynchronous flow: user requests deposit, operator processes it after some delay, user later claims their shares.

Mechanics

Phase	Methods
Request	requestDeposit(assets, controller, owner)
Process	(off-chain or admin call that fulfills pending requests)
Claim	deposit(assets, receiver, controller) (different overload from 4626 sync)

The controller address can be different from the owner — useful when a custodian manages requests on behalf of the depositor.

Neo Equivalent

The Neo port stores pending requests in a per-user mapping and exposes the same request-then-claim flow as the Solidity demo. Production vaults can add operator batching on top of this request ledger.

Live on Neo TestNet

Both implementations are deployed on Neo N3 TestNet (network magic 894710606).

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0xd8838ba126e5a77727c673215782aec59f465b41	(reused — see 0xd8838ba126e5a77727c673215782aec59f465b41)
Neo C# (nccs)	0xc2137b33423fdda8ce5a240e7feec8db2c4b626e	(reused — see 0xc2137b33423fdda8ce5a240e7feec8db2c4b626e)

Checked-in snapshot matches on initial counts; the manifest now also exercises request recording, pending deposit amount, and claim count. Source pairs under docs/standards-mirror/deployments/erc-7540/.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IERC7540Vault {
    event DepositRequest(address indexed controller, address indexed owner,
                         uint256 indexed requestId, address sender, uint256 assets);

    function requestDeposit(uint256 assets, address controller, address owner)
        external returns (uint256 requestId);

    function pendingDepositRequest(uint256 requestId, address controller)
        external view returns (uint256 assets);

    function claimableDepositRequest(uint256 requestId, address controller)
        external view returns (uint256 assets);

    function deposit(uint256 assets, address receiver, address controller)
        external returns (uint256 shares);
}

contract AsyncVault {
    struct Request { uint256 pending; uint256 claimable; uint256 sharesClaimable; }

    mapping(address => Request)         public requests;
    mapping(address => uint256)         public balance;
    address public asset;
    address public operator;

    function requestDeposit(uint256 assets, address controller, address owner)
        external returns (uint256)
    {
        // pull assets from owner to vault
        IERC20(asset).transferFrom(owner, address(this), assets);
        requests[controller].pending += assets;
        return 0;   // simplified: single rolling request per controller
    }

    function processBatch(address[] calldata controllers, uint256 sharePerAsset)
        external
    {
        require(msg.sender == operator, "operator only");
        for (uint i; i < controllers.length; ++i) {
            address c = controllers[i];
            uint256 a = requests[c].pending;
            requests[c].pending = 0;
            requests[c].claimable += a;
            requests[c].sharesClaimable += a * sharePerAsset;
        }
    }

    function deposit(uint256 assets, address receiver, address controller)
        external returns (uint256 shares)
    {
        Request storage r = requests[controller];
        require(r.claimable >= assets, "insufficient claimable");
        shares = r.sharesClaimable * assets / r.claimable;
        r.claimable -= assets;
        r.sharesClaimable -= shares;
        balance[receiver] += shares;
    }
}

interface IERC20 { function transferFrom(address, address, uint256) external returns (bool); }

using System;
using System.ComponentModel;
using System.Numerics;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("AsyncVault")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep17, NepStandard.Nep27)]
public class AsyncVault : SmartContract
{
    private const byte Prefix_Pending   = 0x10;  // controller -> assets pending
    private const byte Prefix_Claimable = 0x11;  // controller -> assets claimable
    private const byte Prefix_Shares    = 0x12;  // controller -> shares claimable
    private const byte Prefix_ShareBal  = 0x13;  // owner -> share balance
    private static readonly byte[] AssetKey    = { 0xA0 };
    private static readonly byte[] OperatorKey = { 0xA1 };

    [DisplayName("DepositRequest")]
    public static event Action<UInt160, UInt160, BigInteger> OnDepositRequest;
    [DisplayName("DepositProcessed")]
    public static event Action<UInt160, BigInteger, BigInteger> OnDepositProcessed;

    /// <summary>Asset arrives via NEP-17 payment — credit to pending.</summary>
    public static void OnNEP17Payment(UInt160 from, BigInteger amount, object data)
    {
        var asset = (UInt160)Storage.Get(Storage.CurrentContext, AssetKey);
        if (!Runtime.CallingScriptHash.Equals(asset)) throw new Exception("wrong asset");
        if (from == null) return;

        // data is the controller (or null = use sender)
        var controller = data is UInt160 ctrl ? ctrl : from;
        var key = new byte[] { Prefix_Pending }.Concat(controller);
        var pending = (BigInteger)(Storage.Get(Storage.CurrentContext, key) ?? ByteString.Empty);
        Storage.Put(Storage.CurrentContext, key, pending + amount);
        OnDepositRequest(from, controller, amount);
    }

    public static BigInteger PendingDepositRequest(UInt160 controller)
        => (BigInteger)(Storage.Get(Storage.CurrentContext,
            new byte[] { Prefix_Pending }.Concat(controller)) ?? ByteString.Empty);

    public static BigInteger ClaimableDepositRequest(UInt160 controller)
        => (BigInteger)(Storage.Get(Storage.CurrentContext,
            new byte[] { Prefix_Claimable }.Concat(controller)) ?? ByteString.Empty);

    public static void ProcessBatch(UInt160[] controllers, BigInteger sharePerAsset)
    {
        var op = (UInt160)Storage.Get(Storage.CurrentContext, OperatorKey);
        if (!Runtime.CheckWitness(op)) throw new Exception("operator only");

        foreach (var c in controllers)
        {
            var pending = PendingDepositRequest(c);
            if (pending == 0) continue;

            Storage.Delete(Storage.CurrentContext,
                           new byte[] { Prefix_Pending }.Concat(c));

            var prevClaim = ClaimableDepositRequest(c);
            Storage.Put(Storage.CurrentContext,
                        new byte[] { Prefix_Claimable }.Concat(c),
                        prevClaim + pending);

            var prevShares = (BigInteger)(Storage.Get(Storage.CurrentContext,
                                          new byte[] { Prefix_Shares }.Concat(c))
                                          ?? ByteString.Empty);
            Storage.Put(Storage.CurrentContext,
                        new byte[] { Prefix_Shares }.Concat(c),
                        prevShares + pending * sharePerAsset);
            OnDepositProcessed(c, pending, pending * sharePerAsset);
        }
    }

    public static BigInteger Claim(UInt160 controller, UInt160 receiver, BigInteger assets)
    {
        if (!Runtime.CheckWitness(controller)) throw new Exception("controller only");
        var claimable = ClaimableDepositRequest(controller);
        if (claimable < assets) throw new Exception("insufficient claimable");

        var shareBal = (BigInteger)(Storage.Get(Storage.CurrentContext,
                       new byte[] { Prefix_Shares }.Concat(controller)) ?? ByteString.Empty);
        var shares   = shareBal * assets / claimable;

        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Claimable }.Concat(controller),
                    claimable - assets);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Shares }.Concat(controller),
                    shareBal - shares);

        var recvBal = (BigInteger)(Storage.Get(Storage.CurrentContext,
                      new byte[] { Prefix_ShareBal }.Concat(receiver)) ?? ByteString.Empty);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_ShareBal }.Concat(receiver),
                    recvBal + shares);
        return shares;
    }
}