Tokenized Securities as Spot Instruments

Article NautilusTrader

Summary

The document explains how a trading system can represent a tokenized asset that tracks an external security, such as a stock or fund traded on a crypto venue. It defines the instrument’s identity, currencies, asset classification, price and quantity precision, increments, timestamps, and optional trading constraints such as minimum quantities or notional values. An international securities identifier can be included when the token references a listed security.

The model treats the instrument as spot: it is not inverse, uses the quote currency for costs, and has no expiry, strike, activation time, or option type. Rust and Python construction examples illustrate the required metadata, and Kraken is named as a representative adapter. This is an implementation and data-model explanation, not a trading strategy or an analysis of tokenized assets’ returns, tracking quality, custody, liquidity, or legal risks. Traders should not infer that a token’s market price will always match its external reference from the schema alone.

Key ideas

A tokenized security can be modeled as a spot instrument whose economic reference is an external asset.
The instrument definition records venue symbols, asset class, currencies, precision, increments, and timestamps.
Optional fields can express order limits, margin rates, tick schemes, and adapter metadata.
The model can carry an international securities identifier when one is known.
The schema describes instrument representation but does not establish tracking quality or market risk.

Tags

Crypto Equities Spot markets Market microstructure

Full text

# Tokenized Asset


# Tokenized Asset

`TokenizedAsset` represents a spot-like token that tracks another asset on a crypto venue.
Use it for tokenized equities, tokenized funds, or similar instruments where the trading
venue exposes a token but the economic reference is an external asset.

Examples include tokenized stock or ETF symbols on crypto venues.

## Fields

| Field             | Rust type          | Python type        | Required/default | Notes                                    |
| ----------------- | ------------------ | ------------------ | ---------------- | ---------------------------------------- |
| `instrument_id`   | `InstrumentId`     | `InstrumentId`     | Required         | Stored as `id` in Rust.                  |
| `raw_symbol`      | `Symbol`           | `Symbol`           | Required         | Native venue symbol.                     |
| `asset_class`     | `AssetClass`       | `AssetClass`       | Required         | Economic asset classification.           |
| `base_currency`   | `Currency`         | `Currency`         | Required         | Tokenized asset or base token.           |
| `quote_currency`  | `Currency`         | `Currency`         | Required         | Currency used to price the token.        |
| `price_precision` | `u8`               | `int`              | Required         | Decimal places allowed for prices.       |
| `size_precision`  | `u8`               | `int`              | Required         | Decimal places allowed for order sizes.  |
| `price_increment` | `Price`            | `Price`            | Required         | Smallest valid price step.               |
| `size_increment`  | `Quantity`         | `Quantity`         | Required         | Smallest valid size step.                |
| `ts_event`        | `UnixNanos`        | `int`              | Required         | Event timestamp in nanoseconds.          |
| `ts_init`         | `UnixNanos`        | `int`              | Required         | Initialization timestamp in nanoseconds. |
| `isin`            | `Option<Ustr>`     | `str \| None`      | `None`           | International Securities ID when known.  |
| `multiplier`      | `Quantity`         | `Quantity`         | `1`              | Contract multiplier.                     |
| `lot_size`        | `Option<Quantity>` | `Quantity \| None` | `None`           | Rounded lot or board size.               |
| `max_quantity`    | `Option<Quantity>` | `Quantity \| None` | `None`           | Maximum order quantity.                  |
| `min_quantity`    | `Option<Quantity>` | `Quantity \| None` | `None`           | Minimum order quantity.                  |
| `max_notional`    | `Option<Money>`    | `Money \| None`    | `None`           | Maximum order notional value.            |
| `min_notional`    | `Option<Money>`    | `Money \| None`    | `None`           | Minimum order notional value.            |
| `max_price`       | `Option<Price>`    | `Price \| None`    | `None`           | Maximum valid quote or order price.      |
| `min_price`       | `Option<Price>`    | `Price \| None`    | `None`           | Minimum valid quote or order price.      |
| `margin_init`     | `Option<Decimal>`  | `Decimal \| None`  | `0`              | Initial margin rate.                     |
| `margin_maint`    | `Option<Decimal>`  | `Decimal \| None`  | `0`              | Maintenance margin rate.                 |
| `tick_scheme`     | `Option<Ustr>`     | `str \| None`      | `None`           | Registered variable tick scheme name.    |
| `info`            | `Option<Params>`   | `dict \| None`     | `None`           | Adapter metadata.                        |

*Note: Python constructors use `instrument_id`; Rust stores the same value as `id`.*

## Behavior

- `TokenizedAsset` has instrument class `Spot`.
- It is never inverse, and its cost currency is the quote currency.
- It can carry an `isin` when the token references a listed security.
- It has no activation timestamp, expiry, strike, or option kind.

## Example

```rust tab="Rust"
use nautilus_core::UnixNanos;
use nautilus_model::{
    enums::AssetClass,
    identifiers::{InstrumentId, Symbol},
    instruments::TokenizedAsset,
    types::{Currency, Price, Quantity},
};

let aaplx = TokenizedAsset::builder()
    .instrument_id(InstrumentId::from("AAPLx/USD.KRAKEN"))
    .raw_symbol(Symbol::from("AAPLxUSD"))
    .asset_class(AssetClass::Equity)
    .base_currency(Currency::get_or_create_crypto("AAPLx"))
    .quote_currency(Currency::from("USD"))
    .price_precision(2)
    .size_precision(4)
    .price_increment(Price::from("0.01"))
    .size_increment(Quantity::from("0.0001"))
    .min_quantity(Quantity::from("0.0001"))
    .ts_event(UnixNanos::default())
    .ts_init(UnixNanos::default())
    .build()
    .unwrap();
```

```python tab="Python"
from nautilus_trader.model import AssetClass
from nautilus_trader.model import Currency
from nautilus_trader.model import InstrumentId
from nautilus_trader.model import Price
from nautilus_trader.model import Quantity
from nautilus_trader.model import Symbol
from nautilus_trader.model import TokenizedAsset

aaplx = TokenizedAsset(
    instrument_id=InstrumentId.from_str("AAPLx/USD.KRAKEN"),
    raw_symbol=Symbol("AAPLxUSD"),
    asset_class=AssetClass.EQUITY,
    base_currency=Currency.from_str("AAPLx"),
    quote_currency=Currency.from_str("USD"),
    price_precision=2,
    size_precision=4,
    price_increment=Price.from_str("0.01"),
    size_increment=Quantity.from_str("0.0001"),
    ts_event=0,
    ts_init=0,
    min_quantity=Quantity.from_str("0.0001"),
)
```

## Adapters

Representative adapters that create or consume `TokenizedAsset` instruments include:

- [Kraken](../../integrations/kraken.md) for tokenized assets where the venue exposes them.

## Related guides

- [Currency Pair](currency_pair.md) covers ordinary crypto spot pairs.
- [Equity](equity.md) covers listed cash equities.

Shown in full with attribution under the source's licence. Licence: LGPL-3.0

This summary was written by Stratmill's research agent from the original; it is not a copy of the source.

Modeling Tokenized Securities as Spot Instruments

Summary

Key ideas

Tags