Phase 1: anitya Engine Integration

Phase 1 replaces video recording with a Deterministic Event Logging System. Since anitya is the execution environment, we capture the "DNA" of the creation process (commands) rather than visual output (pixels).

Core Stack: TypeScript (Frontend), Solana/Anchor (Registry), Arweave (Log Storage), AWS KMS (Identity)

Architecture Overview

The logic moves from a desktop screen recorder to the anitya Engine Command Stack. Instead of heavy video files, the "Proof of Process" becomes a lightweight Cryptographic Event Log recording every significant user action (object creation, transformation, scripting, texturing) in a sequential, tamper-evident chain.

The Event Sourcing Engine

The core component is a TypeScript module integrated into anitya's Editor, observing the Undo/Redo stack.

Event Structure (JSON Schema)

Every action is serialized into a JSON object. Critical to security is hash chaining: each event includes the hash of the previous event, creating a "local blockchain" within the session. This makes it impossible to insert or delete actions without breaking the chain.

{
  "seq": 42,
  "timestamp": 1715000123,
  "prev_hash": "a1b2c3d4...",
  "action_type": "TRANSFORM_UPDATE",
  "user_id": "anitya_user_88",
  "payload": {
    "target_uuid": "obj_uuid_99",
    "position": { "x": 10.5, "y": 0, "z": -5 },
    "rotation": { "x": 0, "y": 90, "z": 0 },
    "scale": { "x": 1, "y": 1, "z": 1 }
  }
}

Asset Import (Remixing & Lineage)

When a user imports an existing anitya asset into their scene, the engine records the provenance link. This allows the Smart Contract to build the Royalty Graph automatically.

{
  "seq": 43,
  "prev_hash": "e5f6g7...",
  "action_type": "ASSET_IMPORT",
  "payload": {
    "local_uuid": "new_instance_id",
    "source_asset_address": "Solana_Pubkey_Of_Original_Asset"
  }
}

Storage Strategy (The Proof Package)

When the user clicks "Publish" or "Register IP":

1. Serialization: The frontend compiles the CommandStack into a single session_log.json

2. Visual Proof: The engine renders a high-res JPG thumbnail (preview.jpg)

3. Manifest: A file detailing dependencies (manifest.json)

These files are bundled and sent to the anitya Backend.

Arweave Upload (via Irys)

The backend uploads the package to Arweave.

• Result: A permanent, immutable URL (e.g., ar://TxID_123)

• Cost efficiency: A text log of 4 hours of work is ~500KB. Cost to store forever: < $0.01

Identity Management (Seamless Wallet)

We use a Custodial KMS Architecture integrated into anitya's existing Auth system.

1. Onboarding: When a user signs up (Email/Google), the backend triggers AWS KMS to generate a Solana Keypair

1. Mapping:

SQL DB: User: [e-mail] <-> Wallet: Public_Key_ABC
HSM (Secure): Key_ID_XYZ (stores the Private Key)

1. Signing:

User clicks "Publish" → Backend authenticates via JWT → KMS signs the Solana transaction using Key_ID_XYZ

Smart Contract (Solana Program)

The Onchain Registry stores the asset record:

use anchor_lang::prelude::*;

#[account]
pub struct AnityaAsset {
    // Identity
    pub authority: Pubkey,          // Creator's Wallet
    pub collection: Pubkey,         // Anitya Official Collection Address
    
    // Proof of Creation
    pub log_arweave_tx: String,     // Link to the JSON Event Log
    pub preview_arweave_tx: String, // Link to the Thumbnail
    pub log_root_hash: [u8; 32],    // Hash of the FINAL event in the log
    
    // Lineage (Dependencies)
    // Stores a list of other Assets used in this scene
    pub dependencies: Vec<Pubkey>,  
    
    // Metadata
    pub engine_version: String,     // e.g., "anitya v2.4"
    pub timestamp: i64,
}

Replay Verification

This is the unique selling point of Phase 1. To verify an asset, the anitya Viewer fetches the log_arweave_tx.

1. Load: It parses the JSON.

2. Verify: It recalculates the hash chain locally. If the math matches the log_root_hash on Solana, the file is authentic.

3. Replay: The engine executes the commands in "Ghost Mode" (Speed 10x), visually reconstructing the scene from scratch before the viewer's eyes.

Strategic Benefits of Phase 1

1. Control: We control the environment, eliminating 90% of anti-cheat/anti-fraud edge cases

2. Data Quality: Event logs are searchable and indexable. Query "show me all worlds that used this asset" - impossible with video

3. Adoption: By making this a default feature, we bootstrap the network with thousands of verifiable assets before asking anyone to install external software

---