Sui Technical

How does Sui's object-centric architecture enable experiences that are practically impossible on other L1s?

Desired outcomes that drive architectural decision making:

Maximize parallel execution through explicit object ownership
Minimize latency for real-time applications
Prevent common smart contract vulnerabilities at the language level

Core Architecture

Sui is a Layer-1, Proof-of-Stake blockchain with Byzantine Fault Tolerant consensus. Key architectural principles:

Modular, upgradeable design:

Core components (consensus, execution, storage) are modular
Can be swapped/upgraded without breaking the network
Execution separation: simple transfers bypass full consensus

Object-Centric Model:

Every asset/state element is a first-class object with ID, type, owner, version, and data
Not a balance in a global account table explicit ownership model
Removes global total ordering bottleneck of account-based chains

Object Model

Object Type	Description	Example
Owned Objects	Single owner, transfers change owner field	User's coin, NFT
Shared Objects	Used for shared state	AMM pools, order books
Immutable Objects	Cannot be modified after creation	Published packages

Parallelism: Independent transactions touching disjoint sets of objects execute in parallel. Validators only lock and update specific objects involved, not entire global state.

Effect: Linear scaling with hardware and validator parallelism.

Mysticeti Consensus

Purpose-built low-latency BFT consensus optimized for fast finality:

Metric	Value
End-to-end confirmation	~390ms
Finality	Sub-second
Security model	BFT resistant to <1/3 faulty stake
Validator count	>100 validators

How it works:

All validators propose blocks in parallel, creating a DAG structure
No single leader bottleneck
Simple object transfers can bypass full consensus using lightweight protocols
Complex transactions (shared objects) go through full Mysticeti

Move Programming Language

Move is a resource-oriented language originally from Diem, extended for Sui's object model:

First-class resources:

Linear types model assets that cannot be duplicated or accidentally destroyed
Maps cleanly to Sui objects (coins, NFTs, positions)
Prevents re-entrancy attacks, unintended asset loss

Safety & verification:

Designed for formal verification
Strong static checking of resource movement
Significantly reduces whole classes of bugs vs Solidity

Developer ergonomics:

Smart contracts define custom object types and capabilities
Not global contract balances explicit composability
Fine-grained access control

Architecture Features

Feature	Description
Programmable Transaction Blocks (PTB)	Execute up to 1024 transactions in a single operation
Sponsored Transactions	Native support for gas-free UX, apps cover user gas costs
zkLogin	Web2 credentials sign blockchain transactions via ZKP
DeepBook	Native CLOB for high-frequency trading

Extended Stack (2025)

Feature	Description	Use Case
Walrus	Decentralized blob storage, coordinated via Sui objects	Store large files, AI outputs, media off-chain
Seal	Identity-based encryption with on-chain Move policies	Encrypt data at source, policy-controlled decryption
Nautilus	TEE compute (AWS Nitro) with verifiable attestations	Prove AI execution, private order books, oracles

Integration pattern:

Encrypt data client-side (Seal SDK)
Store encrypted blob (Walrus)
Compute in TEE (Nautilus) - accesses Seal keys under policy
Verify attestation on-chain (Sui contract)
Pay on verified completion (PTB with conditional logic)

See Sui Ecosystem for detailed integration examples.

Performance Characteristics

Throughput & Scaling:

Theoretical throughput among highest of major L1s due to object-level parallelism
Partial ordering enables massive concurrency
Scales linearly with hardware

Latency:

DeFi CLOB (DeepBook) settles trades in ~390ms range
Enables HFT-style UX in DeFi and real-time gaming

Fees:

Parallel execution and efficient consensus keep per-tx fees low
Predictable even under load

Use-case fit:

Latency-sensitive: Order-book DEXs, HFT, real-time gaming, payments
Rich state apps: Complex NFTs, game items, programmable RWAs

Comparison with Other L1s

Aspect	Sui	Solana	Ethereum
Data Model	Object-centric	Account-based	Account-based
Parallelism	Explicit (object ownership)	Implicit (Sealevel)	Sequential
Language	Move	Rust	Solidity
Finality	~390ms	~400ms	~12min
Storage Cost	>1000x cheaper than ETH	>100x cheaper than ETH	Baseline

