@vorionsys/contracts 0.1.0 → 0.1.2

package/dist/db/proofs.d.ts

@@ -0,0 +1,412 @@
+/**
+ * Proof Schema
+ *
+ * Database schema for immutable proof records with hash chain integrity.
+ *
+ * @packageDocumentation
+ */
+import type { Decision } from '../common/types.js';
+/**
+ * Proofs table - immutable evidence records
+ */
+export declare const proofs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "proofs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        chainPosition: import("drizzle-orm/pg-core").PgColumn<{
+            name: "chain_position";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        intentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "intent_id";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        entityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        decision: import("drizzle-orm/pg-core").PgColumn<{
+            name: "decision";
+            tableName: "proofs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Decision;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Decision;
+        }>;
+        inputs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "inputs";
+            tableName: "proofs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        outputs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "outputs";
+            tableName: "proofs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        hash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hash";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        previousHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "previous_hash";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        signature: import("drizzle-orm/pg-core").PgColumn<{
+            name: "signature";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        signaturePublicKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "signature_public_key";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        signatureAlgorithm: import("drizzle-orm/pg-core").PgColumn<{
+            name: "signature_algorithm";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        signedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "signed_at";
+            tableName: "proofs";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "proofs";
+            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";
+}>;
+/**
+ * Proof chain metadata - tracks chain state
+ */
+export declare const proofChainMeta: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "proof_chain_meta";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "proof_chain_meta";
+            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;
+        }, {}, {}>;
+        chainId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "chain_id";
+            tableName: "proof_chain_meta";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_hash";
+            tableName: "proof_chain_meta";
+            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;
+        }, {}, {}>;
+        chainLength: import("drizzle-orm/pg-core").PgColumn<{
+            name: "chain_length";
+            tableName: "proof_chain_meta";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastVerifiedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_verified_at";
+            tableName: "proof_chain_meta";
+            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;
+        }, {}, {}>;
+        lastVerifiedPosition: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_verified_position";
+            tableName: "proof_chain_meta";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "proof_chain_meta";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "proof_chain_meta";
+            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";
+}>;
+export type Proof = typeof proofs.$inferSelect;
+export type NewProof = typeof proofs.$inferInsert;
+export type ProofChainMeta = typeof proofChainMeta.$inferSelect;
+//# sourceMappingURL=proofs.d.ts.map

package/dist/db/proofs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proofs.d.ts","sourceRoot":"","sources":["../../src/db/proofs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAYH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4ClB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAazB,CAAC;AAGH,MAAM,MAAM,KAAK,GAAG,OAAO,MAAM,CAAC,YAAY,CAAC;AAC/C,MAAM,MAAM,QAAQ,GAAG,OAAO,MAAM,CAAC,YAAY,CAAC;AAClD,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC"}

package/dist/db/proofs.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Proof Schema
+ *
+ * Database schema for immutable proof records with hash chain integrity.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proofChainMeta = exports.proofs = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+/**
+ * Proofs table - immutable evidence records
+ */
+exports.proofs = (0, pg_core_1.pgTable)('proofs', {
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    chainPosition: (0, pg_core_1.integer)('chain_position').notNull(),
+    intentId: (0, pg_core_1.uuid)('intent_id').notNull(),
+    entityId: (0, pg_core_1.uuid)('entity_id').notNull(),
+    // Decision details
+    decision: (0, pg_core_1.jsonb)('decision').notNull().$type(),
+    // Execution context
+    inputs: (0, pg_core_1.jsonb)('inputs').notNull().$type(),
+    outputs: (0, pg_core_1.jsonb)('outputs').notNull().$type(),
+    // Chain integrity
+    hash: (0, pg_core_1.text)('hash').notNull(),
+    previousHash: (0, pg_core_1.text)('previous_hash').notNull(),
+    // Cryptographic signature
+    signature: (0, pg_core_1.text)('signature').notNull(),
+    signaturePublicKey: (0, pg_core_1.text)('signature_public_key'),
+    signatureAlgorithm: (0, pg_core_1.text)('signature_algorithm'),
+    signedAt: (0, pg_core_1.timestamp)('signed_at', { withTimezone: true }),
+    // Timestamps
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => ({
+    // Unique chain position for ordering
+    chainPositionIdx: (0, pg_core_1.uniqueIndex)('proofs_chain_position_idx').on(table.chainPosition),
+    // Fast lookups by entity
+    entityIdIdx: (0, pg_core_1.index)('proofs_entity_id_idx').on(table.entityId),
+    // Fast lookups by intent
+    intentIdIdx: (0, pg_core_1.index)('proofs_intent_id_idx').on(table.intentId),
+    // Chain verification queries
+    hashIdx: (0, pg_core_1.index)('proofs_hash_idx').on(table.hash),
+    // Time-based queries
+    createdAtIdx: (0, pg_core_1.index)('proofs_created_at_idx').on(table.createdAt),
+}));
+/**
+ * Proof chain metadata - tracks chain state
+ */
+exports.proofChainMeta = (0, pg_core_1.pgTable)('proof_chain_meta', {
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    chainId: (0, pg_core_1.text)('chain_id').notNull().default('default'),
+    lastHash: (0, pg_core_1.text)('last_hash').notNull(),
+    chainLength: (0, pg_core_1.integer)('chain_length').notNull().default(0),
+    lastVerifiedAt: (0, pg_core_1.timestamp)('last_verified_at', { withTimezone: true }),
+    lastVerifiedPosition: (0, pg_core_1.integer)('last_verified_position'),
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: (0, pg_core_1.timestamp)('updated_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});
+//# sourceMappingURL=proofs.js.map

package/dist/db/proofs.js.map

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