ERC-7092 — Financial Bonds

Back to DeFi Building Blocks

ERC-7092: Financial Bonds

ERC-7092 is the business-facing counterpart to ERC-3475. Where ERC-3475 abstracts arbitrary bond storage by class/nonce, ERC-7092 bakes in the most common bond fields (issue date, maturity date, coupon rate, currency, denomination, ISIN) and the operations issuers / investors expect (transfer, approve, principal/coupon claim). Better fit for "let me deploy a bond contract and start trading" workflows than ERC-3475's abstract storage.

Required Interface (abridged)

interface IERC7092 {
    struct IssueData {
        bytes32 isin;
        string  name;
        string  symbol;
        address currency;          // ERC-20 of the denomination currency
        uint256 denomination;
        uint256 issueVolume;
        uint256 couponRate;        // basis points
        uint256 issueDate;
        uint256 maturityDate;
    }

    function issue(IssueData calldata data, address[] calldata investors, uint256[] calldata amounts) external;
    function transfer(address to, uint256 amount, bytes calldata data) external;
    function approve(address spender, uint256 amount) external;
    function transferFrom(address from, address to, uint256 amount, bytes calldata data) external;

    function principalOf(address holder)         external view returns (uint256);
    function balanceOf(address holder)           external view returns (uint256);
    function isin()                              external view returns (bytes32);
    function name()                              external view returns (string memory);
    function symbol()                            external view returns (string memory);
    function currency()                          external view returns (address);
    function denomination()                      external view returns (uint256);
    function issueVolume()                       external view returns (uint256);
    function couponRate()                        external view returns (uint256);
    function issueDate()                         external view returns (uint256);
    function maturityDate()                      external view returns (uint256);

    event Issued(IssueData data, address[] investors, uint256[] amounts);
    event Transferred(address indexed from, address indexed to, uint256 amount, bytes data);
    event Redeemed(address indexed holder, uint256 amount);
}

The standard intentionally limits what's encoded on-chain — fields are the minimum set every bond needs. Coupon schedules, amortisation tables, and call/put options are out of scope (those go in extension contracts).

Neo Equivalent: Neo C# Port

The shape ports cleanly. Bond fields live in single-key storage slots (set at issuance, immutable thereafter); per-holder state lives in a balance/principal map. The denomination currency is a NEP-17 contract hash instead of an ERC-20 address; coupon claims are NEP-17 transfers back to holders.

ERC-7092 (Ethereum)	Neo Equivalent	Notes
IssueData struct	Map<string, object> stored at issuance, sealed	Bond identity and economic terms
currency (ERC-20)	currency (NEP-17 contract hash)	GAS, USDC port, or any NEP-17
issue(data, investors, amounts)	Issue(data, investors, amounts) issuer-only	Witness-checked issuer
transfer(to, amount, data)	Transfer(to, amount, data) with NEP-17-style holder witness	Includes data callback
transferFrom(from, to, ...)	TransferFrom(from, to, ...) if approval extension is used	Optional approval layer
Coupon/principal claim flows	Issuer-side PayCoupon / Redeem pushing NEP-17 transfers to holders	Application-specific scheduling
Issued / Transferred / Redeemed events	NEP notifications with same fields	Wire-format equivalent

Composition

• ERC-3475 — abstract storage bonds. Use 7092 as the business surface for a single bond series; use 3475 when a single contract issues many series.
• ERC-3643 — T-REX regulated token. Wrap 7092 with T-REX compliance for tokenised securities.
• ERC-7540 + ERC-7944 — async vault
  • cancel. Use for delayed-redemption bond repayment flows.

Migration Notes

The cleanest port from a Solidity ERC-7092 bond:

1. Replace the ERC-20 inheritance with NEP-17 base.
2. Encode IssueData as a Map<string, object> and store at deploy.
3. Mint principal balances per investor in the constructor / _deploy.
4. Replace block.timestamp with Runtime.Time (millisecond precision).
5. For coupon payments, schedule off-chain or wire a periodic PayCoupon method that the issuer calls each period.

The Neo port is shorter than the Solidity source because NEP-17's OnNEP17Payment callback handles the "data" parameter in transfers without an extra interface declaration.

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

contract ERC7092 {
    struct IssueData {
        bytes32 isin;
        string  name;
        string  symbol;
        address currency;
        uint256 denomination;
        uint256 issueVolume;
        uint256 couponRate;
        uint256 issueDate;
        uint256 maturityDate;
    }

    IssueData public data;
    address   public issuer;
    mapping(address => uint256) public principalOf;
    mapping(address => uint256) public balanceOf;

    event Issued(IssueData data, address[] investors, uint256[] amounts);
    event Transferred(address indexed from, address indexed to, uint256 amount, bytes data);
    event Redeemed(address indexed holder, uint256 amount);

    constructor() { issuer = msg.sender; }

    function issue(IssueData calldata d, address[] calldata investors, uint256[] calldata amounts) external {
        require(msg.sender == issuer, "issuer only");
        require(data.issueDate == 0,  "already issued");
        require(investors.length == amounts.length, "len mismatch");

        data = d;
        for (uint256 i = 0; i < investors.length; ++i) {
            principalOf[investors[i]] += amounts[i];
            balanceOf[investors[i]]   += amounts[i];
        }
        emit Issued(d, investors, amounts);
    }

    function transfer(address to, uint256 amount, bytes calldata _data) external {
        balanceOf[msg.sender] -= amount;
        balanceOf[to]         += amount;
        emit Transferred(msg.sender, to, amount, _data);
    }

    function redeem(address holder, uint256 amount) external {
        require(msg.sender == issuer,                 "issuer only");
        require(block.timestamp >= data.maturityDate, "not matured");
        balanceOf[holder]   -= amount;
        principalOf[holder] -= amount;
        // ... issuer-side currency transfer to holder for principal repayment ...
        emit Redeemed(holder, amount);
    }
}

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("FinancialBond")]
[ContractPermission("*", "*")]
public class FinancialBond : SmartContract
{
    private const byte Prefix_Issuer     = 0x01;
    private const byte Prefix_IssueData  = 0x02;
    private const byte Prefix_Balance    = 0x10;
    private const byte Prefix_Principal  = 0x11;