Agent Economy Primitives

How Sui's architecture enables verifiable AI agents with fluid payments:

Primitive	Knowledge Stack Layer	Sui Implementation
Identity	Platform	zkLogin + AgentProfile objects
Trust	Standards	Reputation scores + slashable stake
Verification	Protocols	Nautilus TEE attestations
Payments	Protocols	PTBs + conditional release
Storage	Platform	Walrus + Seal encryption
Attribution	Standards	Links Protocol (object chains)

Why Sui for Agents?

Object model fits agent state:

Each agent is an owned object with ID, reputation, stake
Tasks, attestations, and payments are composable objects
No global state contention - agents operate in parallel

PTBs enable fluid payments:

Register + stake + claim task in ONE transaction
Batch pay 100 agents in one tx (up to 1024 operations)
Conditional release: payment only on verified attestation

Sub-second finality for real-time:

~390ms confirmation enables responsive agent workflows
DeepBook pattern applicable to agent task markets

Move Contract Pattern: Verifiable Task

module agent::tasks {
    struct AgentProfile has key, store {
        id: UID,
        reputation: u64,
        stake: Coin<SUI>,
        tasks_completed: u64,
    }

    struct TaskAttestation has key, store {
        id: UID,
        agent_id: ID,
        output_blob: vector<u8>,    // Walrus blob ID
        tee_signature: vector<u8>,  // Nautilus attestation
    }

    /// Verify TEE attestation and release payment
    public fun verify_and_pay(
        attestation: &TaskAttestation,
        task: &mut Task,
        agent: &mut AgentProfile,
    ) {
        // Nautilus SDK verifies TEE signature
        assert!(verify_tee_attestation(attestation), E_INVALID);

        // Release escrowed payment
        let payment = task.release_escrow();
        transfer::public_transfer(payment, object::id(agent));

        // Update reputation
        agent.reputation = agent.reputation + 1;
        agent.tasks_completed = agent.tasks_completed + 1;
    }
}

See Knowledge Stack for how primitives compound into platforms.

PropTech Applications

How Sui's primitives map to real estate and property technology:

Primitive → PropTech Matrix

Sui Primitive	PropTech Application	Why It Fits
Object Model	Property as object (ID, owner, metadata, history)	Properties ARE objects
Owned Objects	Title deeds, lease NFTs, access tokens	Clear ownership, transferable
Shared Objects	Escrow, HOA governance, REIT pools	Multi-party coordination
PTBs	Close + record + pay + notify in ONE tx	Replace 90-day closing with minutes
~390ms Finality	Real-time rent, instant access grants	IoT integration possible
zkLogin	Tenant onboarding without wallet	Mainstream adoption
Sponsored Tx	Landlord covers gas for tenant actions	Frictionless UX
Walrus	Property photos, inspection reports, documents	Off-chain storage, on-chain coordination
Seal	Encrypt financials, tenant PII, due diligence	Policy-controlled access per deal
Nautilus	Verifiable valuations, AI screening attestations	Prove the AI model that ran

Architecture Stack

┌─────────────────────────────────────────────────────────────┐
│                    PROPTECH APPLICATIONS                     │
│   Leasing │ Sales │ Management │ Investment │ Compliance    │
├─────────────────────────────────────────────────────────────┤
│                    NAUTILUS (Verifiable AI)                  │
│   Valuations │ Screening │ Predictions with proofs          │
├─────────────────────────────────────────────────────────────┤
│                    SEAL + WALRUS                             │
│   Encrypted docs │ Deal rooms │ Inspection reports          │
├─────────────────────────────────────────────────────────────┤
│                    SUI CORE                                  │
│   PropertyNFT │ LeaseNFT │ AccessToken │ Payments           │
├─────────────────────────────────────────────────────────────┤
│                    DEPIN (Sensor Layer)                      │
│   Occupancy │ Smart locks │ Environment │ Utilities         │
└─────────────────────────────────────────────────────────────┘

