ERC-3475 — Abstract Storage Bonds

Back to DeFi Building Blocks

ERC-3475: Abstract Storage Bonds

ERC-3475 is the foundational standard for on-chain bond instruments: multi-class (different bond series), multi-nonce (different issuance batches per class), with arbitrary metadata per (class, nonce) pair. Each bond instance encodes redemption terms, principal, interest, and arbitrary issuer metadata. Used as the backing for tokenised debt products, structured notes, and the credit half of the RWA stack.

The two-dimensional indexing — (classId, nonceId) — lets a single contract issue multiple bond series, each with multiple maturity batches, without deploying a new contract per issuance.

Required Interface (abridged)

interface IERC3475 {
    struct Values {
        uint256 uintValue;
        string  stringValue;
        address addressValue;
        bool    boolValue;
    }
    struct Metadata {
        string title;
        string _type;     // "uint256" | "string" | "address" | "bool"
        string description;
    }
    struct Transaction {
        uint256 classId;
        uint256 nonceId;
        uint256 amount;
    }

    event Issue(address indexed to, address indexed operator, Transaction[] transactions);
    event Redeem(address indexed from, address indexed operator, Transaction[] transactions);
    event Transfer(address indexed operator, address indexed from, address indexed to, Transaction[] transactions);

    function issue(address to, Transaction[] calldata transactions) external;
    function redeem(address from, Transaction[] calldata transactions) external;
    function transferFrom(address from, address to, Transaction[] calldata transactions) external;

    function balanceOf(address account, uint256 classId, uint256 nonceId) external view returns (uint256);
    function totalSupply(uint256 classId, uint256 nonceId) external view returns (uint256);
    function classMetadata(uint256 metadataId)               external view returns (Metadata memory);
    function nonceMetadata(uint256 classId, uint256 metadataId) external view returns (Metadata memory);
    function classValues(uint256 classId, uint256 metadataId)             external view returns (Values memory);
    function nonceValues(uint256 classId, uint256 nonceId, uint256 metadataId) external view returns (Values memory);
}

The metadata is descriptive (issued in classMetadata/nonceMetadata) and the values are the actual data per class / nonce. Off-chain tools use metadata to render bonds with the issuer's chosen field names ("Coupon Rate", "Maturity Date", "Issuer Country", etc.).

Neo Equivalent: Neo C# Port

Neo doesn't have a native NEP for multi-class bonds; the port is a straightforward storage-prefix design. Each (classId, nonceId) is a namespaced storage prefix; balances, supply, and value rows live under sub-prefixes.

ERC-3475 Component	Neo Equivalent	Notes
Transaction[] batch ops (issue/redeem/transfer)	Same shape, but with NEP-style witness checks at the entry point	Witness covers the operator
balanceOf(account, classId, nonceId)	BalanceOf(account, classId, nonceId) view	Direct port
classMetadata / nonceMetadata	Neo C# Map<int, Metadata> per class / per (class, nonce)	Descriptive metadata stored once
classValues / nonceValues	Map<int, object> storing the actual bond data	Sealed at issuance for nonceValues; mutable by issuer for classValues
Approval / operator path	Witness-scope-based authorization (sender or approved operator)	Native Neo affordance
Issue / Redeem / Transfer events	Named NEP-style notifications

Composition

• ERC-7092 — financial bonds (broader, simpler shape). Mirror together: ERC-3475 for the storage primitive, ERC-7092 for the business-facing surface.
• ERC-3643 — T-REX regulated token. Bonds for regulated investors gate Transfer on T-REX-style identity + compliance checks.
• ERC-7540 + ERC-7944 — async vault. Bond redemption may use the async-vault request/cancel pattern when liquidity is delayed.

Migration Notes

For Solidity bond protocols porting to Neo, the abstract two-dimensional indexing maps cleanly to Neo's storage prefixes; the metadata system is verbose but mostly inert (issued at deploy/config time and rarely mutated). The interesting work is in the issuer / compliance integration which is application-specific.

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

contract ERC3475 {
    struct Values {
        uint256 uintValue;
        string  stringValue;
        address addressValue;
        bool    boolValue;
    }
    struct Metadata {
        string title;
        string _type;
        string description;
    }
    struct Transaction {
        uint256 classId;
        uint256 nonceId;
        uint256 amount;
    }

    event Issue(address indexed to, address indexed operator, Transaction[] transactions);
    event Redeem(address indexed from, address indexed operator, Transaction[] transactions);
    event TransferEv(address indexed operator, address indexed from, address indexed to, Transaction[] transactions);

    mapping(uint256 => mapping(uint256 => mapping(address => uint256))) public balanceOf;  // class → nonce → owner → amount
    mapping(uint256 => mapping(uint256 => uint256))                     public totalSupply;  // class → nonce → total

    address public issuer;
    modifier onlyIssuer() { require(msg.sender == issuer, "issuer only"); _; }

    constructor() { issuer = msg.sender; }

    function issue(address to, Transaction[] calldata transactions) external onlyIssuer {
        for (uint256 i = 0; i < transactions.length; ++i) {
            balanceOf[transactions[i].classId][transactions[i].nonceId][to] += transactions[i].amount;
            totalSupply[transactions[i].classId][transactions[i].nonceId]   += transactions[i].amount;
        }
        emit Issue(to, msg.sender, transactions);
    }

    function redeem(address from, Transaction[] calldata transactions) external onlyIssuer {
        for (uint256 i = 0; i < transactions.length; ++i) {
            balanceOf[transactions[i].classId][transactions[i].nonceId][from] -= transactions[i].amount;
            totalSupply[transactions[i].classId][transactions[i].nonceId]     -= transactions[i].amount;
        }
        emit Redeem(from, msg.sender, transactions);
    }

    function transferFrom(address from, address to, Transaction[] calldata transactions) external {
        require(msg.sender == from, "no auth");
        for (uint256 i = 0; i < transactions.length; ++i) {
            balanceOf[transactions[i].classId][transactions[i].nonceId][from] -= transactions[i].amount;
            balanceOf[transactions[i].classId][transactions[i].nonceId][to]   += transactions[i].amount;
        }
        emit TransferEv(msg.sender, from, to, transactions);
    }
}

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;