    [DisplayName("Issued")]
    public static event Action<Map<string, object>, UInt160[], BigInteger[]> OnIssued;
    [DisplayName("Transferred")]
    public static event Action<UInt160, UInt160, BigInteger, object> OnTransferred;
    [DisplayName("Redeemed")]
    public static event Action<UInt160, BigInteger> OnRedeemed;

    [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(Map<string, object> data, UInt160[] investors, BigInteger[] amounts)
    {
        if (!Runtime.CheckWitness(Issuer())) throw new Exception("BOND:NotIssuer");
        if (Storage.Get(Storage.CurrentContext, new byte[] { Prefix_IssueData }) is not null)
            throw new Exception("BOND:AlreadyIssued");
        if (investors.Length != amounts.Length) throw new Exception("BOND:LenMismatch");

        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_IssueData }, StdLib.Serialize(data));
        for (var i = 0; i < investors.Length; i++)
        {
            var bk = BalanceKey(investors[i]);
            var pk = PrincipalKey(investors[i]);
            Storage.Put(Storage.CurrentContext, bk, GetU(bk) + amounts[i]);
            Storage.Put(Storage.CurrentContext, pk, GetU(pk) + amounts[i]);
        }
        OnIssued(data, investors, amounts);
    }

    public static bool Transfer(UInt160 from, UInt160 to, BigInteger amount, object payload)
    {
        if (!Runtime.CheckWitness(from)) throw new Exception("BOND:NoAuth");
        var fk = BalanceKey(from);
        var prev = GetU(fk);
        if (prev < amount) return false;
        Storage.Put(Storage.CurrentContext, fk, prev - amount);
        var tk = BalanceKey(to);
        Storage.Put(Storage.CurrentContext, tk, GetU(tk) + amount);
        OnTransferred(from, to, amount, payload);
        return true;
    }

    public static void Redeem(UInt160 holder, BigInteger amount)
    {
        if (!Runtime.CheckWitness(Issuer())) throw new Exception("BOND:NotIssuer");
        var data = (Map<string, object>)StdLib.Deserialize((ByteString)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_IssueData }));
        if (Runtime.Time < (BigInteger)data["maturityDate"]) throw new Exception("BOND:NotMatured");

        var bk = BalanceKey(holder);
        var pk = PrincipalKey(holder);
        Storage.Put(Storage.CurrentContext, bk, GetU(bk) - amount);
        Storage.Put(Storage.CurrentContext, pk, GetU(pk) - amount);

        // Push currency back to holder as principal repayment.
        var currency = (UInt160)data["currency"];
        Contract.Call(currency, "transfer", CallFlags.All,
            new object[] { Runtime.ExecutingScriptHash, holder, amount, null });
        OnRedeemed(holder, amount);
    }

    [Safe]
    public static BigInteger BalanceOf(UInt160 holder)   => GetU(BalanceKey(holder));
    [Safe]
    public static BigInteger PrincipalOf(UInt160 holder) => GetU(PrincipalKey(holder));

    private static byte[] BalanceKey(UInt160 a)   => new byte[] { Prefix_Balance   }.Concat(a);
    private static byte[] PrincipalKey(UInt160 a) => new byte[] { Prefix_Principal }.Concat(a);
    private static BigInteger GetU(byte[] k)
        => (BigInteger)(Storage.Get(Storage.CurrentContext, k) ?? ByteString.Empty);
}

Coupon Payments

ERC-7092 doesn't standardise coupon scheduling — bond contracts add a PayCoupon issuer-only method that distributes accrued interest to all holders proportionally:

public static void PayCoupon()
{
    if (!Runtime.CheckWitness(Issuer())) throw new Exception("BOND:NotIssuer");
    var data = LoadIssueData();
    var totalSupply = (BigInteger)data["issueVolume"];
    var totalCoupon = (totalSupply * (BigInteger)data["couponRate"]) / 10000;  // bps

    var iter = Storage.Find(Storage.CurrentContext, new byte[] { Prefix_Balance }, FindOptions.RemovePrefix);
    while (iter.Next())
    {
        var holder  = (UInt160)((object[])iter.Value)[0];
        var balance = (BigInteger)((object[])iter.Value)[1];
        var share   = (totalCoupon * balance) / totalSupply;
        Contract.Call((UInt160)data["currency"], "transfer", CallFlags.All,
            new object[] { Runtime.ExecutingScriptHash, holder, share, null });
    }
}

For large holder bases this loop becomes too expensive in one tx; use a pull pattern instead — ClaimCoupon() per holder, accruing per-period share from a checkpoint table. Same shape as voting / staking reward distribution.