# What Objects Can Be Tokenized on the 3DPass Blockchain? A Complete Guide to 3DPRC-2 Categories

> Discover what objects you can tokenize on the 3DPass blockchain. Explore 3DPRC-2 categories including 3D models, 2D drawings, music, biometrics, movements, and texts.

- Repository: [3Dpass/3dp](https://github.com/3dpass/3dp)
- Tags: tutorial
- Published: 2026-02-23

---

**The 3DPass blockchain supports seven distinct object categories for tokenization under the 3DPRC-2 standard: 3D objects, 2D drawings, music, biometrics, movements, and texts.**

The 3DPass network operates as "The Ledger of Things," implementing the **3DPRC-2** tokenization standard to convert real-world assets into on-chain representations. Through the **PoScan** (Proof-of-Scan) consensus module, objects from specific categories undergo authentication before becoming eligible for native or property-backed tokenization.

## The Seven Tokenizable Object Categories in 3DPRC-2

The 3DPass source code defines a fixed enumeration of object types that the PoScan pallet can process. Each category maps to a specific variant in the `ObjectCategory` enum located in [`primitives/consensus/poscan/src/lib.rs`](https://github.com/3dpass/3dp/blob/main/primitives/consensus/poscan/src/lib.rs).

### Objects3D: Full-Dimensional 3D Models

The **Objects3D** category handles complete three-dimensional models, typically submitted as `.obj` files or similar formats. When submitting an object of this type, the caller must specify the associated 3D algorithm—either low-resolution or high-resolution **Grid2D**—used for the object's geometric hash generation.

In the Rust source, this appears as `ObjectCategory::Objects3D(Algo3D)`, where `Algo3D` specifies the Grid2D resolution variant.

### Drawings2D: Flat 2D Sketches

**Drawings2D** accommodates two-dimensional sketches, drawings, or any flat graphical representations. This category uses the variant `ObjectCategory::Drawings2D` and enables artists to tokenize digital illustrations or scanned artwork through the same PoScan verification process applied to 3D objects.

### Music: Audio and Compositions

The **Music** category, defined as `ObjectCategory::Music`, supports audio recordings and musical compositions. This allows musicians and sound designers to submit waveform data or structured audio files for blockchain authentication and subsequent tokenization as unique digital assets.

### Biometrics: Fingerprint and Iris Data

**Biometrics** handles sensitive biological identification data such as fingerprints, iris scans, or other unique physiological markers. Represented by `ObjectCategory::Biometrics`, this category enables high-security use cases where physical identity attributes require immutable on-chain verification.

### Movements: Motion Capture and Gestures

The **Movements** category captures motion data, gesture recognition sequences, or full motion-capture recordings. Using `ObjectCategory::Movements`, this supports applications in animation, sports analytics, and virtual reality where kinetic data represents valuable intellectual property.

### Texts: Documents and Literary Works

Finally, **Texts** accommodates plain-text documents, literary works, or structured written content. Defined as `ObjectCategory::Texts`, this category completes the spectrum of tokenizable assets, allowing writers and publishers to authenticate manuscripts or critical documents on the 3DPass ledger.

## How Object Categories Are Defined in the 3DPass Source Code

The canonical definition of these categories resides in the consensus primitives. In [`primitives/consensus/poscan/src/lib.rs`](https://github.com/3dpass/3dp/blob/main/primitives/consensus/poscan/src/lib.rs), the `ObjectCategory` enum assigns each category a specific discriminant value that propagates through the runtime and into the Solidity precompile interface.

The enum definition follows this structure:

```rust
pub enum ObjectCategory {
    Objects3D(Algo3D),  // 0
    Drawings2D,         // 1
    Music,              // 2
    Biometrics,         // 3
    Movements,          // 4
    Texts,              // 5
}

```

These indices (0-5) map directly to the `uint8` values exposed in the Solidity precompile, ensuring consistent category identification across Rust and EVM environments.

## Tokenization Methods for Approved Objects

Once an object passes PoScan authentication and achieves **Approved** status, the 3DPass blockchain offers two distinct tokenization pathways, both governed by the `poscanAssets` pallet.

### Native Tokenization

**Native tokenization** creates a simple fungible token representing the entire object. This approach treats the authenticated asset as a single, indivisible unit of value on the ledger.

### Property-Backed Tokenization

**Property-backed tokenization** enables more granular financialization. The object's *properties*—such as share percentage, weight in grams, or area in square meters—serve as the basis for issuing specialized assets. According to the [`pallets/poscan-assets/README.md`](https://github.com/3dpass/3dp/blob/main/pallets/poscan-assets/README.md), only **one** property may be bound to an object at any given time, preventing double-tokenization of the same underlying asset.

The tokenization flow follows this sequence:

1. **Submit** the object via `poscan.putObject` with the appropriate `ObjectCategory` and optional `properties` vector containing `{ propIdx, maxValue }` pairs.
2. **Authenticate** the object through the PoW-based Proof-of-Scan consensus mechanism.
3. Upon **Approval**, issue assets via the `poscanAssets` pallet using either native or property-backed methods.

## Interacting with Object Categories via Solidity

For EVM developers, the 3DPass network exposes these categories through the **PoScan precompile** at address `0x0000000000000000000000000000000000000903`. The Solidity interface mirrors the Rust `ObjectCategory` enum, encoding categories as `uint8` values 0 through 5.

The precompile provides view functions for querying object details and their tokenizable properties:

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

interface IPoscan {
    struct PropertyInfo {
        bool isValid;
        uint32 propIdx;
        string name;
        uint8 class; // 0 = Relative, 1 = Absolute
        uint128 maxValue;
    }

    struct ObjectInfo {
        bool isValid;
        uint8 state;
        uint64 stateBlock;
        uint8 category; // 0 = Objects3D, 1 = Drawings2D, 2 = Music, etc.
        uint64 whenCreated;
        uint64 whenApproved;
        bool isPrivate;
        bytes32[] hashes;
        uint8 numApprovals;
        Property[] prop;
    }

    function getObject(uint32 objIdx) external view returns (ObjectInfo memory);
    function getProperties() external view returns (PropertyInfo[] memory);
}

contract ObjectInspector {
    IPoscan constant poscan = IPoscan(0x0000000000000000000000000000000000000903);

    function getCategoryName(uint32 objIdx) external view returns (string memory) {
        IPoscan.ObjectInfo memory obj = poscan.getObject(objIdx);
        require(obj.isValid, "Object does not exist");
        
        string[6] memory categories = [
            "Objects3D", 
            "Drawings2D", 
            "Music", 
            "Biometrics", 
            "Movements", 
            "Texts"
        ];
        return categories[obj.category];
    }
}

```

This interface allows smart contracts to verify an object's category before executing logic specific to 3D models, biometric data, or other asset types.

## Summary

The 3DPass blockchain supports seven distinct object categories for tokenization under the 3DPRC-2 standard:

- **Objects3D** – Full-dimensional 3D models with Grid2D algorithm selection
- **Drawings2D** – Flat 2D sketches and drawings  
- **Music** – Audio recordings and compositions
- **Biometrics** – Fingerprint, iris, and physiological identification data
- **Movements** – Motion capture and gesture data
- **Texts** – Plain-text documents and literary works

Each category is defined in [`primitives/consensus/poscan/src/lib.rs`](https://github.com/3dpass/3dp/blob/main/primitives/consensus/poscan/src/lib.rs) as a variant of the `ObjectCategory` enum, mapping to `uint8` values 0-5 in the Solidity precompile at `0x...0903`. Once authenticated through PoScan consensus, objects become eligible for native or property-backed tokenization via the `poscanAssets` pallet, with safeguards preventing double-tokenization of the same asset.

## Frequently Asked Questions

### What file formats are supported for 3D object tokenization?

The **Objects3D** category primarily accepts `.obj` files and similar full-dimensional 3D model formats. When submitting these objects through the `poscan.putObject` extrinsic, the caller must specify the Grid2D algorithm variant—either low-resolution or high-resolution—to ensure proper geometric hashing and PoScan authentication.

### Can I tokenize the same object multiple times on 3DPass?

No. The `poscanAssets` pallet explicitly prevents double-tokenization by allowing only **one** property to be bound to an object at any given time. As documented in [`pallets/poscan-assets/README.md`](https://github.com/3dpass/3dp/blob/main/pallets/poscan-assets/README.md), this constraint ensures that a single authenticated asset cannot simultaneously back multiple independent token issuances, maintaining the integrity of the property-backed tokenization model.

### How do Solidity smart contracts identify object categories?

Solidity contracts interact with the **PoScan precompile** at address `0x0000000000000000000000000000000000000903`, which exposes object categories as `uint8` values. The mapping follows the Rust enum order: `0` for Objects3D, `1` for Drawings2D, `2` for Music, `3` for Biometrics, `4` for Movements, and `5` for Texts. Developers can call `getObject(uint32 objIdx)` to retrieve the category and other metadata for any authenticated object on the ledger.