Design Example 1
Andrea
Design Example 2
Bryan
✨ Dynamic ART20 NFT Standard built on Sui

Empowering Liquidity, Shareability, and Tradability for RWAs

Create, sale, trade on the MOVE-based RWA protocol.

No Code Dashboard

Collection Analytics Dashboard

Track supply, metadata changes, and transfer activities in real-time. Monitor your collection's performance with comprehensive analytics and insights.

Collection Analytics Dashboard

Balance Management Interface

Monitor token balances and cleanup operations across collections. Streamline your portfolio management with intuitive controls and real-time updates.

Balance Management Interface

Access Control Center

Manage deny lists and permissions with enterprise-grade controls. Set up role-based access and maintain security across your digital assets.

Access Control Center

Batch Operations Console

Execute and monitor bulk transfers and metadata updates. Efficiently manage large-scale operations with automated validation and error handling.

Batch Operations Console

Metadata Management Hub

Update and synchronize metadata across your collections. Maintain consistency and enrich your assets with dynamic attribute management.

Metadata Management Hub

Transaction Monitoring Center

Track all collection activities in real-time. Monitor transfers, updates, and user interactions through an intuitive dashboard interface.

Transaction Monitoring Center

ART20 Protocol

Protocol as a Service (PaaS)

Artinals is redefining the way creators, builders, institutions, and brands engage with Web3. Our cutting-edge PaaS solution empowers seamless blockchain integration with unmatched scalability and flexibility.

struct CollectionCap has key, store {
    id: UID,
    max_supply: u64,
    creator: address,
    name: String,
    is_mutable: bool,
    value_source: Option<String>
}

Customizable Solutions

From no-code dashboard tools to low-code SDKs, we provide fully customizable solutions that adapt to your scale - whether you're an individual creator or a global brand.

// Rich set of customization options
public entry fun set_collection_value_source(
    collection_cap: &mut CollectionCap,
    value_source: vector<u8>,
    is_api: bool,
) {
    // Configure external price feeds
    // Set custom metadata endpoints
    // Define trading parameters
}

Dynamic NFT Features

Enhanced liquidity mechanisms and real-world utility integration turning NFTs into versatile, highly liquid assets with true market value.

// Advanced trading capabilities
public entry fun batch_update_metadata(
    collection_cap: &CollectionCap,
    tokens: vector<NFT>,
    new_uri: Option<vector<u8>>,
    ctx: &mut TxContext
) {
    // Batch operations
    // Real-time updates
    // Market integrations
}

Web3 Made Simple

No prior blockchain expertise needed. Our platform bridges the gap between Web2 and Web3, providing an intuitive entry point for all users.

// Simplified interaction model
public fun get_collection_value_source(
    collection_cap: &CollectionCap
): (Option<String>, bool) {
    // Easy value retrieval
    // Straightforward interfaces
    // User-friendly design
}

Enterprise-Grade Features

Smart Balance Management

Smart Balance Management

Efficient token accounting with automatic cleanup - zero balances are destroyed to save gas, while collection-specific tracking ensures accurate token counts

Collection-Level Governance

Collection-Level Governance

CollectionCap provides centralized control over supply, mutability, deny lists and access management - true inversion of control pattern

Rich Event System

Rich Event System

Comprehensive event emission for tracking collection creation, mints, transfers, metadata updates, and access control changes

Dual ID System

Dual ID System

Track tokens via global Artinals ID and collection-specific Asset ID. Perfect for cross-collection operations and internal management

Supply Control

Supply Control

Configurable initial and maximum supply with safe arithmetic operations to prevent overflow and ensure supply constraints

Asset ID Operations

Asset ID Operations

Perform transfers and updates by targeting specific asset IDs, enabling precise token management within collections

Advanced Digital Asset Management

ART20 Contract Features

Metadata Freezing System

Permanently freeze metadata with batch operations and event tracking, perfect for establishing immutable token properties.

// Freeze metadata for multiple tokens
              public entry fun batch_freeze_metadata(
                  tokens: vector<NFT>,
                  collection_cap: &CollectionCap,
              ) {
                  token.metadata_frozen = true;
                  token.is_mutable = false;
                  event::emit(MetadataFrozenEvent { ... });
              }

