# Phase 3: The Attribution Protocol SDK

Phase 3 transitions from external observer (video recorder) to native integration (event logging standard), establishing the protocol as foundational infrastructure for IP tracking across the creative industry.

While Phase 2 provides a universal solution for closed-source software, it relies on heavy video data. Phase 3 introduces the Attribution SDK - a library allowing third-party developers to integrate event sourcing logic directly into their software.

This shifts the product from an "app" to a "protocol," enabling a universal standard for digital creation provenance.

## **The Open Creative Graph (OCG) Standard**

To ensure interoperability between tools (e.g., moving an asset from Blender to Unreal Engine), we define a universal schema for creative actions:

```json
{
  "protocol_version": "1.0",
  "sdk_signature": "0xABC_signed_by_core_sdk",
  "session_id": "uuid_v4",
  "software_id": "blender_v4.2_official_plugin",
  "events": [
    {
      "seq": 105,
      "verb": "GEOMETRY_EXTRUDE",
      "subject": "Mesh_Cube.001",
      "params": { "axis": "z", "value": 2.5 },
      "timestamp": 1720005500,
      "prev_event_hash": "sha256_of_event_104"
    },
    {
      "seq": 106,
      "verb": "MATERIAL_ASSIGN",
      "subject": "Mesh_Cube.001",
      "dependency": "Solana_Address_Texture_Asset"
    }
  ]
}
```

## **SDK Architecture**

The SDK ships in three flavors to cover 99% of the market:

### 1. Core C++ SDK

* Target: High-performance game engines (Unreal, Godot, O3DE), AAA studio tools, native plugins (Adobe C++ SDK)
* Focus: Zero-latency logging, thread safety, memory management

### 2. Python SDK

* Target: DCC tools (Blender, Maya, Houdini, Nuke) and pipeline automation scripts
* Focus: Ease of integration into existing studio pipelines

### 3. WebAssembly (WASM) / JS SDK

* Target: Web-based tools (Figma, Canva, Spline) and AI generation platforms
* Focus: Lightweight implementation, secure HTTP transmission

### **The "Black Box" Security Model**

To prevent developers or users from spoofing logs:

* **Internal Buffering:** Events pushed to protected memory buffer
* **Local Hashing:** SDK calculates hash chain internally. Host software cannot edit past events without breaking chain
* **Heartbeat Signing:** SDK periodically pings Attribution API to receive "Server Timestamp Signature," proving logs existed at specific time

### **Integration Scenarios**

#### Scenario A: Open Source Ecosystem (Blender/Godot)

* **Implementation:** Official "Attribution Layer Add-on" using Python SDK
* **UX:** User installs addon, "Record IP" toggle appears in UI
* **Outcome:** Free software users gain enterprise-grade IP protection without desktop recorder

#### Scenario B: AI Platforms (Midjourney / Stable Diffusion)

* **Implementation:** AI platform integrates Node.js SDK on backend
* **Logic:** Every prompt generation records `{ Prompt, Seed, Model_Version, User_ID }`
* **Outcome:** Generated images "born" with Solana connection - clear distinction between provenanced AI and generic scraping

#### Scenario C: Game Studio Pipelines

* **Implementation:** Studio integrates C++ SDK into internal Level Editor
* **Outcome:** Internal tracking of who modified which assets, automating credits and solving disputes

#### **File Format Attribution Embedding**

As platforms adopt the SDK, attribution embeds directly in exported files:

**GLTF/GLB (3D Assets):**

```json
{
  "extensions": {
    "anitya_attribution": {
      "protocol_version": "1.0",
      "project_id": "proj_abc123",
      "creator_wallet": "Sol_ABC123...",
      "provenance_hash": "0x8a3f2b1c9d4e...",
      "total_duration": "8_hours_15_minutes"
    }
  }
}
```

**PNG/JPEG (Images):** Attribution in EXIF/XMP metadata

**MP4/MOV (Video):** Attribution in container metadata

Files carry their own provenance - no external lookup required.

### **Phase 2 vs Phase 3 Comparison**

| **Feature**  | **Phase 2 (Screen Recording)** | **Phase 3 (SDK Protocol)**           |
| ------------ | ------------------------------ | ------------------------------------ |
| Data Type    | Video (Pixels)                 | Event Logs (Commands)                |
| Storage Size | Heavy (GBs per session)        | Tiny (KBs per session)               |
| Accuracy     | Visual Approximation           | Exact Precision (Deterministic)      |
| Privacy      | Risk of capturing sensitive UI | Captures only command data           |
| Integration  | External (Universal)           | Native (Requires developer adoption) |
| Verification | Human/AI Review                | Automated Mathematical Verification  |

Phase 3 represents protocol maturity. Screen recording remains essential for legacy or closed applications, while the SDK becomes the standard for modern, transparent IP management.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://anitya.gitbook.io/lightpaper/technical-deep-dive/phase-3-the-attribution-protocol-sdk.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.