ERC-7535 — Native Asset Tokenized Vault

Back to DeFi Building Blocks

ERC-7535: Native Asset ERC-4626 Vault

ERC-7535 specialises ERC-4626 for vaults that hold the native asset (ETH on Ethereum) rather than an ERC-20. It standardises how deposit() / mint() / withdraw() / redeem() accept and return ETH (via payable and call{value:}) and how the vault reports its underlying asset using the ERC-7528 sentinel (0xEEEE…EEEE). The motivation is simple: thousands of vaults already exist for stETH, USDC, etc., but a uniform pattern for "wrap ETH into a yield-bearing token" was missing. Lido wstETH, Aave aWETH, Yearn yETH all predate this standard with bespoke shapes; ERC-7535 converges them.

Required Interface (delta from ERC-4626)

// Same shape as ERC-4626, but `asset()` returns the native sentinel
// and value-bearing methods are `payable`.

function asset() external view returns (address);  // returns 0xEEEE…EEEE

function deposit(uint256 assets, address receiver) external payable returns (uint256 shares);
function mint(uint256 shares, address receiver)    external payable returns (uint256 assets);
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
function redeem(uint256 shares, address receiver, address owner)   external returns (uint256 assets);

The vault validates msg.value == assets (or the equivalent for mint) and uses receiver.call{value: amount}("") to send ETH back on redemption.

Neo Equivalent: NEP-17 Vault Bound to NEO or GAS

Neo's native assets (NEO and GAS) are NEP-17 contracts in their own right — they have well-known contract hashes and behave like any other NEP-17. A "native asset vault" on Neo is just an ERC-4626-style vault parameterised on the NEO or GAS contract hash. There's no special "payable / msg.value" path — the deposit flow is the standard NEP-17 transfer + OnNEP17Payment callback.

ERC-7535 (Ethereum)	Neo Equivalent	Notes
asset() == 0xEEEE…EEEE (sentinel)	Asset() returns NativeContract.GAS.Hash (or NEO.Hash)	Real contract hash, no sentinel needed
payable deposit(amount, receiver) + msg.value == amount check	Transfer from depositor → vault triggers OnNEP17Payment(from, amount, data) with data encoding the action	Standard NEP-17 callback path
payable mint(shares, receiver)	Same OnNEP17Payment path with data = encode("mint", shares, receiver)	Single entry-point handles both deposit and mint
withdraw(assets, receiver, owner) → receiver.call{value: amount}("")	Contract.Call(GAS, "transfer", [vault, receiver, amount, null])	Standard NEP-17 send
Witness model	Runtime.CheckWitness(owner) for the burn-and-pay flow	Native authorization

Why The ERC Doesn't Need a Separate Standard on Neo

Because NEO and GAS are first-class NEP-17 contracts, the gap that ERC-7535 fills on Ethereum (a uniform spec for "ETH vaults") doesn't exist on Neo — the same vault contract works for NEO, GAS, and any other NEP-17 token with no code paths swapped. The "native asset vault" is just an ERC-4626 vault with asset = NEO.Hash or asset = GAS.Hash.

The mirror page exists to make this concrete for migrating teams: any ERC-7535 vault you're porting becomes a single Solidity-on-Neo or C# vault contract with no native-vs-token branches.

Migration Notes

When porting an ERC-7535 vault to Neo:

1. Drop the ERC-7528 sentinel constant — replace with NativeContract.GAS.Hash or NativeContract.NEO.Hash.
2. Drop payable and msg.value checks — Neo doesn't have native-asset value forwarding. Deposits arrive via NEP-17 transfer → OnNEP17Payment callback.
3. Replace receiver.call{value:}("") with Contract.Call(GAS, "transfer", …).
4. Replace WETH9.deposit/withdraw wrap-unwrap if your vault uses WETH — not needed on Neo since GAS is itself a NEP-17.

The Neo port is shorter than the Ethereum source. The asset indirection that ERC-7535 standardises becomes a constructor argument, not a code path.

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

