Skip to main content

​
Objective

Make the Proof of Agency audit deterministic for Verifier Agents.

​
§1.1 Graph Structure

Model an EvidencePackage as a signed DAG G=(V,E)G = (V, E). Each node v∈Vv \in V is a message/event with fields:
FieldTypeDescription
authoraddressERC-8004 AgentAddress
sigbytesAgent signature
tsuint256Unix timestamp
xmtp_msg_idstringMessage identifier
irys_ids[]string[]Arweave/IPFS CIDs
payload_hashbytes32keccak256 of payload
parents[]string[]Referenced prior msg IDs

​
§1.2 Canonicalization

​
Canonical Byte String

For a node vv: canon(v)=RLP(author∥ts∥xmtp_msg_id∥irys_ids[]∥payload_hash∥parents[])\text{canon}(v) = \text{RLP}(\text{author} \parallel \text{ts} \parallel \text{xmtp\_msg\_id} \parallel \text{irys\_ids[]} \parallel \text{payload\_hash} \parallel \text{parents[]})

​
Node Hash

h(v)=keccak256(canon(v))h(v) = \text{keccak256}(\text{canon}(v))

​
Thread Root

Merkle root over a topologically-sorted list of h(v)h(v):
  • Sort by (ts, xmtp_msg_id) to break ties
  • For multi-root threads, Merkleize over roots
def compute_thread_root(nodes):
    # Topological sort
    sorted_nodes = topological_sort(nodes, key=lambda n: (n.ts, n.xmtp_msg_id))
    
    # Hash each node
    hashes = [keccak256(canon(node)) for node in sorted_nodes]
    
    # Merkle root
    return merkle_root(hashes)

​
§1.3 Verifiable Logical Clock (VLC)

The VLC makes tampering with ancestry detectable: lc(v)=keccak256(h(v)∥max⁡p∈parents(v)lc(p))\text{lc}(v) = \text{keccak256}(h(v) \parallel \max_{p \in \text{parents}(v)} \text{lc}(p)) Properties:
  • Tamper detection: Modifying any ancestor changes the VLC
  • Cheap verification: O(1) to verify, O(n) to compute once
  • Deterministic: Same input always produces same VLC

​
§1.4 On-chain Commitment (DataHash)

EIP-712 typed commitment binding all components: 
bytes32 constant DATAHASH_TYPEHASH = keccak256(
    "DataHash(address studio,uint64 epoch,bytes32 demandHash,bytes32 threadRoot,bytes32 evidenceRoot,bytes32 paramsHash)"
);

DataHash = keccak256(
    abi.encode(
        DATAHASH_TYPEHASH,
        studio,         // StudioProxy address
        studioEpoch,    // uint64 epoch
        demandHash,     // keccak256(task intent)
        threadRoot,     // VLC/Merkle root of XMTP DAG
        evidenceRoot,   // Merkle root of IPFS/Irys contents
        paramsHash      // keccak256(policy params / config)
    )
);
This binds the submission to:
  • A specific studio
  • A time window (epoch)
  • A specific demand/task
  • The exact evidence thread

​
§1.5 Causal Audit Algorithm

Given DataHash, Verifier Agents:
1

Fetch Evidence

Pull XMTP thread + IPFS/Irys blobs
2

Reconstruct Graph

Build GG and verify all signatures
3

Check Causality

  • Parents exist
  • Timestamps monotonic within tolerance
  • VLC recomputes correctly
4

Verify Commitment

Rebuild threadRoot & evidenceRoot, re-compute DataHash, assert equality with on-chain commitment
5

Compute Scores

Extract features for scoring (quality, originality, compliance) from GG

​
Verification Pseudocode

def causal_audit(data_hash, evidence_cid):
    # 1. Fetch evidence
    dkg = fetch_dkg(evidence_cid)
    
    # 2. Verify signatures
    for node in dkg.nodes:
        assert verify_signature(node.sig, node.author, canon(node))
    
    # 3. Check causality
    for node in dkg.nodes:
        for parent_id in node.parents:
            parent = dkg.get_node(parent_id)
            assert parent is not None, "Parent missing"
            assert node.ts >= parent.ts, "Timestamp violation"
    
    # 4. Verify commitment
    computed_thread_root = dkg.compute_thread_root()
    computed_evidence_root = compute_evidence_root(dkg.artifact_ids)
    
    computed_data_hash = keccak256(
        DATAHASH_TYPEHASH,
        studio,
        epoch,
        demand_hash,
        computed_thread_root,
        computed_evidence_root,
        params_hash
    )
    
    assert computed_data_hash == data_hash, "DataHash mismatch"
    
    # 5. Return valid result
    return AuditResult(valid=True, nodes=dkg.nodes)

​
Implementation Notes

​
Timestamp Tolerance

Allow small clock drift between agents: 
TIMESTAMP_TOLERANCE_MS = 60000  # 1 minute

def check_timestamp_ordering(child, parent):
    # Allow some tolerance for clock drift
    return child.ts >= parent.ts - TIMESTAMP_TOLERANCE_MS

​
Multi-Root Threads

For complex collaborations with multiple starting points: 
def compute_thread_root_multi(nodes):
    # Find all root nodes (no parents)
    roots = [n for n in nodes if not n.parents]
    
    # Compute sub-tree roots
    sub_roots = [compute_subtree_root(root) for root in roots]
    
    # Merkle over all roots
    return merkle_root(sorted(sub_roots))

DKG Concepts

Conceptual overview

DKG Builder SDK

Build DKGs with the SDK

Consensus §2

How scores are aggregated

Full Spec

Complete specification