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

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.

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, 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:

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, 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:

// 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 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, 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}