contract NativeVault {
    address public constant ETH_SENTINEL = 0xEEeeEEeeEEeeEEeeEEeeEEeeEEeeEEeeEEeeEEEE;

    string  public name = "Yield ETH";
    string  public symbol = "yETH";
    uint8   public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;

    event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
    event Withdraw(address indexed sender, address indexed receiver, address indexed owner,
                   uint256 assets, uint256 shares);

    function asset() external pure returns (address) { return ETH_SENTINEL; }

    function totalAssets() public view returns (uint256) { return address(this).balance; }

    function deposit(uint256 assets, address receiver) external payable returns (uint256 shares) {
        require(msg.value == assets, "value mismatch");
        shares = previewDeposit(assets);
        balanceOf[receiver] += shares;
        totalSupply         += shares;
        emit Deposit(msg.sender, receiver, assets, shares);
    }

    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets) {
        require(msg.sender == owner, "no auth");
        assets = previewRedeem(shares);
        balanceOf[owner] -= shares;
        totalSupply      -= shares;
        (bool ok, ) = receiver.call{value: assets}("");
        require(ok, "send failed");
        emit Withdraw(msg.sender, receiver, owner, assets, shares);
    }

    function previewDeposit(uint256 assets) public view returns (uint256) {
        return totalSupply == 0 ? assets : (assets * totalSupply) / totalAssets();
    }

    function previewRedeem(uint256 shares) public view returns (uint256) {
        return totalSupply == 0 ? 0 : (shares * totalAssets()) / totalSupply;
    }
}

When compiled with neo-solc, the payable keyword and msg.value checks are no-ops. Replace the deposit flow with NEP-17 OnNEP17Payment callback (see C# tab) and the redeem flow with an explicit Contract.Call(GAS, "transfer", …).

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("GasYieldVault")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep17)]
public class GasYieldVault : Nep17Token
{
    public override string Symbol  => "yGAS";
    public override byte   Decimals => 8;

    private const byte Prefix_TotalDeposited = 0x10;

    [Safe]
    public static UInt160 Asset() => GAS.Hash;

    public static BigInteger TotalAssets()
        => GAS.BalanceOf(Runtime.ExecutingScriptHash);

    [DisplayName("OnNEP17Payment")]
    public static void OnNEP17Payment(UInt160 from, BigInteger amount, object data)
    {
        if (Runtime.CallingScriptHash != GAS.Hash) throw new Exception("only GAS deposits");
        if (amount <= 0)                            throw new Exception("amount <= 0");

        // Mint shares proportional to existing pool. data can encode receiver
        // or be null (default to depositor).
        var receiver = data is null ? from : (UInt160)data;
        var totalShares = TotalSupply();
        var totalAssets = TotalAssets() - amount;  // exclude the deposit just received

        var shares = totalShares == 0 || totalAssets == 0
            ? amount
            : (amount * totalShares) / totalAssets;

        Mint(receiver, shares);
    }

    public static void Redeem(BigInteger shares, UInt160 receiver, UInt160 owner)
    {
        if (!Runtime.CheckWitness(owner)) throw new Exception("no auth");
        if (BalanceOf(owner) < shares)    throw new Exception("insufficient shares");

        var totalShares = TotalSupply();
        var assets = (shares * TotalAssets()) / totalShares;

        Burn(owner, shares);
        // Send GAS back to receiver.
        Contract.Call(GAS.Hash, "transfer", CallFlags.All,
            new object[] { Runtime.ExecutingScriptHash, receiver, assets, null });
    }
}

Why The Neo Code is Shorter

The Solidity reference branches between payable deposits and ERC-20 deposits in three places (deposit, mint, redeem). The Neo version has one entry-point — OnNEP17Payment — that handles every deposit shape, because GAS is just another NEP-17 contract. To support a NEO yield vault instead, change Asset() to NEO.Hash and the witness check on OnNEP17Payment to NEO.Hash — nothing else changes.