Bao

Contract addressNot applicable to type definitions

Hash-verified 0x257e4a98…5250df

Source details▾

Property	Value
Keccak256 Hash	0x257e4a9884075b125c407aec08e906b6dfd2339b178bf45d930720bc6c5250df
Source URL	https://raw.githubusercontent.com/busytoby/atropa_pulsechain/58607494f7741b80525953e4a85bc99e66fd20fc/solidity/dysnomia/include/bao.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	0xd2d9a9914355cdd476c44b666ff7c4872cf2dfb12947f95ad93ca5f1c793a748
Compilation Closure Files	4
Hash Generated	2026-09-14T19:34:18Z

Overview

Bao is the central operation context structure used throughout the Dysnomia ecosystem. It encapsulates a SHIO pair with associated state and reaction outputs.

• Kind: Type Definitions Module
• License: Sharia
• Solidity: ^0.8.21
• Source: include/bao.sol

What This Means For Players

Plain English Summary: Bao is your operation ticket - it carries all your info for transactions. Every time you interact with the game, a Bao is created that contains your identity (Phi), your cryptographic keys (SHIO), and the results of any reactions (Omicron/Omega). It’s like a transaction receipt that also carries the tools to process the next transaction.

Real-World Analogy: Think of Bao like a boarding pass that also contains your passport, wallet, and luggage claim tickets all in one package. When you go through security (perform a game action), the Bao has everything needed to verify who you are and what you’re allowed to do.

How It Affects Your Gameplay:

• Identity bundle - Your Bao links your address (Phi) to your cryptographic identity (SHIO)
• Transaction context - Every operation carries a Bao with the current state
• Reaction results - Omicron and Omega store the outputs of cryptographic reactions
• Indexing - Xi is used to find your Bao in the system’s registries

Definition

struct Bao {
    address Phi;      // Associated address
    SHA Mu;           // Rod SHA token reference
    uint64 Xi;        // Generation/Index value
    uint64 Pi;        // Pi value (unused in most contexts)
    SHIO Shio;        // Associated SHIO pair
    uint64 Ring;      // Ring value from magnetization
    uint64 Omicron;   // First reaction output
    uint64 Omega;     // Second reaction output
}

Field Descriptions

Field	Type	Purpose
Phi	address	Owner/reference address (contract, user token, etc.)
Mu	SHA	The Rod SHA token from the SHIO
Xi	uint64	Index for installation or generation seed
Pi	uint64	Reserved/auxiliary value
Shio	SHIO	The full SHIO pair (contains both Rod and Cone)
Ring	uint64	Result of SHIO magnetization
Omicron	uint64	First output from React operations
Omega	uint64	Second output from React operations

Lifecycle

1. Create with Phi = owner address
2. Create SHA tokens (Mu = Rod)
3. Create SHIO from Rod + Cone
4. Generate SHIO with Xi
5. Iodize (Isomerize + Isolate)
6. Magnetize to get Ring
7. React to get Omicron/Omega
8. Install at Xi index

Common Patterns

Creation

Bao memory On;
On.Phi = msg.sender;
On.Mu = someFactory.New("Rod", "ROD", mathLib);
SHA Cone = someFactory.New("Cone", "CONE", mathLib);
On.Shio = shioFactory.New(address(On.Mu), address(Cone), mathLib);
On.Xi = random();
On.Shio.Generate(On.Xi, alpha, beta);
// ... iodize, magnetize
On.Ring = On.Shio.Magnetize();

Reaction

(On.Omicron, On.Omega) = On.Shio.React(inputValue);

Storage and Retrieval

// Store
mapping(uint64 => Bao) storage Sigma;
Sigma[On.Xi] = On;

// Retrieve
Bao memory retrieved = Sigma[someXi];

Used By

• YI - Nu mapping storage
• ZHENG - Sigma installation registry
• YANG - Rho.Bang/Lai/Le states
• LAU - On user state
• User - User.On field
• All domain contracts using reaction mechanics

Dependencies

Imports interfaces for:

• SHA - ../interfaces/02b_shainterface.sol
• SHIO - ../interfaces/03b_shiointerface.sol

Memory vs Storage

Bao is typically used as memory for temporary operations and passed between functions. For persistent storage, it’s stored in mappings indexed by Xi or address.

// Memory (temporary)
Bao memory temp = createBao();
temp = processReaction(temp);

// Storage (persistent)
mapping(uint64 => Bao) storage registry;
registry[temp.Xi] = temp;

---

Structs

Bao

struct Bao {
    address Phi;
    SHA Mu;
    uint64 Xi;
    uint64 Pi;
    SHIO Shio;
    uint64 Ring;
    uint64 Omicron;
    uint64 Omega;
}