import { AstralSDK } from '@decentralized-geo/astral-sdk';

const astral = new AstralSDK({
  chainId: 84532,
  signer: wallet,
  apiUrl: 'https://api.astral.global'
});

// Compute a policy check
const result = await astral.compute.within(
  userLocationUID,
  landmarkUID,
  500,
  { schema: SCHEMA_UID, recipient: userAddress }
);

// Submit to EAS if check passed
if (result.result) {
  const submission = await astral.compute.submit(result.delegatedAttestation);
  console.log('Attestation UID:', submission.uid);
}

// Estimate gas before submitting
const gas = await astral.compute.estimate(result.delegatedAttestation);
console.log('Estimated gas:', gas.toString());

// Submit with confidence
if (gas < 300000n) {
  await astral.compute.submit(result.delegatedAttestation);
}

interface DelegatedAttestation {
  message: {
    schema: string;         // EAS schema UID
    recipient: string;      // Attestation recipient
    expirationTime: bigint; // When attestation expires
    revocable: boolean;     // Whether can be revoked
    refUID: string;         // Reference UID (empty for new)
    data: string;           // Encoded attestation data
    value: bigint;          // ETH value (usually 0)
    nonce: bigint;          // Attester nonce
    deadline: bigint;       // Signature deadline
  };
  signature: {
    v: number;
    r: string;
    s: string;
  };
  attester: string;         // Astral signer address
}

const result = await astral.compute.within(uid1, uid2, 500, options);

// Check deadline
const deadline = result.delegatedAttestation.message.deadline;
const now = BigInt(Math.floor(Date.now() / 1000));

if (now < deadline) {
  // Signature still valid
  await astral.compute.submit(result.delegatedAttestation);
} else {
  // Signature expired - request new computation
  const newResult = await astral.compute.within(uid1, uid2, 500, options);
  await astral.compute.submit(newResult.delegatedAttestation);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@eas/contracts/resolver/SchemaResolver.sol";

contract MyResolver is SchemaResolver {
    address public astralSigner;

    constructor(IEAS eas, address _astralSigner)
        SchemaResolver(eas)
    {
        astralSigner = _astralSigner;
    }

    function onAttest(
        Attestation calldata attestation,
        uint256 /*value*/
    ) internal override returns (bool) {
        // 1. Verify from Astral
        require(attestation.attester == astralSigner, "Not from Astral");

        // 2. Decode the result
        (
            bool result,
            bytes32[] memory inputRefs,
            uint64 timestamp,
            string memory operation
        ) = abi.decode(
            attestation.data,
            (bool, bytes32[], uint64, string)
        );

        // 3. Business logic
        if (result) {
            // Policy passed - execute action
        }

        return true;
    }

    function onRevoke(Attestation calldata, uint256)
        internal pure override returns (bool)
    {
        return false;
    }
}

uint256 eventTimestamp,string srs,string locationType,string location,string[] recipeType,string[] recipePayload,string[] mediaType,string[] mediaData,string memo

// Build unsigned attestation
const unsigned = await astral.location.build({
  location: { type: 'Point', coordinates: [lon, lat] },
  memo: 'My location'
});

// Encode for EAS
const encoded = astral.location.encode(unsigned);

// Decode from EAS data
const decoded = astral.location.decode(encodedData);
console.log(decoded.location);
console.log(decoded.memo);

const attestation = await astral.location.offchain.create({
  location: geojson
});
// attestation.signature contains EIP-712 signature
// attestation.uid is derived from content hash

const attestation = await astral.location.onchain.create({
  location: geojson
});
// attestation.txHash contains transaction hash
// attestation.uid is from EAS contract

const customSchema = {
  uid: '0x1234...abcd',  // Your schema UID
  rawString: 'uint256 eventTimestamp,string srs,string locationType,string location,string[] recipeType,string[] recipePayload,string[] mediaType,string[] mediaData,string memo'
};

// Use at initialization
const astral = new AstralSDK({
  chainId: 84532,
  signer: wallet,
  defaultSchema: customSchema
});

// Or per-operation
const attestation = await astral.location.offchain.create(
  { location: geojson },
  { schema: customSchema }
);