Skip to main content
Research Preview — These examples illustrate intended patterns. The code is pseudocode for the ideas, not tested snippets, and may not match current SDK call signatures (the SDK uses object arguments — see the SDK reference). They also gate value on location, so remember: raw GPS is spoofable, and Astral verifies the computation, not that a user was truly somewhere. Use location proofs where the input needs to be trustworthy.

​
What You Can Build

One thing you can build with Astral is location-based smart contracts: by combining geospatial computation with EAS resolvers, you can gate an onchain action by real-world location. The examples below are the onchain slice of a broader capability — the same signed results work just as well offchain (agents, backends, compliance records).

​
The Pattern

1

User provides location

Creates a location record (or submits raw coordinates)
2

Astral computes

Performs spatial operation (distance, containment, etc.) in the TEE
3

Signed result

Returns a signed result with the computation output
4

Contract executes

Resolver verifies and triggers business logic

​
Local Currencies

Concept: Token pairs that can only be traded by people physically in a region. Create neighborhood economies where you must be present to participate. SF residents trade BAY tokens, NYC residents trade APPLE tokens. 
// User in San Francisco
const myLocation = await astral.location.onchain.create({ location: userGPS });
const eligibility = await astral.compute.contains(
  sfBayAreaUID,
  myLocation.uid,
  { schema: GEOGATED_SWAP_SCHEMA, submitOnchain: true }
);
// Resolver verifies location → executes swap atomically
Ideas:
  • Neighborhood currencies
  • Regional stablecoins
  • Tourism tokens (only tradeable in the city)
  • Event-specific tokens (festival currency)

​
Neighborhood DAOs

Concept: Governance tokens only mintable by residents of a specific area. 
const noeValleyDAO = new GeogatedDAO({
  region: noeValleyPolygonUID,
  tokenName: "Noe Valley Governance"
});

// Prove you live/work in the neighborhood
const proof = await astral.compute.contains(
  noeValleyPolygonUID,
  myLocationUID,
  { schema: DAO_MEMBERSHIP_SCHEMA }
);
await noeValleyDAO.join(proof);

// Vote on local issues
await noeValleyDAO.vote(proposalId, voteChoice);
Ideas:
  • Community governance
  • Co-op management
  • Neighborhood resource allocation
  • Local mutual aid networks

​
Proof-of-Visit NFTs

Concept: Collectibles you can only mint by physically visiting a location. 
// Prove you're at the Eiffel Tower
const proof = await astral.compute.within(
  myLocationUID,
  eiffelTowerUID,
  100,  // within 100 meters
  { schema: VISIT_NFT_SCHEMA, submitOnchain: true }
);

// Resolver mints NFT if you're close enough
Ideas:
  • Travel badges (collect cities/landmarks)
  • Conference attendance proofs
  • Scavenger hunts with onchain checkpoints
  • Historical site verification

​
Delivery Verification

Concept: Escrow that releases only when package arrives at the right location. 
contract DeliveryEscrow {
    bytes32 public deliveryZoneUID;

    function confirmDelivery(
        bytes32 policyAttestationUID
    ) public {
        Attestation memory att = eas.getAttestation(policyAttestationUID);

        // Verify attester
        require(att.attester == astralSigner, "Not from Astral");

        // Check: was delivery location inside the delivery zone?
        (bool wasInZone, , , ) = abi.decode(
            att.data,
            (bool, bytes32[], uint64, string)
        );

        require(wasInZone, "Wrong delivery location");
        escrow.release();
    }
}
Ideas:
  • P2P delivery marketplaces
  • Supply chain verification
  • Last-mile logistics
  • Food delivery with location proof

​
Event Check-Ins

Concept: POAPs, rewards, or access that require physical presence. 
// At a conference
const proof = await astral.compute.contains(
  conferenceVenueUID,
  myLocationUID,
  { schema: EVENT_SCHEMA, submitOnchain: true }
);

// Resolver grants access/mints POAP
Ideas:
  • Conference attendance tracking
  • Concert/festival badges
  • Meetup verification
  • Sports event proof-of-attendance

​
Proximity-Weighted Voting

Concept: Vote weight increases the closer you are to what’s being voted on. 
function vote(uint proposalId, bytes32 policyAttestationUID) public {
    // Decode distance from numeric policy attestation
    (uint256 distanceCm, , , , ) = abi.decode(...);
    uint256 distanceM = distanceCm / 100;

    // Closer = more voting power
    uint256 weight = 1000 / (distanceM + 1);
    proposals[proposalId].voteWithWeight(msg.sender, weight);
}
Ideas:
  • Local infrastructure decisions
  • Park/facility usage votes
  • Noise ordinance voting
  • Development impact assessment

​
Location-Based Marketplaces

Concept: Buy/sell only from people in your area. 
// List item (seller must be in region)
const sellerProof = await astral.compute.contains(
  regionUID,
  sellerLocationUID,
  { schema: MARKETPLACE_SCHEMA }
);
await marketplace.list(itemId, price, sellerProof);

// Buy item (buyer must be nearby seller)
const proximityProof = await astral.compute.within(
  buyerLocationUID,
  sellerLocationUID,
  5000,  // within 5km
  { schema: MARKETPLACE_SCHEMA }
);
await marketplace.buy(itemId, proximityProof);
Ideas:
  • Hyperlocal classifieds
  • Farmers markets with verified vendors
  • Tool/equipment sharing
  • Local services marketplace

​
Location-Based Games

Concept: Onchain gameplay tied to real-world movement. 
// Capture territory
const proof = await astral.compute.contains(
  territoryUID,
  myLocationUID,
  { schema: GAME_SCHEMA }
);
await game.capture(territoryId, proof);

// Battle (only if players are nearby)
const proximityProof = await astral.compute.distance(
  player1LocationUID,
  player2LocationUID,
  { schema: GAME_SCHEMA }
);
if (proximityProof.result < 100) {
  await game.battle(opponent, proximityProof);
}
Ideas:
  • Territory control games
  • AR treasure hunts
  • Geocaching with tokens
  • Location-based battles

​
Environmental Monitoring

Concept: Carbon credits and conservation proofs tied to physical locations. 
// Verify tree planting at specified location
const proof = await astral.compute.contains(
  conservationZoneUID,
  plantingSiteUID,
  { schema: CARBON_SCHEMA }
);

await carbonRegistry.registerPlanting(proof, treeCount);
// Mint carbon credits
Ideas:
  • Reforestation verification
  • Wildlife habitat monitoring
  • Pollution reporting
  • Community garden tracking

​
The Building Blocks

All of these are built with just a few core operations:
OperationUse Case Examples
distance(a, b)Proximity voting, delivery verification
contains(area, point)Geofencing, DAO membership, territorial games
within(point, target, radius)Proof-of-visit, event check-ins
intersects(a, b)Overlapping territories, coverage verification
Combined with EAS resolvers, these primitives open up a broad design space for location-aware applications — onchain and off.

Get Started

Build your first location-based dApp