Seismic Liquidity: Geospatial Parimutuel Markets
A decentralized physical infrastructure network (DePIN) for hedging geophysical risks. Move beyond binary prediction markets with continuous spatial scoring using Inverse Seismo-Distance Weighting (ISDW) and on-chain geospatial computation.
Three Proximity Frameworks
Our protocol supports multiple distance metrics, allowing markets to capture nuanced predictions beyond simple yes/no outcomes.
Semantic Proximity
Measures similarity in meaning using natural language embeddings. Predictions are scored based on conceptual alignment with actual outcomes.
Structural Proximity
Evaluates graph-based relationships and network structures. Captures how entities relate to each other in complex systems.
Euclidean Proximity
Great Circle distance using Haversine formula for spherical coordinates. Real-world applications for earthquake hedging, disaster relief, and parametric insurance with sub-kilometer precision.
Continuous Fields vs Binary Markets
Traditional prediction markets force complex phenomena into binary outcomes: 'Will an earthquake occur in Japan?' This fails to capture spatial precision and creates inefficient hedging.
Our protocol uses continuous spatial fields for real-world coordinates. When an earthquake occurs, we measure the distance between your predicted location and the actual epicenter using Great Circle distance.
This enables true geospatial hedging: "Protect my property at 37.7749°N, 122.4194°W" rather than coarse regional binary bets. Combines DeFi liquidity with parametric insurance precision.
[35.6895°N, 139.6917°E][35.6950°N, 139.7130°E]Closer distance = higher ISDW score = greater pro-rata payout from pool
Mathematical Foundations
The protocol implements rigorous geospatial mathematics for continuous field scoring and parimutuel payouts.
Core Formula
$$S_i$$ = Total score for user i
$$M_j$$ = Magnitude of earthquake j
$$d_j$$ = Great circle distance between user prediction and earthquake epicenter (km)
$$\\epsilon$$ = Smoothing factor (1 km) to prevent division by zero
$$n$$ = Number of qualifying earthquakes (M ≥ 4.5)
Physical Justification
The inverse square decay mirrors how seismic intensity attenuates with distance. Magnitude weighting uses exponential scaling ($$10^{(M-4.5)}$$) matching Richter scale energy release. This aligns financial incentives with physical reality.
Decentralized Parimutuel Architecture
A novel financial primitive combining horse racing parimutuel dynamics with continuous spatial fields for real-world risk hedging.
24-Hour Rounds
Daily betting windows aligned with USGS real-time earthquake feeds. Markets close at UTC midnight, resolved within 1 hour using Chainlink oracles.
Dynamic Pool Distribution
Pro-rata payout based on ISDW scores. No fixed odds—your payout adjusts based on total participant accuracy and pool size.
Precision Incentives
Exponential reward for proximity. Being 1km away vs 10km away yields dramatically different payouts due to inverse square decay.
Parametric Settlement
Objective, transparent resolution using USGS GeoJSON feeds. No claims adjusters, no disputes—pure data-driven payouts.
Predicted exact epicenter of M7.8 earthquake
Predicted location 14km from actual M7.8 epicenter
Analysis: With $$\epsilon=1$$ km, a 14km miss results in a 99.5% reduction in score. The inverse square decay creates extreme precision incentives, mirroring how seismic intensity physically attenuates with distance.
EVM Implementation & Oracle Architecture
Solidity smart contracts with fixed-point arithmetic, Bhaskara I trigonometry, and Chainlink Functions for USGS data ingestion.
Fixed-Point Math
18-decimal WAD precision for trigonometry without floating-point operations
Bhaskara I Trig
7th-century rational approximation for gas-efficient sin/cos (<0.16% error)
Chainlink Oracle
Decentralized computation for global score aggregation from USGS feeds
On-Chain Claims
Verify individual scores on-chain, trust oracle for global sum only
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
contract SeismicParimutuel {
// Precision constants
uint256 constant WAD = 1e18;
int256 constant GEO_SCALE = 1e6; // 6 decimals for Lat/Lon
uint256 constant EARTH_RADIUS = 6371 * WAD;
uint256 constant MAG_THRESHOLD = 45; // 4.5 * 10
uint256 constant EPSILON = 1 * WAD; // 1 km smoothing
struct Coordinate {
int256 lat;
int256 lon;
}
struct Round {
uint256 id;
uint256 endTime;
uint256 totalPool;
uint256 globalScoreSum;
bool resolved;
}
mapping(uint256 => mapping(address => Coordinate)) public bets;
mapping(uint256 => mapping(address => uint256)) public stakes;
function placeBet(int256 lat, int256 lon) external payable {
require(lat >= -90 * GEO_SCALE && lat <= 90 * GEO_SCALE);
require(lon >= -180 * GEO_SCALE && lon <= 180 * GEO_SCALE);
bets[currentRoundId][msg.sender] = Coordinate(lat, lon);
stakes[currentRoundId][msg.sender] += msg.value;
}
function claim(uint256 roundId) external {
uint256 userScore = _calculateScore(...);
uint256 payout = (userScore * totalPool) / globalScoreSum;
payable(msg.sender).transfer(payout);
}
}Human-Sensor Mining Network
A decentralized seismic verification protocol leveraging human perception as a distributed sensor network. By combining geospatial hashing, bonding curve economics, and proof-of-proximity verification, we create real-time earthquake detection faster than centralized systems.
P-Wave Detection
Humans detect non-destructive P-waves before S-waves arrive, creating a critical early warning window
Geospatial Hashing
Earth discretized into tradeable tiles using Z-order curve interleaving for efficient neighbor finding
Bonding Curve Markets
Linear AMM pricing rewards early detection—supply drives price, incentivizing first responders
Walking Mechanic
Proof-of-proximity via Manhattan distance token burns—closer bets have lower claim costs
Attack Resistance
Walking costs neutralize spray-and-pray attacks and GPS spoofing by economic disincentives
Real-Time Verification
Chainlink oracles fetch USGS data, verify epicenter, and distribute rewards to accurate sensors
The Earth is discretized into a grid using Geohashing—a hierarchical spatial indexing system. Latitude and longitude are interleaved at the bit level using a Z-order curve (Morton encoding), creating a single uint64 token ID that preserves spatial locality.
// Solidity Geohash Encoding (Interleave)
function interleave(uint32 x, uint32 y) internal pure returns (uint64) {
uint64 B[] = [0x5555555555555555, 0x3333333333333333,
0x0F0F0F0F0F0F0F0F, 0x00FF00FF00FF00FF];
uint64 S[] = [1, 2, 4, 8];
uint64 xu = uint64(x);
uint64 yu = uint64(y);
// Spread bits
xu = (xu | (xu << S[3])) & B[3];
xu = (xu | (xu << S[2])) & B[2];
xu = (xu | (xu << S[1])) & B[1];
xu = (xu | (xu << S[0])) & B[0];
yu = (yu | (yu << S[3])) & B[3];
yu = (yu | (yu << S[2])) & B[2];
yu = (yu | (yu << S[1])) & B[1];
yu = (yu | (yu << S[0])) & B[0];
return xu | (yu << 1); // Interleave: X in even bits, Y in odd bits
}// Solidity Geohash Decoding (Deinterleave)
function deinterleave(uint64 code) internal pure returns (uint32 x, uint32 y) {
uint64 t = code & 0x5555555555555555; // Extract even bits (X)
t = (t ^ (t >> 1)) & 0x3333333333333333;
t = (t ^ (t >> 2)) & 0x0f0f0f0f0f0f0f0f;
t = (t ^ (t >> 4)) & 0x00ff00ff00ff00ff;
t = (t ^ (t >> 8)) & 0x0000ffff0000ffff;
t = (t ^ (t >> 16)) & 0x00000000ffffffff;
x = uint32(t);
t = (code >> 1) & 0x5555555555555555; // Extract odd bits (Y)
// ... repeat compression
y = uint32(t);
}Neighbor Finding via Grid Coordinates
Earthquakes don't respect tile boundaries. Using integer grid coordinates (X, Y) derived from deinterleaving, we can trivially compute the 8 surrounding neighbors (Moore Neighborhood) to reward users on adjacent tiles:
// Find neighbors in cardinal and diagonal directions
North: (X, Y+1) Northeast: (X+1, Y+1)
South: (X, Y-1) Northwest: (X-1, Y+1)
East: (X+1, Y) Southeast: (X+1, Y-1)
West: (X-1, Y) Southwest: (X-1, Y-1)
// Re-interleave to get neighbor Geohash token IDsWhy Z-Order Curves?
- • Spatial Locality: Nearby points map to nearby integers
- • Efficient Storage: Single uint64 per tile (vs. struct with lat/lon)
- • Fast Neighbor Queries: ±1 arithmetic operations on grid
- • ERC-1155 Compatible: Each tile is a tradeable NFT
Applications Across Domains
Spatial prediction markets unlock forecasting capabilities for complex, multi-dimensional phenomena.
Disaster Response
Predict disaster impact zones and resource needs with geographic precision.
Market Forecasting
Forecast economic indicators across multiple correlated dimensions.
Health Outcomes
Model complex health scenarios with multi-factor outcome spaces.
Climate Modeling
Track evolving climate patterns in high-dimensional parameter space.
ISDW Calculator
Test the Inverse Seismo-Distance Weighting formula with custom coordinates and earthquake parameters.