@degenerate/generic 0.4.0 → 0.7.0

package/dist/library/in-memory-library-store.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryLibraryStore = void 0;
+const library_errors_1 = require("../errors/library/library-errors");
+const verify_library_1 = require("./verify-library");
+const clone = (value) => JSON.parse(JSON.stringify(value));
+/**
+ * Asserts that `next` extends `existing` append-only: it must keep every
+ * existing version (by `currentHash`, in order) and may only grow. Truncation
+ * or divergence is a {@link LibraryStoreConflictError}.
+ */
+const assertAppendOnly = (existing, next) => {
+    if (next.versions.length < existing.versions.length) {
+        throw new library_errors_1.LibraryStoreConflictError(existing.id, 'history truncated');
+    }
+    for (let i = 0; i < existing.versions.length; i += 1) {
+        if (existing.versions[i].currentHash !== next.versions[i].currentHash) {
+            throw new library_errors_1.LibraryStoreConflictError(existing.id, `version ${i} diverges from stored history`);
+        }
+    }
+};
+/**
+ * In-memory {@link LibraryStore}. Deep-copies on the way in and out so callers
+ * cannot mutate stored state by reference, and re-verifies on every read.
+ *
+ * The optional `seed` models data already present in a backend: it is stored
+ * WITHOUT verification, precisely so that the re-verify-on-read contract is what
+ * catches a tampered backing record.
+ */
+class InMemoryLibraryStore {
+    constructor(seed = []) {
+        this.entities = new Map();
+        for (const entity of seed) {
+            this.entities.set(entity.id, clone(entity));
+        }
+    }
+    async get(id) {
+        const stored = this.entities.get(id);
+        if (!stored) {
+            return undefined;
+        }
+        (0, verify_library_1.verifyLibraryEntity)(stored); // never trust the backing data
+        return clone(stored);
+    }
+    async getVersion(id, currentHash) {
+        const entity = await this.get(id);
+        return entity?.versions.find((version) => version.currentHash === currentHash);
+    }
+    async has(id) {
+        return this.entities.has(id);
+    }
+    async list(filter) {
+        return this.search({ kind: filter?.kind });
+    }
+    async search(query) {
+        const text = query.text?.trim().toLowerCase();
+        const result = [];
+        for (const stored of this.entities.values()) {
+            (0, verify_library_1.verifyLibraryEntity)(stored); // re-verify before exposing
+            if (query.kind && stored.kind !== query.kind) {
+                continue;
+            }
+            if (query.ownerPublicKey && stored.owner.publicKey !== query.ownerPublicKey) {
+                continue;
+            }
+            if (text && !`${stored.name} ${stored.description}`.toLowerCase().includes(text)) {
+                continue;
+            }
+            result.push(clone(stored));
+        }
+        return result;
+    }
+    async save(entity) {
+        (0, verify_library_1.verifyLibraryEntity)(entity); // verify on write
+        const existing = this.entities.get(entity.id);
+        if (existing) {
+            // Ids are content-addressed (id = hash of the first version's
+            // source), so two owners who publish identical source collide on id.
+            // Reject the second — an existing id may not be re-registered under a
+            // different owner (no id hijack); the entity already exists to reuse.
+            if (existing.owner.publicKey !== entity.owner.publicKey) {
+                throw new library_errors_1.LibraryStoreConflictError(entity.id, 'id already registered by another owner');
+            }
+            assertAppendOnly(existing, entity);
+        }
+        this.entities.set(entity.id, clone(entity));
+    }
+    async delete(id) {
+        this.entities.delete(id);
+    }
+}
+exports.InMemoryLibraryStore = InMemoryLibraryStore;

package/dist/library/index.d.ts

@@ -0,0 +1,18 @@
+export * from './library-models';
+export * from './canonical-json';
+export * from './library-hash';
+export * from './library-proof';
+export * from './authorize-library';
+export * from './build-library';
+export * from './verify-library';
+export * from './library-store';
+export * from './in-memory-library-store';
+export * from './caching-library-store';
+export * from './remote-library-models';
+export * from './remote-library-store';
+export * from './library-server';
+export * from './evaluate-library';
+export * from './library-reference';
+export * from './evaluate-library-rules';
+export * from './compile-rule-source';
+//# sourceMappingURL=index.d.ts.map

