ERC-7944 — Async Cancellation for ERC-7540 Vaults

Back to DeFi Building Blocks

ERC-7944: Async Cancellation

ERC-7944 closes a known UX gap in ERC-7540 async vaults: once a user submits a deposit/withdraw request they may need to cancel it before the vault settles. Without cancellation, requests sit indefinitely, locking user funds in pending state. ERC-7944 standardises the cancel-request flow as a small interface delta on top of ERC-7540.

Required Interface (delta from ERC-7540)

interface IERC7944 {
    event CancelDepositRequest(uint256 indexed requestId, address indexed controller);
    event CancelRedeemRequest(uint256 indexed requestId, address indexed controller);

    function cancelDepositRequest(uint256 requestId, address controller) external;
    function cancelRedeemRequest(uint256 requestId, address controller) external;

    function pendingCancelDepositRequest(uint256 requestId, address controller)
        external view returns (uint256 cancelled);
    function pendingCancelRedeemRequest(uint256 requestId, address controller)
        external view returns (uint256 cancelled);
}

The vault validates that controller is the request owner (or approved), marks the request cancelled, and on the next settlement cycle returns the locked principal to the user instead of issuing shares. Cancellations may be immediate (synchronous refund) or queued (asynchronous like the original request); the spec permits both and exposes pendingCancel*Request so off-chain UIs can show "your cancel request is in flight".

Neo Equivalent: Cancel-by-id on the Request Queue

The ERC-7540 mirror's request/claim pattern stores per-request state in the vault's storage keyed by requestId. Adding cancel is one extra storage flag plus a settlement-side branch:

public static void CancelDepositRequest(BigInteger requestId, UInt160 controller)
{
    if (!Runtime.CheckWitness(controller)) throw new Exception("not controller");

    var key = DepositRequestKey(requestId);
    var req = (DepositRequest)Storage.Get(Storage.CurrentContext, key);
    if (req is null)             throw new Exception("no such request");
    if (req.Controller != controller) throw new Exception("not owner");
    if (req.Settled)             throw new Exception("already settled");
    if (req.Cancelled)           return;     // idempotent

    req.Cancelled = true;
    Storage.Put(Storage.CurrentContext, key, req);
    OnCancelDepositRequest(requestId, controller);
}

// The next settlement cycle reads req.Cancelled and refunds principal
// instead of issuing shares.

ERC-7944 (Ethereum)	Neo Equivalent	Notes
cancelDepositRequest(id, controller)	CancelDepositRequest(id, controller) with witness check	Same semantics
pendingCancelDepositRequest(id, controller)	PendingCancelDepositRequest(id, controller) view returning the cancelled amount	UI-facing helper
Settlement cycle returns principal on cancellation	Settlement cycle reads req.Cancelled and uses Contract.Call(asset, "transfer", …) to refund	Native NEP-17 transfer back
Approved-operator path (controller != msg.sender)	Witness-scope or approved-operator check on the vault	Flexible

Composition With Existing Mirror Pages

• ERC-7540 — base async vault. ERC-7944 is a strict superset; implement both for a complete async-vault offering.
• ERC-7575 — multi-asset vault. Cancellation extends per-asset since each sub-vault has its own request queue.
• ERC-3009 — meta-tx authorization. Cancel can be issued via a relayer using the same witness-scope flow.

Migration Notes

Existing ERC-7540 ports get this for free if the request struct already has room for a bool Cancelled flag. The settlement loop's existing "if pending then settle" branch becomes "if pending and not cancelled then settle, else refund principal". Two-line patch in most implementations.

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

contract AsyncVaultWithCancel {
    struct DepositRequest {
        address controller;
        uint256 assets;
        uint64  submittedAt;
        bool    settled;
        bool    cancelled;
    }

    mapping(uint256 => DepositRequest) public requests;

    event RequestDeposit(uint256 indexed requestId, address indexed controller, uint256 assets);
    event CancelDepositRequest(uint256 indexed requestId, address indexed controller);
    event Settled(uint256 indexed requestId, uint256 sharesOrRefund);

    function requestDeposit(uint256 assets, address controller, address /*owner*/)
        external returns (uint256 requestId)
    {
        requestId = ++_lastId;
        requests[requestId] = DepositRequest(controller, assets, uint64(block.timestamp), false, false);
        // ... pull `assets` of the underlying into the vault ...
        emit RequestDeposit(requestId, controller, assets);
    }

    function cancelDepositRequest(uint256 requestId, address controller) external {
        DepositRequest storage r = requests[requestId];
        require(r.controller == controller && msg.sender == controller, "not owner");
        require(!r.settled, "already settled");
        if (r.cancelled) return;
        r.cancelled = true;
        emit CancelDepositRequest(requestId, controller);
    }

    function settle(uint256 requestId) external {
        DepositRequest storage r = requests[requestId];
        require(!r.settled, "already settled");
        r.settled = true;
        if (r.cancelled) {
            // Refund principal.
            // ... transfer r.assets back to r.controller ...
            emit Settled(requestId, r.assets);
        } else {
            uint256 shares = _previewIssue(r.assets);
            // ... issue shares to r.controller ...
            emit Settled(requestId, shares);
        }
    }

    uint256 internal _lastId;
    function _previewIssue(uint256 assets) internal view returns (uint256) { return assets; /* simplified */ }
}

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("AsyncVaultWithCancel")]
[ContractPermission("*", "*")]
public class AsyncVaultWithCancel : SmartContract
{
    private const byte Prefix_Request = 0x10;
    private const byte Prefix_LastId  = 0x11;

