ERC-7575 — Multi-Asset Vault

Back to DeFi Building Blocks

ERC-7575: Multi-Asset ERC-4626 Vaults

ERC-4626 assumes one underlying asset per vault. ERC-7575 generalises: a single share token can be backed by multiple assets, each with its own convert/deposit/withdraw overloads. Useful for stable-coin baskets, multi-asset yield aggregators, RWA fund-of-fund structures.

Required Interface (Sketch)

function asset(address share) external view returns (address);
function shareToken() external view returns (address);
function convertToShares(address asset, uint256 assets) external view returns (uint256);
function deposit(address asset, uint256 assets, address receiver)
    external returns (uint256 shares);

Neo Equivalent

The Neo C# port keeps the share NEP-17 contract and a separate vault contract that accepts multiple asset types via OnNEP17Payment. Each asset has its own exchange-rate oracle (or constant ratio for basket vaults).

Live on Neo TestNet

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

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

Cross-implementation invocations match on assetCount. Source pairs under docs/standards-mirror/deployments/erc-7575/.

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

interface IERC7575 {
    function asset(address share)         external view returns (address);
    function shareToken()                  external view returns (address);
    function convertToShares(address a, uint256 v) external view returns (uint256);
    function deposit(address a, uint256 v, address receiver)
        external returns (uint256 shares);
}

contract MultiAssetVault is IERC7575 {
    address public override shareToken;
    mapping(address => uint256) public ratePerAsset;   // share-per-asset ratio

    function asset(address) external view override returns (address) {
        revert("unused");
    }

    function convertToShares(address a, uint256 amount)
        public view override returns (uint256)
    {
        return amount * ratePerAsset[a] / 1e18;
    }

    function deposit(address a, uint256 amount, address receiver)
        external override returns (uint256 shares)
    {
        IERC20(a).transferFrom(msg.sender, address(this), amount);
        shares = convertToShares(a, amount);
        IShareToken(shareToken).mint(receiver, shares);
    }
}

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

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("MultiAssetVault")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep27)]
public class MultiAssetVault : SmartContract
{
    private const byte Prefix_RatePerAsset = 0x20;   // assetHash -> rate (BigInteger, 1e8 fixed)
    private static readonly byte[] ShareTokenKey = { 0xA0 };

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

    public static UInt160 ShareToken()
        => (UInt160)Storage.Get(Storage.CurrentContext, ShareTokenKey);

    public static BigInteger ConvertToShares(UInt160 asset, BigInteger amount)
    {
        var rate = (BigInteger)(Storage.Get(Storage.CurrentContext,
            new byte[] { Prefix_RatePerAsset }.Concat(asset)) ?? ByteString.Empty);
        if (rate == 0) throw new Exception("asset not accepted");
        return amount * rate / 100_000_000;
    }

    /// <summary>
    /// Auto-deposit on incoming NEP-17 payment of any whitelisted asset.
    /// Caller is the asset's NEP-17 contract; we look up its rate.
    /// </summary>
    public static void OnNEP17Payment(UInt160 from, BigInteger amount, object data)
    {
        var asset = Runtime.CallingScriptHash;
        var shares = ConvertToShares(asset, amount);
        if (shares == 0) throw new Exception("zero shares");

        // Mint share tokens to the depositor
        Contract.Call(ShareToken(), "mint", CallFlags.All,
                      new object[] { from, shares });
        OnDeposit(from, asset, amount, shares);
    }

    public static void SetAssetRate(UInt160 asset, BigInteger ratePerAsset_1e8)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("admin only");
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_RatePerAsset }.Concat(asset),
                    ratePerAsset_1e8);
    }

    private static UInt160 GetAdmin() => (UInt160)"0x0000000000000000000000000000000000000000";
}