Technical Reference

YANG

Contract address0xB702b3ec6d9De1011BE963EFe30A28b6dDFbe011

Hash-verified 0xc56c0fac…4115f8

Source details

Property	Value
Keccak256 Hash	`0xc56c0facdcf6e2b68d9fda3ef769ea09f7818f7fa161d5ef941e4d6fd24115f8`
Source URL	https://raw.githubusercontent.com/busytoby/atropa_pulsechain/58607494f7741b80525953e4a85bc99e66fd20fc/solidity/dysnomia/08_yang.sol
Source Revision	`58607494f7741b80525953e4a85bc99e66fd20fc`
Source Status	Canonical source snapshot; deployed bytecode equivalence is only established where a deployment record says so.
Compiler	solc 0.8.21; optimizer enabled with 200 runs
Compiler Configuration	`{"evmVersion":"compiler-default","optimizer":{"enabled":true,"runs":200},"version":"0.8.21+commit.d9974bed.Linux.g++"}`
Compilation Closure Hash	`0x98da4edc0b7219a96eb4eaaf9a6d45eee87f00e888bebac1b346c800d7557738`
Compilation Closure Files	14
Hash Generated	2026-09-14T19:33:37Z

Overview

YANG is the multi-state aggregator that creates a three-part state structure (Bang, Lai, Le). It orchestrates multiple reactions and installations to establish a comprehensive protocol state.

Kind: Contract
License: Sharia
Solidity: ^0.8.21
Source: 08_yang.sol

Inheritance Chain (C3 Linearized)

Immediate Parents

DYSNOMIA

What This Means For Players

Plain English Summary: YANG is the state tracker - it remembers what’s happened in the game. It maintains three connected states (Bang, Lai, Le) that capture the history and current condition of the system. When you perform actions, YANG’s state evolves to reflect those changes.

Real-World Analogy: Think of YANG as a game save file that has three checkpoints. Each checkpoint (Bang, Lai, Le) captures a different aspect of the game state. Together, they provide a complete picture of where everything stands, and they’re cryptographically linked so they can’t be tampered with.

How It Affects Your Gameplay:

History tracking - YANG records the sequence of reactions that define the current game state
State dependencies - Many game mechanics check YANG’s state to determine valid actions
Pole values - YANG provides the “pole” values used in identity generation and reactions

State Variables

Variable	Type	Visibility	Mutability	Initial Value
`Type`	`string`	public	constant	`YANG`
`Mu`	`YAU`	public	mutable	``
`Rho`	`Tai`	public	mutable	``
`Pole`	`uint64[3]`	public	mutable	``

Constructor

constructor

constructorconstructor

constructor(address YauAddress) DYSNOMIA(unicode"CHATLOG Yang", unicode"YANG", address(DYSNOMIA(YauAddress).Xiao()))

Modifiers: DYSNOMIA(unicode"CHATLOG Yang", unicode"YANG", address(DYSNOMIA(YauAddress).Xiao()))
Parameters: address YauAddress

Functions

Internal

Augment

Augmentfunction

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
YAU - Protocol coordination
ZHOU - Market orchestration (via YAU)
ZHENG - Installation management (via YAU)
YI - Token operations (via YAU)

Depended On By

SIU - Uses YANG for token generation

Constructor Logic

constructor(YauAddress) {
    Mu = YAU(YauAddress);

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

    // 1. Bang: React via YAU
    Rho.Bang = Mu.React();
    Rho.Bang.Xi = Pole[0] = Rho.Bang.Omicron;

    // 2. Le: React via ZHOU
    Rho.Le = Mu.Tau().React(Pole[0]);
    Rho.Le.Xi = Pole[1] = Rho.Le.Omicron;

    // 3. Lai: Create new SHIO pair
    Rho.Lai.Phi = address(this);
    Rho.Lai.Mu = Mu.Tau().Alpha("Yang Rod", "MROD");
    SHA Cone = Mu.Tau().Upsilon().Eta().Beta("Yang Cone", "MCONE");
    Rho.Lai.Shio = Mu.Tau().Upsilon().Eta().Kappa(Rho.Lai.Mu, Cone);

    // Configure ownership
    Rho.Lai.Shio.addOwner(address(Mu.Tau()));
    Rho.Lai.Shio.addOwner(address(Mu.Tau().Upsilon()));
    Rho.Lai.Shio.addOwner(address(Mu.Tau().Upsilon().Eta()));

    // Generate with XOR'd Xi
    Rho.Lai.Xi = Rho.Bang.Omega ^ Rho.Le.Omega;
    Rho.Lai.Shio.Generate(Rho.Lai.Xi, Pole[1], Pole[0]);

    // Iodize and magnetize
    Mu.Tau().Upsilon().Iodize(Rho.Lai.Shio);
    Rho.Lai.Ring = Rho.Lai.Shio.Magnetize();

    // React and install
    Rho.Lai = Mu.Tau().Upsilon().Eta().React(Rho.Lai, Pole[1]);
    Pole[2] = Rho.Lai.Omicron;
    Rho.Lai = Mu.Tau().Upsilon().InstallRod(Rho.Lai.Xi, Rho.Lai, Pole[2]);
}

Special Mechanisms

Three-State Architecture

YANG creates three distinct states:

Bang: Result of reacting via YAU
Le: Result of reacting via ZHOU
Lai: Newly created and installed SHIO

Pole Value Chain

The Pole array creates a dependency chain:

Pole[0] = Bang.Omicron (used to generate Le)
Pole[1] = Le.Omicron (used to generate Lai)
Pole[2] = Lai.Omicron (final installation monopole)

XOR Generation

Lai’s Xi is computed as Bang.Omega ^ Le.Omega, combining entropy from both reactions.

Deep Ownership Chain

YANG adds itself as owner at four levels:

YAU (Mu)
ZHOU (Mu.Tau)
ZHENG (Mu.Tau.Upsilon)
YI (Mu.Tau.Upsilon.Eta)

Comprehensive Market Rates

The Augment function sets market rates for all tokens across all three states:

Lai’s tokens (Mu, Shio, Shio.Cone)
Bang’s tokens (Phi, Mu, Shio, Rod, Cone)
Le’s tokens (Phi, Mu, Shio, Rod, Cone)

State Diagram

YAU.React() → Bang
    ↓
ZHOU.React(Bang.Omicron) → Le
    ↓
Create new Shio with Xi = Bang.Omega ^ Le.Omega
    ↓
React and Install → Lai
    ↓
Rho = {Bang, Lai, Le}