package/dist/library/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/library/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC"}

package/dist/library/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./library-models"), exports);
+__exportStar(require("./canonical-json"), exports);
+__exportStar(require("./library-hash"), exports);
+__exportStar(require("./library-proof"), exports);
+__exportStar(require("./authorize-library"), exports);
+__exportStar(require("./build-library"), exports);
+__exportStar(require("./verify-library"), exports);
+__exportStar(require("./library-store"), exports);
+__exportStar(require("./in-memory-library-store"), exports);
+__exportStar(require("./caching-library-store"), exports);
+__exportStar(require("./remote-library-models"), exports);
+__exportStar(require("./remote-library-store"), exports);
+__exportStar(require("./library-server"), exports);
+__exportStar(require("./evaluate-library"), exports);
+__exportStar(require("./library-reference"), exports);
+__exportStar(require("./evaluate-library-rules"), exports);
+__exportStar(require("./compile-rule-source"), exports);

package/dist/library/library-hash.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Content hash of a library version: SHA-256 over the canonical JSON of
+ * `{ source, previousHash }`. Binds BEHAVIOUR ONLY — the source and its chain
+ * position — and deliberately excludes `createdAt`, `name`, and `description`
+ * so identity stays purely content-addressed. Those mutable fields are made
+ * tamper-evident by the version's signature instead, not by this hash.
+ */
+export declare const computeVersionHash: (source: string, previousHash: string) => string;
+//# sourceMappingURL=library-hash.d.ts.map

package/dist/library/library-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-hash.d.ts","sourceRoot":"","sources":["../../src/library/library-hash.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,EAAE,cAAc,MAAM,KAAG,MACP,CAAC"}

package/dist/library/library-hash.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeVersionHash = void 0;
+const calculate_hash_1 = require("../crypto/calculate-hash");
+const canonical_json_1 = require("./canonical-json");
+/**
+ * Content hash of a library version: SHA-256 over the canonical JSON of
+ * `{ source, previousHash }`. Binds BEHAVIOUR ONLY — the source and its chain
+ * position — and deliberately excludes `createdAt`, `name`, and `description`
+ * so identity stays purely content-addressed. Those mutable fields are made
+ * tamper-evident by the version's signature instead, not by this hash.
+ */
+const computeVersionHash = (source, previousHash) => (0, calculate_hash_1.calculateHash)((0, canonical_json_1.canonicalJsonStringify)({ source, previousHash }));
+exports.computeVersionHash = computeVersionHash;

package/dist/library/library-models.d.ts

