ERC-4626 — Tokenized Vault

Back to DeFi Building Blocks

ERC-4626: Tokenized Vault Standard

ERC-4626 standardises yield-bearing share tokens — a contract that holds a base ERC-20 asset and mints a share token to depositors. As the vault earns yield, each share is redeemable for an increasing amount of the underlying. Aave, Yearn, Sommelier, and most yield-bearing protocols implement this.

Required Interface (Highlights)

Method	Purpose
asset()	Underlying token
totalAssets()	TVL in underlying
convertToShares / convertToAssets	Pricing
deposit / mint	Add liquidity, receive shares
withdraw / redeem	Remove liquidity, burn shares

Inflation Attack

The famous ERC-4626 vulnerability: attacker deposits 1 wei, donates a large amount directly to the vault, then totalAssets is huge but totalSupply is 1. The next depositor gets 0 shares due to integer truncation. Mitigation: virtual offset (OpenZeppelin pattern) or seed dead shares at deployment.

Neo Equivalent

The Neo C# port uses NEP-17 for the share token + an asset reference. Crucially, it uses NEP-17's onNEP17Payment to auto-deposit when the user sends asset directly to the vault — no separate approve + deposit dance needed. Single transaction UX is built in.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash
Solidity (neo-solc)	NMKxbu3BoWHMqsehay8ybt4AX2Akbau7JF	0xfaf678fd…1f9f810f
Neo C# (nccs)	NdtwXkP4UYHoaEkfFavBat7fhNpMMaknX8	0x0e515ad2…647740c5

Verified: vault metadata (symbol, decimals), empty initial state. The C# port uses NEP-27's OnNEP17Payment for auto-deposit when the configured asset transfers in. docs/standards-mirror/deployments/erc-4626/.

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

import "./ERC20.sol";

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

contract ERC4626Vault is ERC20 {
    IERC20 public immutable asset;

    constructor(IERC20 asset_, string memory name_, string memory symbol_)
        ERC20(name_, symbol_)
    { asset = asset_; }

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

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

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

    function deposit(uint256 assets, address receiver) public returns (uint256 shares) {
        shares = convertToShares(assets);
        asset.transferFrom(msg.sender, address(this), assets);
        _mint(receiver, shares);
    }

    function withdraw(uint256 assets, address to, address from)
        public returns (uint256 shares)
    {
        shares = convertToShares(assets);
        if (from != msg.sender) {
            uint256 allowed = allowance[from][msg.sender];
            require(allowed >= shares, "vault: insufficient allowance");
            allowance[from][msg.sender] = allowed - shares;
        }
        _burn(from, shares);
        asset.transfer(to, assets);
    }
}

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("YieldVault")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep17, NepStandard.Nep27)]
public class YieldVault : SmartContract
{
    private const byte Prefix_TotalShares = 0x00;
    private const byte Prefix_Balance     = 0x01;
    private static readonly byte[] AssetKey = { 0xA0 };

    private const long DeadShares = 1_000;   // virtual offset for inflation-attack mitigation

    [DisplayName("Transfer")]
    public static event Action<UInt160, UInt160, BigInteger> OnTransfer;
    [DisplayName("Deposit")]
    public static event Action<UInt160, UInt160, BigInteger, BigInteger> OnDeposit;
    [DisplayName("Withdraw")]
    public static event Action<UInt160, UInt160, BigInteger, BigInteger> OnWithdraw;

    [Safe]
    public static string  Symbol()    => "vGAS";
    public static byte    Decimals()  => 8;
    [Safe]
    public static UInt160 Asset()     => (UInt160)Storage.Get(Storage.CurrentContext, AssetKey);

    public static BigInteger TotalShares()
        => (BigInteger)(Storage.Get(Storage.CurrentContext, new byte[] { Prefix_TotalShares }) ?? ByteString.Empty);

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

    public static BigInteger TotalAssets()
        => (BigInteger)Contract.Call(Asset(), "balanceOf", CallFlags.ReadOnly,
                                     new object[] { Runtime.ExecutingScriptHash });

    public static BigInteger ConvertToShares(BigInteger assets)
    {
        var supply = TotalShares() + DeadShares;
        var totAst = TotalAssets() + 1;
        return assets * supply / totAst;
    }

    public static BigInteger ConvertToAssets(BigInteger shares)
    {
        var supply = TotalShares() + DeadShares;
        var totAst = TotalAssets() + 1;
        return shares * totAst / supply;
    }

    /// <summary>Auto-deposit on incoming NEP-17 payment of the configured asset.</summary>
    public static void OnNEP17Payment(UInt160 from, BigInteger amount, object data)
    {
        if (!Runtime.CallingScriptHash.Equals(Asset()))
            throw new Exception("only accepts the configured asset");
        if (from == null) return;

        var shares = ConvertToShares(amount);
        if (shares == 0) throw new Exception("zero shares (try larger deposit)");
        Mint(from, shares);
        OnDeposit(from, from, amount, shares);
    }

    public static bool Withdraw(UInt160 from, UInt160 to, BigInteger shares)
    {
        if (!Runtime.CheckWitness(from)) throw new Exception("no authorization");
        var assets = ConvertToAssets(shares);
        Burn(from, shares);
        Contract.Call(Asset(), "transfer", CallFlags.All,
            new object[] { Runtime.ExecutingScriptHash, to, assets, "withdraw" });
        OnWithdraw(from, to, assets, shares);
        return true;
    }

    private static void Mint(UInt160 to, BigInteger amount)
    {
        var bal = BalanceOf(to) + amount;
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Balance }.Concat(to), bal);
        var supply = TotalShares() + amount;
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_TotalShares }, supply);
        OnTransfer(UInt160.Zero, to, amount);
    }

    private static void Burn(UInt160 from, BigInteger amount)
    {
        var bal = BalanceOf(from);
        if (bal < amount) throw new Exception("insufficient shares");
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Balance }.Concat(from), bal - amount);
        var supply = TotalShares() - amount;
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_TotalShares }, supply);
        OnTransfer(from, UInt160.Zero, amount);
    }

    public static void _deploy(object data, bool update)
    {
        if (update) return;
        Storage.Put(Storage.CurrentContext, AssetKey, (UInt160)data);
    }
}