Skip to content

YAU

Overview

YAU is the protocol coordinator that extends the installation chain by creating a secondary Rod installation. It reacts against ZHOU and stores the resulting state for further operations.

  • Inherits: DYSNOMIA
  • License: Sharia
  • Solidity: ^0.8.21

What This Means For Players

Plain English Summary: YAU is the protocol coordinator - it makes sure everything works together. It sits between the low-level infrastructure (ZHOU) and the higher-level game mechanics (YANG, SIU), ensuring all the pieces connect properly. Players don't interact with YAU directly, but it's essential plumbing that makes the game work.

Real-World Analogy: Think of YAU as a network router in your home. You don't configure it every day, but it's constantly working behind the scenes to make sure data flows correctly between your devices and the internet. YAU does the same for token operations in Dysnomia.

How It Affects Your Gameplay: - State management - YAU maintains crucial game state that other contracts depend on - Reaction processing - When you do things in the game, reactions often flow through YAU - System stability - YAU's secondary installation provides redundancy and stability

State Variables

Variable Type Visibility Description
Type string public constant "YAU"
Tau ZHOU public Reference to ZHOU market orchestrator
Theta Bao public Primary Bao state for this contract
Monopole uint64[2] public Omega and Omicron values from reaction

Read Functions

Tau

ZHOU public Tau
- Returns: Reference to the ZHOU contract

Theta

Bao public Theta
- Returns: The primary Bao state

Monopole

uint64[2] public Monopole
- Returns: Array of [Omega, Omicron] values

Write Functions

React

function React() public onlyOwners returns(Bao memory)
- Access: onlyOwners - Returns: - Bao: Delta Bao containing the fresh reaction outputs - Description: Reacts Theta via YI using its current Omega, then accumulates new values via XOR. - Logic Flow: 1. React Theta: Delta = Tau.Upsilon().Eta().React(Theta, Theta.Omega) 2. Update Theta's Omicron: Theta.Omicron = Delta.Omicron 3. XOR accumulate Omega: Theta.Omega = Theta.Omega ^ Delta.Omega 4. Call _mintToCap() 5. Return Delta - Computation Details: - Theta.Omega is used as input, creating a chain where each reaction depends on the previous - XOR accumulation means state evolves without losing history - Side Effects: Updates Theta.Omicron and Theta.Omega; triggers YI reaction; mints tokens - In Plain English: Advance the protocol state by running a reaction against the current Theta. The output Omega is XORed with the previous Omega, creating an evolving chain of state. Each React() call produces different outputs because the input depends on all previous reactions.

Contract Interactions

Depends On

  • DYSNOMIA - Base token functionality
  • ZHOU - Market orchestration
  • ZHENG - Installation management (via ZHOU)
  • YI - Token operations (via ZHOU)

Depended On By

  • YANG - Uses YAU for multi-state aggregation

Constructor Logic

constructor(ZhouAddress) {
    Tau = ZHOU(ZhouAddress);

    // Add ownership through the entire chain
    Tau.addOwner(address(this));
    Tau.Upsilon().addOwner(address(this));
    Tau.Upsilon().Eta().addOwner(address(this));

    // React against ZHOU with random input
    Theta = Tau.React(Xiao.Random());
    Theta.Phi = address(this);

    // Store reaction outputs
    Theta.Xi = Monopole[0] = Theta.Omega;
    Monopole[1] = Theta.Omicron;

    // Install as Rod at new Xi position
    Theta = Tau.Upsilon().InstallRod(Theta.Xi, Theta, Monopole[1]);
}

Special Mechanisms

Deep Ownership Chain

YAU adds itself as owner at three levels: 1. ZHOU (Tau) 2. ZHENG (Tau.Upsilon) 3. YI (Tau.Upsilon.Eta)

This enables full access to the token hierarchy.

Reaction Output Storage

The Monopole array stores both outputs from the initial reaction: - Monopole[0] = Omega (used as new Xi) - Monopole[1] = Omicron (used as Monopole for installation)

XOR Accumulation

The React function uses XOR to accumulate Omega values: 

Theta.Omega = Theta.Omega ^ Delta.Omega;
This creates an evolving state that depends on all previous reactions.

Secondary Installation

Unlike ZHOU which installs the primary Rod, YAU creates a secondary installation at a derived Xi position (the Omega value from reacting against ZHOU).

State Progression

ZHOU deploys with Xi_1
    ↓ React
YAU reacts, gets (Omicron, Omega)
    ↓
YAU installs at Xi = Omega
    ↓
Theta stored with new values

Usage Pattern

// React and update state
Bao memory result = yau.React();

// Access current state
Bao memory current = yau.Theta();
uint64 omega = yau.Monopole(0);
uint64 omicron = yau.Monopole(1);

Contract Verification

Property Value
Keccak256 Hash 0x1265570a1c690c48fd2f95a6a296f7d0646b4676c940279eb00524e444edaeda
Source URL https://raw.githubusercontent.com/busytoby/atropa_pulsechain/main/solidity/dysnomia/07_yau.sol
Hash Generated 2026-02-08T00:29:57Z