@vorionsys/platform-core 0.1.0

package/dist/db/schema/merkle.d.ts

@@ -0,0 +1,475 @@
+/**
+ * Merkle Tree Schema
+ *
+ * Database schema for Merkle tree aggregation of proofs.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Merkle roots table - stores aggregated proof tree roots
+ */
+export declare const merkleRoots: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "merkle_roots";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "merkle_roots";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rootHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "root_hash";
+            tableName: "merkle_roots";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        leafCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "leaf_count";
+            tableName: "merkle_roots";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        windowStart: import("drizzle-orm/pg-core").PgColumn<{
+            name: "window_start";
+            tableName: "merkle_roots";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        windowEnd: import("drizzle-orm/pg-core").PgColumn<{
+            name: "window_end";
+            tableName: "merkle_roots";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        anchorTx: import("drizzle-orm/pg-core").PgColumn<{
+            name: "anchor_tx";
+            tableName: "merkle_roots";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        anchorChain: import("drizzle-orm/pg-core").PgColumn<{
+            name: "anchor_chain";
+            tableName: "merkle_roots";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        anchoredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "anchored_at";
+            tableName: "merkle_roots";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        treeLevels: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tree_levels";
+            tableName: "merkle_roots";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[][];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[][];
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "merkle_roots";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Merkle leaves table - maps individual proofs to their Merkle tree position
+ */
+export declare const merkleLeaves: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "merkle_leaves";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "merkle_leaves";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        proofId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "proof_id";
+            tableName: "merkle_leaves";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rootId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "root_id";
+            tableName: "merkle_leaves";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        leafIndex: import("drizzle-orm/pg-core").PgColumn<{
+            name: "leaf_index";
+            tableName: "merkle_leaves";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        leafHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "leaf_hash";
+            tableName: "merkle_leaves";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        siblingHashes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sibling_hashes";
+            tableName: "merkle_leaves";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        siblingDirections: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sibling_directions";
+            tableName: "merkle_leaves";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: boolean[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: boolean[];
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "merkle_leaves";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * Pending proofs queue - proofs waiting to be aggregated into a Merkle tree
+ */
+export declare const merkleQueue: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "merkle_queue";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "merkle_queue";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        proofId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "proof_id";
+            tableName: "merkle_queue";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        proofHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "proof_hash";
+            tableName: "merkle_queue";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        aggregated: import("drizzle-orm/pg-core").PgColumn<{
+            name: "aggregated";
+            tableName: "merkle_queue";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rootId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "root_id";
+            tableName: "merkle_queue";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        queuedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "queued_at";
+            tableName: "merkle_queue";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        aggregatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "aggregated_at";
+            tableName: "merkle_queue";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type MerkleRoot = typeof merkleRoots.$inferSelect;
+export type NewMerkleRoot = typeof merkleRoots.$inferInsert;
+export type MerkleLeaf = typeof merkleLeaves.$inferSelect;
+export type NewMerkleLeaf = typeof merkleLeaves.$inferInsert;
+export type MerkleQueueItem = typeof merkleQueue.$inferSelect;
+export type NewMerkleQueueItem = typeof merkleQueue.$inferInsert;
+//# sourceMappingURL=merkle.d.ts.map

package/dist/db/schema/merkle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.d.ts","sourceRoot":"","sources":["../../../src/db/schema/merkle.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAcH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCvB,CAAC;AAGF,MAAM,MAAM,UAAU,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AACzD,MAAM,MAAM,aAAa,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAC5D,MAAM,MAAM,UAAU,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAC7D,MAAM,MAAM,eAAe,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC"}

package/dist/db/schema/merkle.js

@@ -0,0 +1,100 @@
+/**
+ * Merkle Tree Schema
+ *
+ * Database schema for Merkle tree aggregation of proofs.
+ *
+ * @packageDocumentation
+ */
+import { pgTable, uuid, text, integer, timestamp, jsonb, index, uniqueIndex, boolean, } from 'drizzle-orm/pg-core';
+/**
+ * Merkle roots table - stores aggregated proof tree roots
+ */
+export const merkleRoots = pgTable('merkle_roots', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    /** The Merkle root hash (SHA-256 hex string) */
+    rootHash: text('root_hash').notNull(),
+    /** Number of proof leaves in this tree */
+    leafCount: integer('leaf_count').notNull(),
+    /** Time window start for proofs included in this tree */
+    windowStart: timestamp('window_start', { withTimezone: true }).notNull(),
+    /** Time window end for proofs included in this tree */
+    windowEnd: timestamp('window_end', { withTimezone: true }).notNull(),
+    /** Optional anchor transaction (for blockchain anchoring) */
+    anchorTx: text('anchor_tx'),
+    /** Anchor chain (e.g., 'ethereum', 'bitcoin') */
+    anchorChain: text('anchor_chain'),
+    /** Anchor timestamp (when anchored to blockchain) */
+    anchoredAt: timestamp('anchored_at', { withTimezone: true }),
+    /** Full tree structure for reconstruction (optional, for debugging) */
+    treeLevels: jsonb('tree_levels').$type(),
+    /** Creation timestamp */
+    createdAt: timestamp('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => ({
+    // Fast lookup by root hash
+    rootHashIdx: uniqueIndex('merkle_roots_root_hash_idx').on(table.rootHash),
+    // Query by time window
+    windowStartIdx: index('merkle_roots_window_start_idx').on(table.windowStart),
+    // Query by creation time
+    createdAtIdx: index('merkle_roots_created_at_idx').on(table.createdAt),
+    // Query for unanchored roots
+    anchorTxIdx: index('merkle_roots_anchor_tx_idx').on(table.anchorTx),
+}));
+/**
+ * Merkle leaves table - maps individual proofs to their Merkle tree position
+ */
+export const merkleLeaves = pgTable('merkle_leaves', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    /** Reference to the proof */
+    proofId: uuid('proof_id').notNull(),
+    /** Reference to the Merkle root this leaf belongs to */
+    rootId: uuid('root_id').notNull(),
+    /** Leaf index in the tree (0-based) */
+    leafIndex: integer('leaf_index').notNull(),
+    /** The leaf hash (SHA-256 of proof_id:proof_hash) */
+    leafHash: text('leaf_hash').notNull(),
+    /** Sibling hashes for proof reconstruction (JSON array) */
+    siblingHashes: jsonb('sibling_hashes').notNull().$type(),
+    /** Sibling directions (true = right, false = left) */
+    siblingDirections: jsonb('sibling_directions').notNull().$type(),
+    /** Creation timestamp */
+    createdAt: timestamp('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => ({
+    // Fast lookup by proof ID
+    proofIdIdx: uniqueIndex('merkle_leaves_proof_id_idx').on(table.proofId),
+    // Fast lookup by root ID
+    rootIdIdx: index('merkle_leaves_root_id_idx').on(table.rootId),
+    // Leaf hash lookup
+    leafHashIdx: index('merkle_leaves_leaf_hash_idx').on(table.leafHash),
+}));
+/**
+ * Pending proofs queue - proofs waiting to be aggregated into a Merkle tree
+ */
+export const merkleQueue = pgTable('merkle_queue', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    /** Reference to the proof */
+    proofId: uuid('proof_id').notNull(),
+    /** The proof's hash for leaf computation */
+    proofHash: text('proof_hash').notNull(),
+    /** Whether this proof has been aggregated */
+    aggregated: boolean('aggregated').notNull().default(false),
+    /** Reference to the Merkle root (set after aggregation) */
+    rootId: uuid('root_id'),
+    /** Queue timestamp */
+    queuedAt: timestamp('queued_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    /** Aggregation timestamp */
+    aggregatedAt: timestamp('aggregated_at', { withTimezone: true }),
+}, (table) => ({
+    // Fast lookup by proof ID
+    proofIdIdx: uniqueIndex('merkle_queue_proof_id_idx').on(table.proofId),
+    // Find pending proofs efficiently
+    aggregatedIdx: index('merkle_queue_aggregated_idx').on(table.aggregated),
+    // Order by queue time
+    queuedAtIdx: index('merkle_queue_queued_at_idx').on(table.queuedAt),
+}));
+//# sourceMappingURL=merkle.js.map

package/dist/db/schema/merkle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle.js","sourceRoot":"","sources":["../../../src/db/schema/merkle.ts"],"names":[],"mappings":"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"}