H2O¶

Overview¶

H2O is the water token created by WAR. It represents a game resource with controlled minting and overflow mechanics.

Kind: Contract
License: Sharia
Solidity: ^0.8.21
Source: domain/assets/h2o.sol

Inheritance Chain (C3 Linearized)¶

Immediate Parents¶

DYSNOMIA

What This Means For Players¶

Plain English Summary: H2O is the water currency - earned through battle (WAR) and representing your resources. When you beat high scores at territory positions, you earn H2O tokens. Water represents your accumulated battle rewards.

Real-World Analogy: Think of H2O like experience points or loot in a battle game. Every time you win a fight (beat a position record in WAR), you collect water as your reward. The more battles you win, the more water you accumulate.

How It Affects Your Gameplay: - Battle rewards - Earn H2O by beating records in the WAR system - Overflow protection - If you hold too much, excess flows to WORLD or gets burned - Resource token - H2O represents one of the core game currencies

State Variables¶

Variable	Type	Visibility	Mutability	Initial Value	NatSpec
`Type`	`string`	public	constant	`H2O`
`War`	`WARINTERFACE`	public	mutable	``

Constructor¶

constructor¶

constructor(address WarAddress) DYSNOMIA(unicode"水",, 2O",, dress(DYSNOMIA(WarAddress).Xiao())))

Modifiers: DYSNOMIA(unicode"水",, 2O",, dress(DYSNOMIA(WarAddress).Xiao())))
Parameters: address WarAddress

Functions¶

External & Public¶

Balance¶

function Balance() public view returns (uint256)

Visibility: public
State Mutability: view
Returns: uint256

Mint¶

function Mint(address To, uint256 Amount) public onlyOwners

Visibility: public
Modifiers: onlyOwners
Parameters: address To, uint256 Amount

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 virtual 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
`_addLibraryOwner`	`function _addLibraryOwner(VOID Void, string memory what) internal`
`_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`

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 V2 - Base functionality
WAR - Owner and creator

Created By¶

WAR - Constructor deployment

Special Mechanisms¶

Overflow Protection¶

function Mint(address To, uint256 Amount) public onlyOwners {
    _mint(To, Amount);

    uint256 _flip = H2O(address(this)).balanceOf(To);
    uint256 _max = War.World().Map().Map().Meridians(13);

    if(_flip > _max) {
        uint256 _flip2 = H2O(address(this)).balanceOf(address(War.World()));
        uint256 _max2 = War.World().Map().Map().Meridians(20);

        if(_flip2 < _max2)
            _transfer(To, address(War.World()), _flip - _max);
        else
            _transfer(To, address(0x0), _flip - _max);  // Burn excess
    }
}

Overflow Logic¶

Mint requested amount
If recipient balance > Meridian[13], excess flows out
If WORLD balance < Meridian[20], excess goes to WORLD
Otherwise, excess is burned (sent to address(0))

Initial Supply¶

Constructor mints initial supply equal to Call token's total supply:

DYSNOMIA calltoken = DYSNOMIA(CallContract);
_mint(address(this), calltoken.totalSupply());

maxSupply¶

Set to 0 to disable automatic minting mechanics:

maxSupply = 0;

Contract Verification¶

Property	Value
Keccak256 Hash	`0x81ab4af65ad462172f93b1b0402735f9cff185ec6cf8412027eeed714c4020b4`
Source URL	https://raw.githubusercontent.com/busytoby/atropa_pulsechain/main/solidity/dysnomia/domain/assets/h2o.sol
Hash Generated	2026-04-17T20:48:10Z