Move Contract Patterns

Property as Object:

module proptech::property {
    struct PropertyNFT has key, store {
        id: UID,
        address: String,
        legal_description: String,
        owner: address,
        fractional_shares: u64,
        metadata_blob: vector<u8>,  // Walrus blob ID
        valuation: u64,
        last_updated: u64,
    }
}

Smart Lease:

module proptech::lease {
    struct Lease has key, store {
        id: UID,
        property_id: ID,
        tenant: address,
        landlord: address,
        monthly_rent: u64,
        deposit: Coin<USDC>,
        start_epoch: u64,
        end_epoch: u64,
        terms_blob: vector<u8>,  // Walrus: full lease PDF
    }

    /// Auto-debit rent with PTB
    public fun pay_rent(lease: &mut Lease, payment: Coin<USDC>) {
        assert!(coin::value(&payment) >= lease.monthly_rent, E_INSUFFICIENT);
        transfer::public_transfer(payment, lease.landlord);
    }
}

Token-Gated Access:

module proptech::access {
    struct AccessToken has key, store {
        id: UID,
        property_id: ID,
        holder: address,
        access_level: u8,      // 0=none, 1=tenant, 2=maintenance, 3=owner
        valid_from: u64,
        valid_until: u64,
    }

    /// Smart lock verifies on-chain (~390ms)
    public fun verify_access(token: &AccessToken, property_id: ID): bool {
        token.property_id == property_id &&
        token.valid_until >= tx_context::epoch()
    }
}

Verifiable Valuation (Nautilus):

module proptech::valuation {
    struct ValuationAttestation has key, store {
        id: UID,
        property_id: ID,
        estimated_value: u64,
        confidence: u64,
        model_hash: vector<u8>,     // Which AI model ran
        tee_signature: vector<u8>,  // Nautilus attestation
        timestamp: u64,
    }

    /// DeFi can trust this for collateral
    public fun get_verified_value(att: &ValuationAttestation): u64 {
        assert!(verify_nautilus_signature(att), E_INVALID_ATTESTATION);
        att.estimated_value
    }
}

Use Case Flows

1. Property Sale (PTB closes in minutes, not months):

PTB Transaction:
Verify buyer funds
Transfer PropertyNFT to buyer
Transfer payment to seller
Record on-chain title change
Mint AccessToken for new owner
Revoke seller's AccessToken

  → All in ~390ms, not 90 days

2. IoT Access Control:

Tenant approaches door
    ↓
Smart lock queries Sui for AccessToken
    ↓
~390ms verification
    ↓
Door unlocks
    ↓
Entry logged on-chain

3. Encrypted Deal Room (Seal + Walrus):

Upload due diligence docs → Walrus
Encrypt with Seal policy (allowlist + expiry)
Only verified buyers can decrypt
Every access logged on-chain
Auto-expire after deal closes

Why Sui for PropTech

Requirement	Sui Advantage
Property = Object	Native object model, not account hacks
Batch closing	PTB: 1024 ops in one tx
Mainstream users	zkLogin removes wallet friction
Real-time IoT	~390ms enables smart locks
Document storage	Walrus native integration
Privacy/compliance	Seal + on-chain policies
Verifiable AI	Nautilus attestations for valuations

See Real Estate Platform for the full PropTech stack and Vertical SaaS for software patterns.

Context

Sui Overview
Sui Business Development
Sui Dev Resources
Sui Ecosystem
Architecture
Real Estate Platform - PropTech application
Vertical SaaS - Software layer patterns
DePIN - Physical infrastructure

Core Architecture​

Object Model​

Mysticeti Consensus​

Move Programming Language​

Architecture Features​

Extended Stack (2025)​

Performance Characteristics​

Comparison with Other L1s​

Agent Economy Primitives​

Why Sui for Agents?​

Move Contract Pattern: Verifiable Task​

PropTech Applications​

Primitive → PropTech Matrix​

Architecture Stack​

Move Contract Patterns​

Use Case Flows​

Why Sui for PropTech​

Context​