Advanced Deny List Management

Enterprise-grade access control with batch operations, authority management, and comprehensive event tracking.

// Deny list management
              public entry fun add_to_deny_list(
                  collection_cap: &mut CollectionCap,
                  addrs: vector<address>
              ) {
                  assert!(collection_cap.has_deny_list_authority);
                  // Add addresses to deny list
                  event::emit(DenyListStatusChanged { ... });
              }
shapeshape

Technical Infrastructure

Safe Arithmetic Operations

Built-in overflow protection and validation for all numerical operations

fun safe_add(a: u64, b: u64): u64 {
    assert!(a <= MAX_U64 - b, E_OVERFLOW);
    a + b
}
fun safe_sub(a: u64, b: u64): u64 {
    assert!(a >= b, E_INSUFFICIENT_BALANCE);
    a - b
}

Advanced Query Functions

Rich set of view functions for external integrations and data access

public fun get_collections_info(): (
    vector<ID>,     // collection_ids
    vector<address>,// creators
    vector<String>, // names
    vector<u64>,    // supplies
    vector<bool>    // mutability flags
)

Comprehensive Event System

Debug events and detailed tracking for all state changes

// Debug event system
public struct DebugEvent has copy, drop {
    key: String,
    value: String,
}
public struct BatchTransferEvent has copy, drop {
    from: address,
    recipients: vector<address>,
    token_ids: vector<ID>,
    timestamp: u64
}

Error Code Management

Detailed error handling with specific error codes for each validation

const E_MISMATCH_TOKENS_AND_URIS: u64 = 1;
const E_NOT_CREATOR: u64 = 2;
const E_TOKEN_NOT_MUTABLE: u64 = 3;
const E_METADATA_FROZEN: u64 = 4;
const E_NOT_OWNER: u64 = 5;
const E_NO_TOKENS_TO_BURN: u64 = 6;

Create Module: Competitive Edge

websiteartinalsopensearariblefoundationmintbasezora
ArtinalsYesNoNoNoNoNo
Deny List ManagementYesNoNoNoNoNo
Dynamic Metadata UpdatesYesNoNoNoNoPartial
Compliance Authority IntegrationYesNoNoNoNoNo
Batch Minting with Unique IDsYesNoNoNoNoNo
User Balance ManagementYesPartialPartialNoPartialNo

Technical FAQ

CollectionCap is the primary governance structure that provides centralized control over collection-level operations. It manages supply limits, mutability settings, and access control through deny lists. Only the creator can perform sensitive operations, making it perfect for enterprise-grade access management.

The contract implements efficient balance tracking through UserBalance struct that maps collection IDs to balances. When a balance reaches zero, the contract automatically deletes the UserBalance object to optimize gas costs. This ensures efficient resource management while maintaining accurate token ownership records.

Batch operations are optimized through consolidated state changes and validation checks. Features like batch_update_metadata and batch_burn_art20 process multiple tokens in a single transaction, significantly reducing gas costs compared to individual operations. Each batch is bounded by MAX_BATCH_SIZE to ensure safe execution.

Metadata can be updated at both token and collection levels through update_metadata functions. The system supports freezing metadata permanently when needed using freeze_collection_metadata and batch_freeze_metadata. All metadata operations respect the is_mutable and metadata_frozen flags.

Each NFT has two identifiers: a global artinals_id (unique across all collections) and an asset_id (unique within its collection). This enables both cross-collection operations using artinals_id and collection-specific management using asset_id, while maintaining uniqueness guarantees.

Supply is managed through multiple safeguards: MAX_SUPPLY constant (1 billion), per-collection max_supply, and real-time current_supply tracking. Safe arithmetic operations (safe_add, safe_sub) prevent overflow, while supply validation occurs during minting and burning.

Partner with Artinals Protocol

Explore partnership opportunities, custom solutions, no-code dashboard implementations, and low-code SDK integrations with our enterprise-grade NFT infrastructure.