Hecke¶

Overview¶

Hecke implements a geographic coordinate system with 90 meridian bands. It maps large numbers (Waat values) to latitude/longitude coordinates, enabling location-based token mechanics.

Kind: Contract
License: Sharia
Solidity: ^0.8.21
Source: lib/heckemeridians.sol

Inheritance Chain (C3 Linearized)¶

Immediate Parents¶

DYSNOMIA

What This Means For Players¶

Plain English Summary: Hecke is the coordinate system - it turns numbers into map locations. Every QING has a "Waat" (position number) that Hecke converts into latitude and longitude coordinates. This is how the game places venues on the world map.

Real-World Analogy: Think of Hecke like a GPS system that converts numerical addresses into physical locations. Just as your GPS turns an address into "you are here" on a map, Hecke turns a Waat number into a specific latitude/longitude position in the Dysnomia world.

How It Affects Your Gameplay: - Map positions - Every venue has a unique position calculated by Hecke - 90 meridian bands - The world is divided into 90 zones from south to north - Territory proximity - When claiming territory, your distance from venues is calculated using Hecke coordinates - Geographic lookup - Find which venue is at any given coordinates

State Variables¶

Variable	Type	Visibility	Mutability	Initial Value
`Meridians`	`uint256[90]`	public	mutable	`[
476733977057179,
3256639860692891,
...`

Constructor¶

constructor¶

constructor(address ChoAddress) DYSNOMIA("Dysnomia Hecke", "HECKE", address(DYSNOMIA(ChoAddress).Xiao()))

Modifiers: DYSNOMIA("Dysnomia Hecke", "HECKE", address(DYSNOMIA(ChoAddress).Xiao()))
Parameters: address ChoAddress

Functions¶

External & Public¶

Compliment¶

function Compliment(uint256 Waat) public view returns (int256 Longitude, int256 Latitude)

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

GetWaat¶

function GetWaat(int256 Latitude) public view returns (uint256 Waat)

Visibility: public
State Mutability: view
Parameters: int256 Latitude
Returns: uint256 Waat

GetMeridian¶

function GetMeridian(uint256 Waat) public view returns (uint256 Meridian)

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

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)

Meridians Array¶

The Meridians array contains exponentially increasing boundary values:

Meridians[0]  = 476733977057179         // ~4.7e14
Meridians[1]  = 3256639860692891        // ~3.2e15
...
Meridians[88] = 394003890037732925341349197890665503744188106368861304015211794431709973855
Meridians[89] = 788007780075465850682698395781331007488376212737722608030423588863419947711

The array represents: - Meridians 0-88: Southern to Northern hemisphere bands - Meridian 89: Maximum value (wraps to north pole)

Contract Interactions¶

Depends On¶

DYSNOMIA V2 - Base functionality
CHO - Receives market rate

Depended On By¶

MAP - Uses for coordinate mapping
WORLD - Geographic operations

Special Mechanisms¶

Coordinate System¶

         North Pole (Meridian 89)
              ↑
    +Lat  ←---|---→  -Lat
              |
         South Pole (Meridian 0)

    West ← Longitude → East
    (-X)              (+X)

Compliment Algorithm¶

1. Assert Waat <= Meridians[89]
2. Get Meridian index
3. If Meridian == 89:
   - Flip to northern hemisphere
   - Recalculate from inverse
4. Calculate Latitude from Meridians[88] distance
5. Calculate Longitude within meridian band:
   - First half: positive longitude
   - Second half: negative longitude
6. Scale Latitude by 333
7. Apply hemisphere sign

Latitude Scaling¶

Latitude is divided by 333 to compress the large Waat values into manageable coordinate ranges.

Hemisphere Handling¶

Values above Meridian 88 represent the northern hemisphere, handled by subtracting from the maximum and recalculating.

Usage Pattern¶

// Get coordinates for a Waat value
(int256 lon, int256 lat) = hecke.Compliment(someWaat);

// Find meridian for a value
uint256 meridian = hecke.GetMeridian(someWaat);

// Get Waat for latitude
uint256 waat = hecke.GetWaat(lat);

Geographic Token Mechanics¶

The Hecke system enables: 1. Location-based tokens: Each QING token has a Waat that maps to coordinates 2. Proximity checks: Determine if tokens are in the same region 3. Territory mechanics: Define areas based on meridian bands 4. Distance calculations: Compare Waat values for relative position

Example Mapping¶

Waat = 476733977057179 (Meridian 0 boundary)
→ Near equator, specific longitude

Waat = 394003890037732925... (Meridian 88)
→ Near north pole, high latitude

Waat between boundaries
→ Proportional position within band

Integration with MAP¶

The MAP contract uses Hecke to: 1. Assign geographic position to new QING tokens 2. Organize tokens by location 3. Enable location-based lookup via _map[Latitude][Longitude]

Contract Verification¶

Property	Value
Keccak256 Hash	`0x43eaadc802dbc2559957b17ac5f11129b3490732c0c2e8a44b7e38395f4a74de`
Source URL	https://raw.githubusercontent.com/busytoby/atropa_pulsechain/main/solidity/dysnomia/lib/heckemeridians.sol
Hash Generated	2026-04-17T20:48:16Z