@totemsdk/raster-proof 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,189 @@
+/**
+ * @totemsdk/raster-proof — Type definitions
+ *
+ * Pure schema for raster and visual evidence proofs.
+ *
+ * This package proves bytes, manifests, provenance, windows and declared
+ * relationships. It does NOT process raster bytes — no decoding, no GDAL,
+ * no cloud masking, no NDVI, no ML. It only hashes bytes and records the
+ * metadata that makes them verifiable.
+ *
+ * No network, no storage, no map rendering, no GIS engine dependency.
+ */
+export type RasterSourceType = 'satellite' | 'drone' | 'camera' | 'robot-camera' | 'thermal-camera' | 'lidar-derived' | 'radar' | 'map-tile' | 'derived' | 'manual-import' | 'other';
+export type RasterAssetFormat = 'geotiff' | 'cog' | 'png' | 'jpeg' | 'webp' | 'mbtiles' | 'zarr' | 'npy' | 'raw' | 'other';
+export type RasterLayerType = 'rgb' | 'thermal' | 'multispectral' | 'sar' | 'lidar-derived' | 'depth' | 'change-mask' | 'water-mask' | 'vegetation-mask' | 'bare-earth-mask' | 'cloud-mask' | 'uncertainty-mask' | 'custom';
+/**
+ * Spatial context for a raster asset. Bounds are GeoJSON order:
+ * [minLon, minLat, maxLon, maxLat] (WGS84 / EPSG:4326).
+ */
+export interface RasterSpatialMetadata {
+    crs?: string;
+    bounds?: [number, number, number, number];
+    resolutionM?: number;
+    widthPx?: number;
+    heightPx?: number;
+    /** totem:geo:<hex> hash of the footprint geometry (via @totemsdk/spatial-proof). */
+    geometryHash?: string;
+    /** totem:spatial:<hex> spatial object ID the footprint maps to. */
+    spatialObjectId?: string;
+}
+export interface RasterAssetRef {
+    uri?: string;
+    mediaType?: string;
+    format: RasterAssetFormat;
+    byteSize?: number;
+    contentHash: string;
+    hashAlgorithm: 'sha3-256';
+    merkleRoot?: string;
+    chunkSizeBytes?: number;
+}
+export interface RasterProvenance {
+    derivedFrom?: string[];
+    pipelineId?: string;
+    pipelineVersion?: string;
+    parametersHash?: string;
+    operatorId?: string;
+    modelId?: string;
+    uncertainty?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface RasterManifest {
+    rasterId: string;
+    sourceType: RasterSourceType;
+    layerType: RasterLayerType;
+    capturedAt?: number;
+    createdAt: number;
+    deviceId?: string;
+    operatorId?: string;
+    missionId?: string;
+    providerId?: string;
+    sceneId?: string;
+    asset: RasterAssetRef;
+    spatial?: RasterSpatialMetadata;
+    provenance?: RasterProvenance;
+    metadata?: Record<string, unknown>;
+}
+export interface RasterChunk {
+    index: number;
+    offset: number;
+    length: number;
+    hash: string;
+}
+export interface RasterMerkleProof {
+    root: string;
+    leafHash: string;
+    leafIndex: number;
+    siblings: Array<{
+        position: 'left' | 'right';
+        hash: string;
+    }>;
+    hashAlgorithm: 'sha3-256';
+}
+export interface RasterWindowProof {
+    windowProofId: string;
+    rasterId: string;
+    merkleRoot: string;
+    chunkIndices: number[];
+    chunkHashes: string[];
+    spatial?: RasterSpatialMetadata;
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+}
+export interface RasterValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export interface RasterMerkleSummary {
+    contentHash: string;
+    merkleRoot: string;
+    chunkSizeBytes: number;
+    chunkCount: number;
+    byteSize: number;
+}
+export interface RasterMerkleOptions {
+    chunkSizeBytes?: number;
+}
+export interface CreateRasterManifestParams {
+    sourceType: RasterSourceType;
+    layerType: RasterLayerType;
+    asset: RasterAssetRef;
+    capturedAt?: number;
+    createdAt?: number;
+    deviceId?: string;
+    operatorId?: string;
+    missionId?: string;
+    providerId?: string;
+    sceneId?: string;
+    spatial?: RasterSpatialMetadata;
+    provenance?: RasterProvenance;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateDerivedRasterManifestParams {
+    sourceManifests: RasterManifest[];
+    layerType: RasterLayerType;
+    asset: RasterAssetRef;
+    capturedAt?: number;
+    createdAt?: number;
+    deviceId?: string;
+    operatorId?: string;
+    missionId?: string;
+    providerId?: string;
+    sceneId?: string;
+    spatial?: RasterSpatialMetadata;
+    pipelineId?: string;
+    pipelineVersion?: string;
+    parametersHash?: string;
+    modelId?: string;
+    uncertainty?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface CreateRasterWindowProofParams {
+    rasterId: string;
+    merkleRoot: string;
+    chunkIndices: number[];
+    chunkHashes: string[];
+    spatial?: RasterSpatialMetadata;
+    createdAt?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface RasterDerivationVerifyResult {
+    valid: boolean;
+    reasons?: string[];
+    sourceRasterIds?: string[];
+    missingSources?: string[];
+    uncertainty?: string[];
+}
+export interface CreateRasterSpatialRelationParams {
+    manifest: RasterManifest;
+    /** Spatial object from @totemsdk/spatial-proof (site boundary, zone, route, …). */
+    spatialObject: import('@totemsdk/spatial-proof').SpatialObject;
+    relation: import('@totemsdk/spatial-proof').SpatialRelationType;
+    computedAt?: number;
+    maxDistanceM?: number;
+    subjectProofId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateRasterProofParams {
+    manifest: RasterManifest;
+    windowProof?: RasterWindowProof;
+    /** Full Merkle proofs for chunks referenced by windowProof (optional, enables leaf-level verification). */
+    merkleProofs?: RasterMerkleProof[];
+    /** Spatial object ID referenced by the raster footprint (added as evidence ref). */
+    spatialObjectId?: string;
+    issuer?: string;
+    issuedAt?: number;
+    expiresAt?: number;
+}
+export interface RasterProofVerifyResult {
+    valid: boolean;
+    reason?: string;
+    signerAddress?: string;
+    rasterId?: string;
+    payloadValid?: boolean;
+    rasterIdValid?: boolean;
+    manifestHashValid?: boolean;
+    windowProofValid?: boolean;
+    derivationValid?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * @totemsdk/raster-proof — Type definitions
+ *
+ * Pure schema for raster and visual evidence proofs.
+ *
+ * This package proves bytes, manifests, provenance, windows and declared
+ * relationships. It does NOT process raster bytes — no decoding, no GDAL,
+ * no cloud masking, no NDVI, no ML. It only hashes bytes and records the
+ * metadata that makes them verifiable.
+ *
+ * No network, no storage, no map rendering, no GIS engine dependency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/window.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Raster window / tile proof construction for @totemsdk/raster-proof.
+ *
+ * A window proof attests that a subset of chunks (a spatial window, a tile,
+ * a scene patch) belongs to a raster whose Merkle root is known. It carries
+ * the chunk indices and their content hashes so a verifier can tie a specific
+ * set of bytes to the root without re-hashing the whole asset.
+ */
+import type { EvidenceRef } from '@totemsdk/proof';
+import type { CreateRasterWindowProofParams, RasterWindowProof } from './types.js';
+/**
+ * Create a deterministic RasterWindowProof. windowProofId is computed from
+ * stable fields (everything except windowProofId and metadata).
+ */
+export declare function createRasterWindowProof(params: CreateRasterWindowProofParams): RasterWindowProof;
+/**
+ * Convert a RasterWindowProof into an EvidenceRef for inclusion in a proof.
+ */
+export declare function rasterWindowProofToEvidenceRef(proof: RasterWindowProof): EvidenceRef;

package/dist/window.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Raster window / tile proof construction for @totemsdk/raster-proof.
+ *
+ * A window proof attests that a subset of chunks (a spatial window, a tile,
+ * a scene patch) belongs to a raster whose Merkle root is known. It carries
+ * the chunk indices and their content hashes so a verifier can tie a specific
+ * set of bytes to the root without re-hashing the whole asset.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRasterWindowProof = createRasterWindowProof;
+exports.rasterWindowProofToEvidenceRef = rasterWindowProofToEvidenceRef;
+const canonical_js_1 = require("./canonical.js");
+/**
+ * Create a deterministic RasterWindowProof. windowProofId is computed from
+ * stable fields (everything except windowProofId and metadata).
+ */
+function createRasterWindowProof(params) {
+    const { rasterId, merkleRoot, chunkIndices, chunkHashes, spatial, createdAt = Date.now(), metadata } = params;
+    if (chunkIndices.length === 0) {
+        throw new Error('a window proof must reference at least one chunk');
+    }
+    if (chunkIndices.length !== chunkHashes.length) {
+        throw new Error('chunkIndices and chunkHashes must have equal length');
+    }
+    for (const idx of chunkIndices) {
+        if (!Number.isInteger(idx) || idx < 0) {
+            throw new Error('chunk indices must be non-negative integers');
+        }
+    }
+    for (const h of chunkHashes) {
+        if (!/^[a-f0-9]{64}$/.test(h)) {
+            throw new Error('chunk hashes must be 64-char lowercase hex (sha3-256)');
+        }
+    }
+    if (!/^[a-f0-9]{64}$/.test(merkleRoot)) {
+        throw new Error('merkleRoot must be 64-char lowercase hex (sha3-256)');
+    }
+    const body = {
+        rasterId,
+        merkleRoot,
+        chunkIndices,
+        chunkHashes,
+        ...(spatial !== undefined ? { spatial } : {}),
+        createdAt,
+        ...(metadata !== undefined ? { metadata } : {}),
+    };
+    return { ...body, windowProofId: (0, canonical_js_1.computeRasterWindowProofId)(body) };
+}
+/**
+ * Convert a RasterWindowProof into an EvidenceRef for inclusion in a proof.
+ */
+function rasterWindowProofToEvidenceRef(proof) {
+    return {
+        id: proof.windowProofId,
+        kind: 'raster-window-proof',
+        hash: (0, canonical_js_1.hashRasterWindowProof)(proof),
+    };
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@totemsdk/raster-proof",
+  "version": "0.1.0",
+  "description": "Edge-capable raster and visual evidence proof primitives for Totem Edge — asset hashes, tile Merkle roots, raster manifests, derived-layer provenance, and proof envelope integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@totemsdk/core": "^1.2.7",
+    "@totemsdk/proof": "^0.1.2",
+    "@totemsdk/proofgraph": "^0.1.1",
+    "@totemsdk/spatial-proof": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.0.0",
+    "jest": "^30.4.2",
+    "ts-jest": "^29.0.0",
+    "typescript": "^7.0.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "Totem SDK",
+  "homepage": "https://totem.ing",
+  "bugs": {
+    "url": "https://github.com/totem-sdk/totem-sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
+    "directory": "packages/raster-proof"
+  },
+  "keywords": [
+    "totem",
+    "totemsdk",
+    "raster",
+    "imagery",
+    "drone",
+    "satellite",
+    "geotiff",
+    "proof",
+    "merkle",
+    "edge",
+    "visual-evidence",
+    "spatial",
+    "autonomous-devices"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "jest"
+  }
+}