Blockchain · 12 March 2019

TriveAsset — Tokenizing Assets on Trivechain

by Tan Ji Sheng

An archival field note — documenting work from that era, written up for the record later.

We built TriveAsset — TA for short — to put real, tradable assets directly onto Trivechain, the Layer-1 I was lead developer of. Not a separate smart-contract platform, not a sidechain — a token layer riding on Trivechain's own transactions: a tiny "dust" output that is the ownership, and an on-chain data payload that carries the asset's rules. Fungible or non-fungible, the idea was the same — represent something real as something you can hold, transfer, and verify on our chain.

The mechanism, plainly

Trivechain is a UTXO chain — your balance is just the set of outputs you can spend — and TriveAsset piggybacks on that.

To issue an asset, you broadcast a transaction carrying two things:

  • A minimal dust output — the smallest spendable amount, sent to an address. That output is the asset. Whoever can spend it owns the asset; you transfer ownership by spending the dust to a new address.
  • A data payload carrying the asset's open data — what it is, how many units, divisible or not, and whether this operation issues, transfers, or burns.

The chain itself has no idea any of this means "an asset." Trivechain sees an ordinary transaction moving dust around. The meaning lives in a wallet or indexer that walks the chain, finds the TriveAsset transactions, reads each payload, follows the dust as it's spent, and reconstructs who owns what. The blockchain stores the events; the indexer computes the state.

That's the whole trick: on-chain data, off-chain interpretation.

A TriveAsset test transaction on the Trivechain block explorer — its metadata reads "The TriveAsset Test (TAT) is used to ensure that the asset is issued correctly."

The honest tradeoff: clunkier than an ERC-20

If you've only worked with account-based tokens, the UTXO approach feels like fighting the tool. That feeling is correct, and I won't pretend otherwise.

An ERC-20 lives in one smart contract with a clean global balance table the chain enforces natively — you ask the contract and it tells you the truth. TriveAsset had no native state. There's no balance table on-chain; you reconstruct it by replaying every relevant transaction through an indexer. Which means:

  • You depend on off-chain indexers. Two indexers with slightly different rules can disagree about a balance, and the chain won't referee — it doesn't know the asset exists.
  • You fight the dust limit. Every ownership record is a live output you keep funded above dust. Assets bloat the UTXO set, and you're doing dust-level accounting just to hold a token.
  • You fight payload size. On-chain data slots are small — enough for a tag or a hash, not rich metadata. You encode tightly, or you point to something off-chain.
  • You pay a fee on everything. Every mint, transfer, and burn is a full transaction with real fees, whether the asset is worth a lot or nothing.

None of that is fatal. All of it is friction. I'm not going to claim the UX rivalled an account-based token — it didn't. What it did do was work, on infrastructure we ran end to end.

Where it ended up

TriveAsset wasn't a demo that sat on a shelf. It became the tokenization layer underneath TriveCredential — our system for recording verifiable certificates on Trivechain. When we issued blockchain certificates for real events in late 2019, including the IIUM KICT Postgraduate Colloquium, TriveAsset was the machinery underneath: an asset — here, a credential — encoded on-chain, owned by a recipient, verifiable by anyone from the block explorer.

Trivechain's live block explorer — four TriveAssets issued on-chain, on a network of 122 masternodes.

What building it taught me

Encoding assets on a UTXO chain wasn't an idea I invented; representing ownership through spendable outputs was floating around the ecosystem well before us. What I did was build and ship a working version of it, end to end, on a live Layer-1, at a time when almost nobody in our region had operated this class of system. The honest, still-interesting claim is the narrow one: I learned the shape of on-chain tokenization — indexer consensus, dust management, payload limits, fee overhead — by hitting every one of those rocks myself. That's not a victory lap. It's tuition, and it's exactly why I can see those tradeoffs coming now.