public class BondTransaction
{
    public BigInteger ClassId;
    public BigInteger NonceId;
    public BigInteger Amount;
}

[DisplayName("ERC3475Bonds")]
[ContractPermission("*", "*")]
public class ERC3475Bonds : SmartContract
{
    private const byte Prefix_Balance      = 0x10;
    private const byte Prefix_TotalSupply  = 0x11;
    private const byte Prefix_ClassMeta    = 0x20;
    private const byte Prefix_NonceMeta    = 0x21;
    private const byte Prefix_ClassValues  = 0x22;
    private const byte Prefix_NonceValues  = 0x23;
    private const byte Prefix_Issuer       = 0xff;

    [DisplayName("Issue")]
    public static event Action<UInt160, UInt160, BondTransaction[]> OnIssue;
    [DisplayName("Redeem")]
    public static event Action<UInt160, UInt160, BondTransaction[]> OnRedeem;
    [DisplayName("Transfer")]
    public static event Action<UInt160, UInt160, UInt160, BondTransaction[]> OnTransfer;

    [DisplayName("_deploy")]
    public static void Deploy(object data, bool update)
    {
        if (update) return;
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Issuer }, (UInt160)data);
    }

    private static UInt160 Issuer()
        => (UInt160)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_Issuer });

    public static void Issue(UInt160 to, BondTransaction[] transactions)
    {
        if (!Runtime.CheckWitness(Issuer())) throw new Exception("BOND:NotIssuer");
        var ctx = Storage.CurrentContext;
        for (var i = 0; i < transactions.Length; i++)
        {
            var t = transactions[i];
            var bk = BalanceKey(t.ClassId, t.NonceId, to);
            var sk = SupplyKey(t.ClassId, t.NonceId);
            Storage.Put(ctx, bk, GetU(ctx, bk) + t.Amount);
            Storage.Put(ctx, sk, GetU(ctx, sk) + t.Amount);
        }
        OnIssue(to, Runtime.CallingScriptHash, transactions);
    }

    public static void Redeem(UInt160 from, BondTransaction[] transactions)
    {
        if (!Runtime.CheckWitness(Issuer())) throw new Exception("BOND:NotIssuer");
        var ctx = Storage.CurrentContext;
        for (var i = 0; i < transactions.Length; i++)
        {
            var t = transactions[i];
            var bk = BalanceKey(t.ClassId, t.NonceId, from);
            var sk = SupplyKey(t.ClassId, t.NonceId);
            var prev = GetU(ctx, bk);
            if (prev < t.Amount) throw new Exception("BOND:Insufficient");
            Storage.Put(ctx, bk, prev - t.Amount);
            Storage.Put(ctx, sk, GetU(ctx, sk) - t.Amount);
        }
        OnRedeem(from, Runtime.CallingScriptHash, transactions);
    }

    public static void Transfer(UInt160 from, UInt160 to, BondTransaction[] transactions)
    {
        if (!Runtime.CheckWitness(from)) throw new Exception("BOND:NoAuth");
        var ctx = Storage.CurrentContext;
        for (var i = 0; i < transactions.Length; i++)
        {
            var t = transactions[i];
            var fk = BalanceKey(t.ClassId, t.NonceId, from);
            var tk = BalanceKey(t.ClassId, t.NonceId, to);
            var prev = GetU(ctx, fk);
            if (prev < t.Amount) throw new Exception("BOND:Insufficient");
            Storage.Put(ctx, fk, prev - t.Amount);
            Storage.Put(ctx, tk, GetU(ctx, tk) + t.Amount);
        }
        OnTransfer(Runtime.CallingScriptHash, from, to, transactions);
    }

    public static BigInteger BalanceOf(UInt160 account, BigInteger classId, BigInteger nonceId)
        => GetU(Storage.CurrentContext, BalanceKey(classId, nonceId, account));

    public static BigInteger TotalSupply(BigInteger classId, BigInteger nonceId)
        => GetU(Storage.CurrentContext, SupplyKey(classId, nonceId));

    private static byte[] BalanceKey(BigInteger c, BigInteger n, UInt160 a)
        => new byte[] { Prefix_Balance }
            .Concat((ByteString)(byte[])c.ToByteArray())
            .Concat((ByteString)(byte[])n.ToByteArray())
            .Concat(a);

    private static byte[] SupplyKey(BigInteger c, BigInteger n)
        => new byte[] { Prefix_TotalSupply }
            .Concat((ByteString)(byte[])c.ToByteArray())
            .Concat((ByteString)(byte[])n.ToByteArray());

    private static BigInteger GetU(StorageContext ctx, byte[] key)
        => (BigInteger)(Storage.Get(ctx, key) ?? ByteString.Empty);
}

Issuer Workflow

1. Deploy ERC3475Bonds with the issuer address (typically a multisig or governance contract).
2. Configure classMetadata / classValues for each bond series via issuer-only setter methods.
3. For each issuance batch, call Issue(to, [{classId, nonceId, amount}, …]) to mint bonds to investors.
4. On maturity, call Redeem(from, [{classId, nonceId, amount}, …]) to burn the bonds; pair with off-chain or on-chain coupon-/principal- payment flows.