MAP¶

Overview¶

MAP is the geographic token registry that maps tokens to coordinates using the Hecke meridian system. It manages QING token creation and provides location-based lookup.

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

Inheritance Chain (C3 Linearized)¶

Immediate Parents¶

DYSNOMIA

What This Means For Players¶

Plain English Summary: MAP is the game world map - it assigns locations to every token/venue in the game. Every QING (venue) has a unique position on the map, like a latitude and longitude. When you explore the game, you're navigating this map to find and visit different locations.

Real-World Analogy: Think of MAP like Google Maps for the Dysnomia game world. Every venue (QING) has a unique address on the map, and you can look up what's at any location. When someone creates a new venue, MAP assigns it a unique spot on the world grid.

How It Affects Your Gameplay: - Find venues - Use MAP to discover QINGs at specific coordinates - Wrap tokens - Any token can become a venue (QING) with a map location - Explore - Navigate the game world by coordinates - Forbidden tokens - Some tokens may be blocked from becoming venues

State Variables¶

Variable	Type	Visibility	Mutability	Initial Value
`Type`	`string`	public	constant	`MAP`
`Cho`	`CHOINTERFACE`	public	mutable	``
`Map`	`HECKE`	public	mutable	``
`Offset`	`uint256`	public	mutable	``
`_qings`	`mapping(address => address)`	private	mutable	``
`_waats`	`mapping(uint256 => QING)`	private	mutable	``
`_forbidden`	`mapping(address => bool)`	private	mutable	``
`_map`	`mapping(int256 => mapping(int256 => address))`	private	mutable	``

Events¶

Event	Parameters	Anonymous	NatSpec
`NewQing`	address Qing, address Integrative, uint256 Waat	no

Errors¶

Error	Parameters	NatSpec
`NotOwner`	address what, address who
`QingAlreadyExists`	address Token, address Qing
`DerivativeQing`	address Integrative, uint256 Waat
`ForbiddenToken`	address which

Constructor¶

constructor¶

constructor(address ChoAddress, address HeckeAddress) DYSNOMIA("Dysnomia Map", "MAP", address(DYSNOMIA(ChoAddress).Xiao()))

Modifiers: DYSNOMIA("Dysnomia Map", "MAP", address(DYSNOMIA(ChoAddress).Xiao()))
Parameters: address ChoAddress, address HeckeAddress

Functions¶

External & Public¶

GetMapQing¶

function GetMapQing(int256 Latitude, int256 Longitude) public view returns (QINGINTERFACE)

Visibility: public
State Mutability: view
Parameters: int256 Latitude, int256 Longitude
Returns: QINGINTERFACE

hasOwner¶

function hasOwner(address _contract) public view returns (bool does)

Visibility: public
State Mutability: view
Parameters: address _contract
Returns: bool does

has¶

function has(address _contract, string memory what) public view returns (bool does)

Visibility: public
State Mutability: view
Parameters: address _contract, string memory what
Returns: bool does

Forbidden¶

function Forbidden(address Asset) public view returns (bool)

Visibility: public
State Mutability: view
Parameters: address Asset
Returns: bool

Forbid¶

function Forbid(address Token, bool Disallow) public

Visibility: public
Parameters: address Token, bool Disallow

GetQing¶

function GetQing(uint256 Waat) public view returns (QING)

Visibility: public
State Mutability: view
Parameters: uint256 Waat
Returns: QING

New¶

function New(address Integrative) public returns (QING Mu)

Visibility: public
Parameters: address Integrative
Returns: QING Mu

Internal¶

addToMap¶

function addToMap(uint256 Waat, address Qing) internal

Visibility: internal
Parameters: uint256 Waat, address Qing

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 - Base functionality
CHO - Login and Luo generation
Hecke - Coordinate system

Depended On By¶

WORLD - World simulation
QING - Token wrapper

Special Mechanisms¶

QING Creation¶

function New(address Integrative) public returns(QING Mu) {
    // Check not already wrapped
    if(_qings[Integrative] != address(0x0)) revert QingAlreadyExists(...);

    // Check not forbidden
    if(_forbidden[Integrative]) revert ForbiddenToken(Integrative);

    // Check not already a QING
    if(has(Integrative, "Waat()")) revert DerivativeQing(...);

    // Generate unique Waat
    Luo = Cho.Luo() * Offset;

    // Create QING
    Mu = new QING(Luo, Integrative, address(Cho));

    // Copy ownership and name
    if(has(Integrative, "owner()")) Mu.addOwner(Asset.owner());
    if(has(Integrative, "name()") && has(Integrative, "symbol()"))
        Mu.Rename(Asset.name() + " QING", "q" + Asset.symbol());

    // Register
    _qings[Integrative] = address(Mu);
    _waats[Luo] = Mu;
    addToMap(Luo, address(Mu));
}

WITHOUT Token Ban¶

Holders of the WITHOUT token are automatically forbidden from all operations:

if(DYSNOMIA(WITHOUTContract).balanceOf(tx.origin) > 0) return true;

Geographic Registration¶

function addToMap(uint256 Waat, address Qing) internal {
    (int256 Longitude, int256 Latitude) = Map.Compliment(Waat);
    assert(_map[Latitude][Longitude] == address(0x0));
    _map[Latitude][Longitude] = Qing;
}

Contract Verification¶

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