ZHOU¶

Overview¶

ZHOU is the market rate orchestrator that initializes a complete token hierarchy during deployment. It creates a primary SHIO pair and installs it as a Rod in ZHENG, establishing the foundational market infrastructure.

Kind: Contract
License: Sharia
Solidity: ^0.8.21
Source: 06_zhou.sol

Inheritance Chain (C3 Linearized)¶

Immediate Parents¶

DYSNOMIA

What This Means For Players¶

Plain English Summary: ZHOU is the exchange rate board - it sets how much things are worth. When you want to trade one token for another, ZHOU's infrastructure determines the exchange rate. It's also the main chat channel where global messages are broadcast.

Real-World Analogy: Think of ZHOU as a currency exchange kiosk at an airport. It posts the rates for converting between different currencies and processes your exchanges. In Dysnomia, every token can be traded for any other token, and ZHOU manages those rates.

How It Affects Your Gameplay: - Token trading - The exchange rates you see when buying/selling tokens come from here - Chat channel - ZHOU hosts one of the main message channels in the game - Market foundation - ZHOU establishes the primary trading infrastructure that everything else builds on

State Variables¶

Variable	Type	Visibility	Mutability	Initial Value
`Type`	`string`	public	constant	`ZHOU`
`Upsilon`	`ZHENG`	public	mutable	``
`Xi`	`uint64`	public	mutable	``
`Monopole`	`uint64`	public	mutable	``

Constructor¶

constructor¶

constructor(address ZhengContract) DYSNOMIA(unicode"CHATLOG Zhou", unicode"ZHOU", address(DYSNOMIA(ZhengContract).Xiao()))

Modifiers: DYSNOMIA(unicode"CHATLOG Zhou", unicode"ZHOU", address(DYSNOMIA(ZhengContract).Xiao()))
Parameters: address ZhengContract

Functions¶

External & Public¶

Alpha¶

function Alpha(string memory Name, string memory Symbol) public onlyOwners returns (SHA Epsilon)

Visibility: public
Modifiers: onlyOwners
Parameters: string memory Name, string memory Symbol
Returns: SHA Epsilon

React¶

function React(uint64 Iota) public returns (Bao memory)

Visibility: public
Parameters: uint64 Iota
Returns: Bao memory

Internal¶

Augment¶

function Augment(Bao memory Theta) internal

Visibility: internal
Parameters: Bao memory Theta

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
ZHENG - Installation management
YI - Token creation (via ZHENG)

Depended On By¶

YAU - Uses ZHOU for protocol coordination

Constructor Logic¶

constructor(ZhengContract) {
    Upsilon = ZHENG(ZhengContract);

    // Add ownership up the chain
    Upsilon.addOwner(address(this));
    Upsilon.Eta().addOwner(address(this));

    // Create Bao for installation
    Bao memory Theta;
    Theta.Phi = address(this);
    Theta.Mu = Alpha("Zheng Rod", "ZROD");

    // Create Cone via YI
    SHA Cone = Upsilon.Eta().Beta("Yi Shio Cone", "ZCONE");
    Cone.addOwner(address(Upsilon));

    // Create SHIO pair
    Theta.Shio = Upsilon.Eta().Kappa(Theta.Mu, Cone);

    // Configure ownership
    Theta.Shio.addOwner(address(Upsilon));
    Theta.Shio.addOwner(address(Upsilon.Eta()));

    // Generate and ionize
    Theta.Xi = Xiao.Random();
    Theta.Shio.Generate(Theta.Xi, Xiao.Random(), Xiao.Random());
    Upsilon.Iodize(Theta.Shio);

    // Magnetize and react
    Theta.Ring = Theta.Shio.Magnetize();
    Theta = Upsilon.Eta().React(Theta, Theta.Xi);

    // Store values and install
    Monopole = Theta.Omicron;
    Theta = Upsilon.InstallRod(Theta.Xi, Theta, Monopole);
    Xi = Theta.Xi;
}

Special Mechanisms¶

Hierarchical Ownership Setup¶

The Alpha function sets up a three-level ownership chain: - msg.sender owns the token - ZHENG (Upsilon) owns the token - YI (Upsilon.Eta()) owns the token

This enables operations from any level in the hierarchy.

Primary Rod Installation¶

During construction, ZHOU creates and installs the first Rod in the system, establishing: - The Xi index for future lookups - The initial Monopole for reactions - Market rates for all created tokens

React Passthrough¶

The React function provides a convenient way to react against the primary Rod without needing to know its exact location - it automatically retrieves the Rod by Xi and reacts via YI.

Usage Pattern¶

// Create new SHA token
SHA token = zhou.Alpha("New Token", "NTK");

// React against the primary installation
Bao memory result = zhou.React(inputValue);

Contract Verification¶

Property	Value
Keccak256 Hash	`0xb80e4856136756c84425a43afdddcfdda898b9b2e2ec32217c1e85bfa6d20d7f`
Source URL	https://raw.githubusercontent.com/busytoby/atropa_pulsechain/main/solidity/dysnomia/06_zhou.sol
Hash Generated	2026-04-17T20:48:08Z