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.

Kind: Contract
License: Sharia
Solidity: ^0.8.21
Source: 07_yau.sol

Inheritance Chain (C3 Linearized)¶

Immediate Parents¶

DYSNOMIA

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	Mutability	Initial Value
`Type`	`string`	public	constant	`YAU`
`Tau`	`ZHOU`	public	mutable	``
`Theta`	`Bao`	public	mutable	``
`Monopole`	`uint64[2]`	public	mutable	``

Constructor¶

constructor¶

constructor(address ZhouAddress) DYSNOMIA(unicode"CHATLOG Yau", unicode"YAU", address(DYSNOMIA(ZhouAddress).Xiao()))

Modifiers: DYSNOMIA(unicode"CHATLOG Yau", unicode"YAU", address(DYSNOMIA(ZhouAddress).Xiao()))
Parameters: address ZhouAddress

Functions¶

External & Public¶

React¶

function React() public onlyOwners returns (Bao memory)

Visibility: public
Modifiers: onlyOwners
Returns: Bao memory

Internal¶

Augment¶

function Augment() internal

Visibility: internal

Inherited Members¶

This contract inherits the members below from its parents. See each parent's dedicated MD for full signatures, NatSpec, and semantics.

From DYSNOMIA¶

External & Public Functions

Function	Signature	State Mutability
`Rename`	`function Rename(string memory newName, string memory newSymbol) public onlyOwners`	nonpayable
`mintToCap`	`function mintToCap() public onlyOwners`	nonpayable
`GetMarketRate`	`function GetMarketRate(address _a) public view returns (uint256)`	view
`Purchase`	`function Purchase(address _t, uint256 _a) public`	nonpayable
`Redeem`	`function Redeem(address _t, uint256 _a) public`	nonpayable
`name`	`function name() public view virtual returns (string memory)`	view
`symbol`	`function symbol() public view virtual returns (string memory)`	view
`decimals`	`function decimals() public view virtual returns (uint8)`	view
`totalSupply`	`function totalSupply() public view virtual returns (uint256)`	view
`balanceOf`	`function balanceOf(address account) public view virtual returns (uint256)`	view
`transfer`	`function transfer(address to, uint256 value) public virtual returns (bool)`	nonpayable
`allowance`	`function allowance(address owner, address spender) public view virtual returns (uint256)`	view
`approve`	`function approve(address spender, uint256 value) public virtual returns (bool)`	nonpayable
`transferFrom`	`function transferFrom(address from, address to, uint256 value) public virtual returns (bool)`	nonpayable

Internal Functions

Function	Signature
`_mintToCap`	`function _mintToCap() internal`
`AddMarketRate`	`function AddMarketRate(address _a, uint256 _r) internal`
`_transfer`	`function _transfer(address from, address to, uint256 value) internal`
`_update`	`function _update(address from, address to, uint256 value) internal virtual`
`_mint`	`function _mint(address account, uint256 value) internal`
`_approve`	`function _approve(address owner, address spender, uint256 value) internal`
`_spendAllowance`	`function _spendAllowance(address owner, address spender, uint256 value) internal virtual`
`log10`	`function log10(uint256 value) internal pure returns (uint256)`
`String`	`function String(uint256 value) internal pure returns (string memory buffer)`
`Hex`	`function Hex(address account) internal pure returns (string memory)`

Events

Event	Parameters
`Transfer`	address indexed from, address indexed to, uint256 value
`Approval`	address indexed owner, address indexed spender, uint256 value

Errors

Error	Parameters
`MarketRateNotFound`	address asset
`DysnomiaInsufficientBalance`	address origin, address sender, address from, address to, address what, uint256 balance, uint256 needed
`DysnomiaInsufficientAllowance`	address origin, address sender, address owner, address spender, address what, uint256 allowance, uint256 needed

State Variables (private parent storage is not reachable and is omitted)

Variable	Type	Visibility	Mutability
`__name`	`string`	internal	mutable
`__symbol`	`string`	internal	mutable
`MotzkinPrime`	`uint64`	public	constant
`Xiao`	`atropaMath`	public	mutable
`maxSupply`	`uint256`	public	mutable

From MultiOwnable¶

External & Public Functions

Function	Signature	State Mutability
`owner`	`function owner() external view virtual returns (address)`	view
`renounceOwnership`	`function renounceOwnership(address toRemove) public virtual onlyOwners`	nonpayable
`addOwner`	`function addOwner(address newOwner) public virtual onlyOwners`	nonpayable

Internal Functions

Function	Signature
`_checkOwner`	`function _checkOwner() internal view virtual`
`_changeOwnership`	`function _changeOwnership(address cOwner, bool cState) internal virtual`

Events

Event	Parameters
`OwnershipUpdate`	address indexed newOwner, bool indexed state

Errors

Error	Parameters
`OwnableUnauthorizedAccount`	address origin, address account, address what
`OwnableInvalidOwner`	address origin, address owner, address what

Modifiers

Modifier	Parameters
`onlyOwners`	(none)

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-04-17T20:48:08Z