@@ -0,0 +1,134 @@
+import { z } from 'zod';
+/**
+ * Library ledger models — the storage-agnostic, portable-JSON shape of a
+ * reusable function or rule in the SAFE network logic library. An entity is a
+ * signed, content-addressed, append-only ledger of versions. See
+ * `documentation/functions/functions.md` and `plans/FUNCTION_LEDGER_PLAN.html`.
+ */
+/** One gas unit is 100ms of sandbox processing time. */
+export declare const GAS_UNIT_MS = 100;
+/** Maximum gas a function may declare: 30 minutes / 100ms = 18,000 units. */
+export declare const MAX_GAS_UNITS = 18000;
+/**
+ * The two kinds of reusable library entity. Both share the same versioned,
+ * signed ledger primitive; the kind selects the proof `purpose` namespace.
+ *
+ * Modelled as a Zod-inferred union + a companion value object (rather than a TS
+ * `enum`) so the schema's inferred field type and the value used in code are the
+ * same string-literal type — a nominal `enum` would not be assignable to the
+ * `z.enum` inference.
+ */
+export declare const LibraryEntityKindSchema: z.ZodEnum<{
+    function: "function";
+    rule: "rule";
+}>;
+export type LibraryEntityKind = z.infer<typeof LibraryEntityKindSchema>;
+export declare const LibraryEntityKind: {
+    readonly FUNCTION: "function";
+    readonly RULE: "rule";
+};
+/** The proof scheme used to sign versions. Only EdDSA signatures today. */
+export declare const LibraryProofTypeSchema: z.ZodEnum<{
+    CRYPTOGRAPHIC_SIGNATURE: "CRYPTOGRAPHIC_SIGNATURE";
+}>;
+export type LibraryProofType = z.infer<typeof LibraryProofTypeSchema>;
+export declare const LibraryProofType: {
+    readonly CRYPTOGRAPHIC_SIGNATURE: "CRYPTOGRAPHIC_SIGNATURE";
+};
+/** An Ed25519 signature over a canonical, purpose-bound payload. */
+export declare const ILibraryProofSchema: z.ZodObject<{
+    publicKey: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strip>;
+export type ILibraryProof = z.infer<typeof ILibraryProofSchema>;
+/**
+ * One version in a library entity's ledger. `currentHash` binds behaviour only
+ * (`source` + `previousHash`); `createdAt` is NOT in the content hash but IS in
+ * the signed proof payload, so it is tamper-evident via the signature.
+ */
+export declare const ILibraryVersionSchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    previousHash: z.ZodString;
+    source: z.ZodString;
+    currentHash: z.ZodString;
+    proof: z.ZodObject<{
+        publicKey: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strip>;
+    proofType: z.ZodEnum<{
+        CRYPTOGRAPHIC_SIGNATURE: "CRYPTOGRAPHIC_SIGNATURE";
+    }>;
+}, z.core.$strip>;
+export type ILibraryVersion = z.infer<typeof ILibraryVersionSchema>;
+/** The ledger tip: the latest version's hash plus a proof over it. */
+export declare const ILibraryHeadSchema: z.ZodObject<{
+    currentHash: z.ZodString;
+    proof: z.ZodObject<{
+        publicKey: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ILibraryHead = z.infer<typeof ILibraryHeadSchema>;
+/**
+ * A delegation granting `signerPublicKey` the right to append versions. The
+ * `proof` is the OWNER's signature over a canonical payload binding the entity
+ * id and the granted key — so a delegation cannot be forged (no valid owner
+ * signature) and cannot be replayed onto another entity (id is bound).
+ */
+export declare const ILibraryDelegationSchema: z.ZodObject<{
+    signerPublicKey: z.ZodString;
+    createdAt: z.ZodNumber;
+    proof: z.ZodObject<{
+        publicKey: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ILibraryDelegation = z.infer<typeof ILibraryDelegationSchema>;
+/**
+ * A reusable library entity: content-addressed `id` (= the first version's
+ * `currentHash`), mutable metadata, a declared `gasLimit`, an owner key, and an
+ * append-only `versions` ledger with a signed `head`.
+ */
+export declare const ILibraryEntitySchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        function: "function";
+        rule: "rule";
+    }>;
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    gasLimit: z.ZodNumber;
+    owner: z.ZodObject<{
+        publicKey: z.ZodString;
+    }, z.core.$strip>;
+    delegations: z.ZodArray<z.ZodObject<{
+        signerPublicKey: z.ZodString;
+        createdAt: z.ZodNumber;
+        proof: z.ZodObject<{
+            publicKey: z.ZodString;
+            signature: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    versions: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodNumber;
+        previousHash: z.ZodString;
+        source: z.ZodString;
+        currentHash: z.ZodString;
+        proof: z.ZodObject<{
+            publicKey: z.ZodString;
+            signature: z.ZodString;
+        }, z.core.$strip>;
+        proofType: z.ZodEnum<{
+            CRYPTOGRAPHIC_SIGNATURE: "CRYPTOGRAPHIC_SIGNATURE";
+        }>;
+    }, z.core.$strip>>;
+    head: z.ZodObject<{
+        currentHash: z.ZodString;
+        proof: z.ZodObject<{
+            publicKey: z.ZodString;
+            signature: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ILibraryEntity = z.infer<typeof ILibraryEntitySchema>;
+//# sourceMappingURL=library-models.d.ts.map

package/dist/library/library-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-models.d.ts","sourceRoot":"","sources":["../../src/library/library-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;GAKG;AAIH,wDAAwD;AACxD,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,6EAA6E;AAC7E,eAAO,MAAM,aAAa,QAAS,CAAC;AAMpC;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;;;EAA+B,CAAC;AACpE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,eAAO,MAAM,iBAAiB;;;CAAkD,CAAC;AAEjF,2EAA2E;AAC3E,eAAO,MAAM,sBAAsB;;EAAsC,CAAC;AAC1E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,eAAO,MAAM,gBAAgB;;CAAkE,CAAC;AAMhG,oEAAoE;AACpE,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;iBAOhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,sEAAsE;AACtE,eAAO,MAAM,kBAAkB;;;;;;iBAG7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;iBAInC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/library/library-models.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ILibraryEntitySchema = exports.ILibraryDelegationSchema = exports.ILibraryHeadSchema = exports.ILibraryVersionSchema = exports.ILibraryProofSchema = exports.LibraryProofType = exports.LibraryProofTypeSchema = exports.LibraryEntityKind = exports.LibraryEntityKindSchema = exports.MAX_GAS_UNITS = exports.GAS_UNIT_MS = void 0;
+const zod_1 = require("zod");
+/**
+ * Library ledger models — the storage-agnostic, portable-JSON shape of a
+ * reusable function or rule in the SAFE network logic library. An entity is a
+ * signed, content-addressed, append-only ledger of versions. See
+ * `documentation/functions/functions.md` and `plans/FUNCTION_LEDGER_PLAN.html`.
+ */
+//#region constants
+/** One gas unit is 100ms of sandbox processing time. */
+exports.GAS_UNIT_MS = 100;
+/** Maximum gas a function may declare: 30 minutes / 100ms = 18,000 units. */
+exports.MAX_GAS_UNITS = 18000;
+//#endregion constants
+//#region enums
+/**
+ * The two kinds of reusable library entity. Both share the same versioned,
+ * signed ledger primitive; the kind selects the proof `purpose` namespace.
+ *
+ * Modelled as a Zod-inferred union + a companion value object (rather than a TS
+ * `enum`) so the schema's inferred field type and the value used in code are the
+ * same string-literal type — a nominal `enum` would not be assignable to the
+ * `z.enum` inference.
+ */
+exports.LibraryEntityKindSchema = zod_1.z.enum(['function', 'rule']);
+exports.LibraryEntityKind = { FUNCTION: 'function', RULE: 'rule' };
+/** The proof scheme used to sign versions. Only EdDSA signatures today. */
+exports.LibraryProofTypeSchema = zod_1.z.enum(['CRYPTOGRAPHIC_SIGNATURE']);
+exports.LibraryProofType = { CRYPTOGRAPHIC_SIGNATURE: 'CRYPTOGRAPHIC_SIGNATURE' };
+//#endregion enums
+//#region models
+/** An Ed25519 signature over a canonical, purpose-bound payload. */
+exports.ILibraryProofSchema = zod_1.z.object({
+    publicKey: zod_1.z.string(), // hex public key of the signer
+    signature: zod_1.z.string(), // hex Ed25519 signature
+});
+/**
+ * One version in a library entity's ledger. `currentHash` binds behaviour only
+ * (`source` + `previousHash`); `createdAt` is NOT in the content hash but IS in
+ * the signed proof payload, so it is tamper-evident via the signature.
+ */
+exports.ILibraryVersionSchema = zod_1.z.object({
+    createdAt: zod_1.z.number(), // milliseconds; signed, not hashed
+    previousHash: zod_1.z.string(), // prior version's currentHash ('' for the first)
+    source: zod_1.z.string(), // the stringified function/rule source
+    currentHash: zod_1.z.string(), // SHA-256(canonicalJSON({ source, previousHash }))
+    proof: exports.ILibraryProofSchema, // signs the canonical, purpose-bound payload
+    proofType: exports.LibraryProofTypeSchema,
+});
+/** The ledger tip: the latest version's hash plus a proof over it. */
+exports.ILibraryHeadSchema = zod_1.z.object({
+    currentHash: zod_1.z.string(), // == the latest version's currentHash
+    proof: exports.ILibraryProofSchema,
+});
+/**
+ * A delegation granting `signerPublicKey` the right to append versions. The
+ * `proof` is the OWNER's signature over a canonical payload binding the entity
+ * id and the granted key — so a delegation cannot be forged (no valid owner
+ * signature) and cannot be replayed onto another entity (id is bound).
+ */
+exports.ILibraryDelegationSchema = zod_1.z.object({
+    signerPublicKey: zod_1.z.string(), // the delegated key being granted append rights
+    createdAt: zod_1.z.number(),
+    proof: exports.ILibraryProofSchema, // signed by the entity owner
+});
+/**
+ * A reusable library entity: content-addressed `id` (= the first version's
+ * `currentHash`), mutable metadata, a declared `gasLimit`, an owner key, and an
+ * append-only `versions` ledger with a signed `head`.
+ */
+exports.ILibraryEntitySchema = zod_1.z.object({
+    kind: exports.LibraryEntityKindSchema,
+    id: zod_1.z.string(), // = versions[0].currentHash
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    gasLimit: zod_1.z.number(), // gas units (100ms each), 1..MAX_GAS_UNITS
+    owner: zod_1.z.object({ publicKey: zod_1.z.string() }),
+    delegations: zod_1.z.array(exports.ILibraryDelegationSchema), // owner-signed append grants
+    versions: zod_1.z.array(exports.ILibraryVersionSchema),
+    head: exports.ILibraryHeadSchema,
+});
+//#endregion models

package/dist/library/library-proof.d.ts

@@ -0,0 +1,40 @@
+import { LibraryEntityKind } from './library-models';
+/**
+ * Canonical, purpose-bound payloads that library proofs sign over. Reuses the
+ * trust-chain discipline (Ed25519 over a canonical string with a `purpose`
+ * tag): the payload binds the entity `id` so a version's signature cannot be
+ * replayed onto another entity, folds in `createdAt`/`publicKey` so they are
+ * tamper-evident, and carries a `purpose` so a version proof can never satisfy
+ * a head check (or a function proof a rule check) and vice versa.
+ */
+/** Purpose tag for a per-version proof, namespaced by entity kind. */
+export declare const versionPurpose: (kind: LibraryEntityKind) => string;
+/** Purpose tag for the head (ledger tip) proof, namespaced by entity kind. */
+export declare const headPurpose: (kind: LibraryEntityKind) => string;
+/** Purpose tag for a delegation proof, namespaced by entity kind. */
+export declare const delegatePurpose: (kind: LibraryEntityKind) => string;
+export interface VersionProofPayloadArgs {
+    id: string;
+    currentHash: string;
+    previousHash: string;
+    createdAt: number;
+    purpose: string;
+    publicKey: string;
+}
+export declare const buildVersionProofPayload: (args: VersionProofPayloadArgs) => string;
+export interface HeadProofPayloadArgs {
+    id: string;
+    head: string;
+    purpose: string;
+    publicKey: string;
+}
+export declare const buildHeadProofPayload: (args: HeadProofPayloadArgs) => string;
+export interface DelegationProofPayloadArgs {
+    id: string;
+    signerPublicKey: string;
+    purpose: string;
+    /** The owner's public key (the signer of the delegation). */
+    publicKey: string;
+}
+export declare const buildDelegationProofPayload: (args: DelegationProofPayloadArgs) => string;
+//# sourceMappingURL=library-proof.d.ts.map

package/dist/library/library-proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-proof.d.ts","sourceRoot":"","sources":["../../src/library/library-proof.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;GAOG;AAEH,sEAAsE;AACtE,eAAO,MAAM,cAAc,GAAI,MAAM,iBAAiB,KAAG,MAA2B,CAAC;AAErF,8EAA8E;AAC9E,eAAO,MAAM,WAAW,GAAI,MAAM,iBAAiB,KAAG,MAAwB,CAAC;AAE/E,qEAAqE;AACrE,eAAO,MAAM,eAAe,GAAI,MAAM,iBAAiB,KAAG,MAA4B,CAAC;AAEvF,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,wBAAwB,GAAI,MAAM,uBAAuB,KAAG,MAQnE,CAAC;AAEP,MAAM,WAAW,oBAAoB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,qBAAqB,GAAI,MAAM,oBAAoB,KAAG,MAM7D,CAAC;AAEP,MAAM,WAAW,0BAA0B;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,2BAA2B,GAAI,MAAM,0BAA0B,KAAG,MAMzE,CAAC"}

package/dist/library/library-proof.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDelegationProofPayload = exports.buildHeadProofPayload = exports.buildVersionProofPayload = exports.delegatePurpose = exports.headPurpose = exports.versionPurpose = void 0;
+const canonical_json_1 = require("./canonical-json");
+/**
+ * Canonical, purpose-bound payloads that library proofs sign over. Reuses the
+ * trust-chain discipline (Ed25519 over a canonical string with a `purpose`
+ * tag): the payload binds the entity `id` so a version's signature cannot be
+ * replayed onto another entity, folds in `createdAt`/`publicKey` so they are
+ * tamper-evident, and carries a `purpose` so a version proof can never satisfy
+ * a head check (or a function proof a rule check) and vice versa.
+ */
+/** Purpose tag for a per-version proof, namespaced by entity kind. */
+const versionPurpose = (kind) => `${kind}-version`;
+exports.versionPurpose = versionPurpose;
+/** Purpose tag for the head (ledger tip) proof, namespaced by entity kind. */
+const headPurpose = (kind) => `${kind}-head`;
+exports.headPurpose = headPurpose;
+/** Purpose tag for a delegation proof, namespaced by entity kind. */
+const delegatePurpose = (kind) => `${kind}-delegate`;
+exports.delegatePurpose = delegatePurpose;
+const buildVersionProofPayload = (args) => (0, canonical_json_1.canonicalJsonStringify)({
+    id: args.id,
+    currentHash: args.currentHash,
+    previousHash: args.previousHash,
+    createdAt: args.createdAt,
+    purpose: args.purpose,
+    publicKey: args.publicKey,
+});
+exports.buildVersionProofPayload = buildVersionProofPayload;
+const buildHeadProofPayload = (args) => (0, canonical_json_1.canonicalJsonStringify)({
+    id: args.id,
+    head: args.head,
+    purpose: args.purpose,
+    publicKey: args.publicKey,
+});
+exports.buildHeadProofPayload = buildHeadProofPayload;
+const buildDelegationProofPayload = (args) => (0, canonical_json_1.canonicalJsonStringify)({
+    id: args.id,
+    signerPublicKey: args.signerPublicKey,
+    purpose: args.purpose,
+    publicKey: args.publicKey,
+});
+exports.buildDelegationProofPayload = buildDelegationProofPayload;

package/dist/library/library-reference.d.ts

@@ -0,0 +1,75 @@
+import { FunctionExecutionResult, FunctionExecutor } from '../sandbox/sandbox-models';
+import { RuleEvaluationResult, RuleEvaluator } from '../sandbox/rule-evaluator';
+import { IShareData } from '../models/share-data/share-data-models';
+import { IShareRuleApplied } from '../models/rules/share-rule-models';
+import { ILibraryEntity, ILibraryVersion, LibraryEntityKind } from './library-models';
+import { LibraryStore } from './library-store';
+/**
+ * A reference from a consumer (e.g. a ShareData) to a specific version of a
+ * library entity, pinned by `currentHash`. Pinning a version is what preserves
+ * the "frozen at lock" guarantee: the consumer keeps running its exact version
+ * even after the library entity gains new versions.
+ */
+export interface LibraryReference {
+    kind: LibraryEntityKind;
+    id: string;
+    currentHash: string;
+}
+/**
+ * A rule reference as carried by a ShareData: the library reference plus the
+ * root property the rule governs (`targettedProperty`), which the per-property
+ * routing needs to group rules during evaluation.
+ */
+export interface ILibraryRuleReferenceBinding {
+    reference: LibraryReference;
+    targettedProperty: string;
+}
+/** Builds a reference pinning a specific version of `entity` (defaults to the head). */
+export declare const referenceLibraryEntity: (entity: ILibraryEntity, versionHash?: string) => LibraryReference;
+/**
+ * The canonical source string for a rule library entity: the stringified rule
+ * definition. A rule entity published with this source resolves to a reference
+ * built by {@link referenceForRule} (both hash the same bytes).
+ */
+export declare const ruleLibrarySource: (rule: IShareRuleApplied) => string;
+/**
+ * Computes the content-addressed reference for a rule WITHOUT publishing it: the
+ * id is the hash of the rule's first (and, for a standard rule, only) version,
+ * exactly as `createLibraryEntity` would compute it. This lets a block reference
+ * a rule by hash and resolve it on demand from any store that has been seeded
+ * with the same rule definition (see `seedRuleLibrary` in `@degenerate/shareblock`).
+ */
+export declare const referenceForRule: (rule: IShareRuleApplied) => LibraryReference;
+/**
+ * Locates the pinned version within an already-in-hand entity (the
+ * self-contained path). Checks the reference's `id` and `kind` match the entity
+ * and that the pinned `currentHash` exists.
+ */
+export declare const findPinnedVersion: (entity: ILibraryEntity, reference: LibraryReference) => ILibraryVersion;
+export interface ResolvedLibraryReference {
+    entity: ILibraryEntity;
+    version: ILibraryVersion;
+}
+/**
+ * Resolves a reference against the store (the limited-self-containment path):
+ * loads the entity by id (the store re-verifies it), then locates the pinned
+ * version. Throws {@link LibraryEntityNotFoundError} if the store lacks the id.
+ */
+export declare const resolveLibraryReference: (reference: LibraryReference, store: LibraryStore) => Promise<ResolvedLibraryReference>;
+export interface ExecuteFunctionReferenceOptions {
+    current: IShareData;
+    input: unknown;
+    gasLimit?: number;
+    executor?: FunctionExecutor;
+}
+/** Resolves a FUNCTION reference from the store and runs its pinned version. */
+export declare const executeFunctionReference: (reference: LibraryReference, store: LibraryStore, options: ExecuteFunctionReferenceOptions) => Promise<FunctionExecutionResult>;
+export interface EvaluateRuleReferenceOptions {
+    current: IShareData;
+    proposed: IShareData;
+    gasLimit?: number;
+    evaluator?: RuleEvaluator;
+}
+/** Resolves a RULE reference from the store and evaluates its pinned version. */
+export declare const evaluateRuleReference: (reference: LibraryReference, store: LibraryStore, options: EvaluateRuleReferenceOptions) => Promise<RuleEvaluationResult>;
+//# sourceMappingURL=library-reference.d.ts.map

package/dist/library/library-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-reference.d.ts","sourceRoot":"","sources":["../../src/library/library-reference.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAGtE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,iBAAiB,CAAC;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IACzC,SAAS,EAAE,gBAAgB,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;CAC7B;AAaD,wFAAwF;AACxF,eAAO,MAAM,sBAAsB,GAAI,QAAQ,cAAc,EAAE,cAAc,MAAM,KAAG,gBAGrF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,iBAAiB,KAAG,MAA8B,CAAC;AAE3F;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,iBAAiB,KAAG,gBAG1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,cAAc,EAAE,WAAW,gBAAgB,KAAG,eAYvF,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;CAC5B;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAChC,WAAW,gBAAgB,EAC3B,OAAO,YAAY,KACpB,OAAO,CAAC,wBAAwB,CAMlC,CAAC;AAEF,MAAM,WAAW,+BAA+B;IAC5C,OAAO,EAAE,UAAU,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC/B;AAED,gFAAgF;AAChF,eAAO,MAAM,wBAAwB,GACjC,WAAW,gBAAgB,EAC3B,OAAO,YAAY,EACnB,SAAS,+BAA+B,KACzC,OAAO,CAAC,uBAAuB,CASjC,CAAC;AAEF,MAAM,WAAW,4BAA4B;IACzC,OAAO,EAAE,UAAU,CAAC;IACpB,QAAQ,EAAE,UAAU,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC7B;AAED,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,GAC9B,WAAW,gBAAgB,EAC3B,OAAO,YAAY,EACnB,SAAS,4BAA4B,KACtC,OAAO,CAAC,oBAAoB,CAS9B,CAAC"}