ERC-6239 — Semantic Soulbound Tokens

Back to Token Standards

ERC-6239: Semantic Soulbound Tokens

ERC-6239 layers RDF-style semantic triples (subject, predicate, object) on top of soulbound NFTs. Each soulbound credential carries machine-readable claims like (this NFT) (issued-by) (university X), (this NFT) (certifies) (skill Y), (this NFT) (expires-on) (date). Indexers, credential aggregators, and verification tools query the triples uniformly without per-issuer integration.

Used by:

• Education credentials — degrees / certificates with structured issuer, course, grade fields.
• Professional licences — bar admissions, medical licences with jurisdiction, scope, renewal-date fields.
• DAO membership badges — role, joined-at, contributions tagged with structured predicates.
• Vouching networks — (A) (vouches-for) (B) (in-context) (C).

Required Interface

interface IERC6239 {
    function rdfOf(uint256 tokenId) external view returns (string memory);
    function addClaim(uint256 tokenId, string calldata predicate, string calldata object) external;
}

The rdfOf returns a Turtle / N-Triples encoded string with all the claims for the token; addClaim (issuer-only) appends a new predicate→object pair. Pairs with ERC-5192 / ERC-5484 for the soulbound-transfer-restriction half.

Neo Equivalent: NEP-11 Soulbound + RDF Triple Storage

public static void AddClaim(ByteString tokenId, string predicate, string objectVal)
{
    if (!Runtime.CheckWitness(GetIssuer())) throw new Exception("NEP11:NotIssuer");
    var existing = GetClaims(tokenId);
    var triple = new Map<string, object> { ["p"] = predicate, ["o"] = objectVal };
    var updated = new object[existing.Length + 1];
    for (var i = 0; i < existing.Length; i++) updated[i] = existing[i];
    updated[existing.Length] = triple;
    Storage.Put(Storage.CurrentContext, ClaimsKey(tokenId), StdLib.Serialize(updated));
}

public static string RdfOf(ByteString tokenId)
{
    var claims = GetClaims(tokenId);
    var sb = "<urn:nep11:" + Runtime.ExecutingScriptHash.ToString() + ":" + tokenId + ">";
    for (var i = 0; i < claims.Length; i++)
    {
        var t = (Map<string, object>)claims[i];
        sb = sb + " <" + (string)t["p"] + "> \"" + (string)t["o"] + "\" .";
    }
    return sb;
}

ERC-6239 (Ethereum)	Neo Equivalent	Notes
rdfOf(tokenId)	RdfOf(tokenId) returning Turtle string	Direct port
addClaim(tokenId, predicate, object)	AddClaim(...) issuer-witness-checked
Append-only claims	Storage append (no remove)	Credentials don't unmake
Subject = urn:erc6239:contract:tokenId	urn:nep11:contract:tokenId	Stable URI

Composition

• ERC-5192 — soulbound base. ERC-6239 adds the metadata layer.
• ERC-5484 — consensual soulbound with BurnAuth.
• ERC-5375 — author + consent. Triples can encode the issuer and consent details.
• ERC-7053 — media indexing. Combine: indexers consume both the soulbound flag and the RDF claims uniformly.

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

contract ERC6239 {
    struct Triple { string predicate; string object; }
    mapping(uint256 => Triple[]) internal _claims;

    function addClaim(uint256 tokenId, string calldata predicate, string calldata object_) external {
        // ... issuer check ...
        _claims[tokenId].push(Triple(predicate, object_));
    }

    function rdfOf(uint256 tokenId) external view returns (string memory) {
        // Turtle-encode all claims; implementation-specific.
        return "";
    }
}

using System;
using System.ComponentModel;
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("SemanticSBT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class SemanticSBT : Nep11Token<TokenState>
{
    public override string Symbol => "SSBT";

    private const byte Prefix_Claims = 0xA0;
    private const byte Prefix_Issuer = 0xff;

    public static void AddClaim(ByteString tokenId, string predicate, string objectVal)
    {
        var issuer = (UInt160)Storage.Get(Storage.CurrentContext, new byte[] { Prefix_Issuer });
        if (!Runtime.CheckWitness(issuer)) throw new Exception("NEP11:NotIssuer");
        var existing = GetClaims(tokenId);
        var updated = new object[existing.Length + 1];
        for (var i = 0; i < existing.Length; i++) updated[i] = existing[i];
        updated[existing.Length] = new object[] { predicate, objectVal };
        Storage.Put(Storage.CurrentContext, ClaimsKey(tokenId), StdLib.Serialize(updated));
    }

    public static object[] GetClaims(ByteString tokenId)
    {
        var raw = Storage.Get(Storage.CurrentContext, ClaimsKey(tokenId));
        return raw is null ? new object[0] : (object[])StdLib.Deserialize((ByteString)raw);
    }

    // Block transfers — soulbound. Nep11Token<T> has no virtual hook, so we
    // redefine Transfer with `public new static` to short-circuit transfers.
    public new static bool Transfer(UInt160 to, ByteString tokenId, object data = null)
    {
        // For soulbound: refuse all transfers from non-null holders.
        // (Mint paths use base.Mint(tokenId, new TokenState{...}) which doesn't go through Transfer.)
        var currentOwner = OwnerOf(tokenId);
        if (currentOwner is not null && currentOwner != UInt160.Zero)
            throw new Exception("NEP11:Soulbound");
        return Nep11Token<TokenState>.Transfer(to, tokenId, data);
    }

    private static byte[] ClaimsKey(ByteString tokenId) => new byte[] { Prefix_Claims }.Concat(tokenId);
}