    [DisplayName("RequestDeposit")]
    public static event Action<BigInteger, UInt160, BigInteger> OnRequestDeposit;

    [DisplayName("CancelDepositRequest")]
    public static event Action<BigInteger, UInt160> OnCancelDepositRequest;

    [DisplayName("Settled")]
    public static event Action<BigInteger, BigInteger> OnSettled;

    public static BigInteger RequestDeposit(BigInteger assets, UInt160 controller)
    {
        if (!Runtime.CheckWitness(controller)) throw new Exception("not controller");

        var ctx = Storage.CurrentContext;
        var lastKey = new byte[] { Prefix_LastId };
        var nextId  = (BigInteger)(Storage.Get(ctx, lastKey) ?? ByteString.Empty) + 1;
        Storage.Put(ctx, lastKey, nextId);

        var req = new Map<string, object>
        {
            ["controller"]  = controller,
            ["assets"]      = assets,
            ["submittedAt"] = Runtime.Time,
            ["settled"]     = false,
            ["cancelled"]   = false,
        };
        Storage.Put(ctx, RequestKey(nextId), StdLib.Serialize(req));

        // Pull principal from the user — assumes prior NEP-17 approval flow.
        OnRequestDeposit(nextId, controller, assets);
        return nextId;
    }

    public static void CancelDepositRequest(BigInteger requestId, UInt160 controller)
    {
        if (!Runtime.CheckWitness(controller)) throw new Exception("not controller");

        var ctx = Storage.CurrentContext;
        var req = (Map<string, object>)StdLib.Deserialize((ByteString)Storage.Get(ctx, RequestKey(requestId)));
        if (req is null)                            throw new Exception("no such request");
        if ((UInt160)req["controller"] != controller) throw new Exception("not owner");
        if ((bool)req["settled"])                   throw new Exception("already settled");
        if ((bool)req["cancelled"])                 return;  // idempotent

        req["cancelled"] = true;
        Storage.Put(ctx, RequestKey(requestId), StdLib.Serialize(req));
        OnCancelDepositRequest(requestId, controller);
    }

    public static BigInteger PendingCancelDepositRequest(BigInteger requestId, UInt160 controller)
    {
        var ctx = Storage.CurrentContext;
        var raw = Storage.Get(ctx, RequestKey(requestId));
        if (raw is null) return 0;
        var req = (Map<string, object>)StdLib.Deserialize((ByteString)raw);
        return ((UInt160)req["controller"] == controller && (bool)req["cancelled"] && !(bool)req["settled"])
            ? (BigInteger)req["assets"]
            : 0;
    }

    public static void Settle(BigInteger requestId)
    {
        var ctx = Storage.CurrentContext;
        var req = (Map<string, object>)StdLib.Deserialize((ByteString)Storage.Get(ctx, RequestKey(requestId)));
        if ((bool)req["settled"]) throw new Exception("already settled");

        req["settled"] = true;
        Storage.Put(ctx, RequestKey(requestId), StdLib.Serialize(req));

        if ((bool)req["cancelled"])
        {
            // Refund principal.
            // Contract.Call(asset, "transfer", CallFlags.All, …)
            OnSettled(requestId, (BigInteger)req["assets"]);
        }
        else
        {
            // Issue vault shares.
            // Contract.Call(shares, "transfer", CallFlags.All, …)
            OnSettled(requestId, (BigInteger)req["assets"]);  // simplified
        }
    }

    private static byte[] RequestKey(BigInteger id)
        => new byte[] { Prefix_Request }.Concat((ByteString)(byte[])id.ToByteArray());
}

Why Cancel Matters For Async Vaults

ERC-7540 made vaults that settle on a delay possible (RWA vaults, strategy vaults that need off-chain rebalancing). But "submit and wait" without "submit and back out" is unfriendly UX — users want to react to market moves between submit and settlement. ERC-7944 closes that gap without changing the request/claim shape.