@degenerate/generic 0.2.7 → 0.4.0

package/dist/models/safe/transactions/sharedata-transactions-models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sharedata-transactions-models.d.ts","sourceRoot":"","sources":["../../../../src/models/safe/transactions/sharedata-transactions-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACH,mBAAmB,EACnB,yBAAyB,EAG5B,MAAM,4BAA4B,CAAC;AAIpC;;GAEG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;EAI9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEhG;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAIxF;;GAEG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK7C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKhD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKhD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC"}
+{"version":3,"file":"sharedata-transactions-models.d.ts","sourceRoot":"","sources":["../../../../src/models/safe/transactions/sharedata-transactions-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACH,mBAAmB,EACnB,yBAAyB,EAG5B,MAAM,4BAA4B,CAAC;AASpC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEhG;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAIxF;;GAEG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK7C,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKhD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG;;GAEG;AACH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKhD,CAAC;AAEH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC"}

package/dist/models/safe/transactions/sharedata-transactions-models.js

@@ -3,14 +3,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ISAFETransactionShareDataDeleteSchema = exports.ISAFETransactionShareDataUpdateSchema = exports.ISAFETransactionShareDataAddSchema = exports.ISAFETransactionShareDataSchema = exports.ISAFETransactionShareDataDataSchema = void 0;
 const zod_1 = require("zod");
 const safe_transaction_models_1 = require("../safe-transaction-models");
+const share_data_crypto_models_1 = require("../../share-data/share-data-crypto-models");
+const shareblock_models_1 = require("../../shareblock/shareblock-models");
 //#region ShareData Transaction
 /**
- * This is the data for the sharedata in the SAFE Ecosystem.
+ * Wire-format payload for creating a ShareData over the SAFE HTTP / SAFE
+ * transaction layer. Carries everything the receiving server needs to
+ * dispatch to the matching ShareBlock factory and reconstruct the
+ * client-signed trust chain:
+ *
+ *   - `metadata` — variant tag + creation attribution (also identifies
+ *     which factory to call).
+ *   - `initialState` — caller-supplied initial state inputs. Validated
+ *     loosely here (currency/participants/balance) — the factory layers
+ *     the variant-specific defaults (`isOpen: true`, `committed: false`,
+ *     etc.) on top.
+ *   - `initialCrypto` — the client's pre-computed creation hash / sig.
+ *     `creationPublicKey` is derived from this — *not* taken from a
+ *     separate field — so there is one source of truth for "who created
+ *     this block."
+ *   - `proofs` — bundle keyed by purpose. Each entry signs over the
+ *     in-construction share-data state at the moment the factory will
+ *     register the matching function/rule. The server cross-checks the
+ *     bundle covers every purpose the chosen factory requires (via
+ *     `*_REQUIRED_PROOF_PURPOSES`) before invoking the factory.
+ *
+ * Replaces the legacy free-form `shareDataContent: Record<string, any>`
+ * shape — that was the attack surface that let the HTTP create route
+ * accept attacker-controlled JSON as canonical state.
  */
 exports.ISAFETransactionShareDataDataSchema = zod_1.z.object({
-    shareDataId: zod_1.z.string(),
-    shareDataType: zod_1.z.string(),
-    shareDataContent: zod_1.z.record(zod_1.z.any()),
+    metadata: shareblock_models_1.IShareBlockMetadataSchema,
+    initialState: shareblock_models_1.IShareBlockInitialStateInputSchema,
+    initialCrypto: share_data_crypto_models_1.IShareDataInitialCryptoDataSchema,
+    proofs: share_data_crypto_models_1.ShareDataProofsSchema,
 });
 /**
  * This is the transaction targeting a sharedata item in the SAFE Ecosystem.

package/dist/models/share-data/share-data-crypto-models.d.ts

@@ -0,0 +1,344 @@
+import { z } from 'zod';
+/**
+ * This contains the interface for the share data initial crypto data schema
+ */
+export declare const IShareDataInitialCryptoDataSchema: z.ZodObject<{
+    publicKey: z.ZodString;
+    shareDataHash: z.ZodString;
+    shareDataSignature: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareDataInitialCryptoData = z.infer<typeof IShareDataInitialCryptoDataSchema>;
+/**
+ * This contains the interface for the share data crypto proof schema.
+ *
+ * `purpose` identifies what this proof attests to (e.g. `'deposit'`,
+ * `'rule-balance'`, `'seed-function'`). It is folded into the canonical
+ * signed string so two proofs taken over the same share-data state at the
+ * same moment but tagged with different purposes produce different
+ * signatures. Verifiers consume `purpose` directly from the proof — the
+ * proof is self-describing, so the structural-add boundary
+ * (`addFunction` / `addRule`) does not need a separate purpose argument.
+ */
+export declare const IShareDataCryptoProofSchema: z.ZodObject<{
+    publicKey: z.ZodString;
+    shareDataHash: z.ZodString;
+    shareDataPreviousHash: z.ZodString;
+    shareDataSignature: z.ZodString;
+    timestamp: z.ZodNumber;
+    purpose: z.ZodString;
+}, z.core.$strip>;
+export type IShareDataCryptoProof = z.infer<typeof IShareDataCryptoProofSchema>;
+/**
+ * A bundle of structural proofs keyed by their `purpose`, used as the
+ * wire-format input to ShareBlock factories when the client (rather than
+ * the server) signs each registration. Matches how `_structuralProofs`
+ * end up shaped on a constructed ShareData — one proof per
+ * `addFunction` / `addRule` call.
+ */
+export declare const ShareDataProofsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    publicKey: z.ZodString;
+    shareDataHash: z.ZodString;
+    shareDataPreviousHash: z.ZodString;
+    shareDataSignature: z.ZodString;
+    timestamp: z.ZodNumber;
+    purpose: z.ZodString;
+}, z.core.$strip>>;
+export type ShareDataProofs = z.infer<typeof ShareDataProofsSchema>;
+/**
+ * A single delegated-signer grant on a block: a public key the block owner has
+ * authorized to propose runtime transactions, scoped to a specific set of
+ * function ids (least privilege — a granted key can only drive the function(s)
+ * it was delegated, not arbitrary mutations).
+ *
+ * Field-declaration order is load-bearing, NOT cosmetic — same constraint as
+ * {@link IShareDataCryptoProofSchema}. The grant is folded into the canonical
+ * share-data string via order-sensitive `JSON.stringify` (see `getArrayString`
+ * / `calculateShareDataString`), so a grant that round-trips through `.parse()`
+ * (persistence reload) must come back with the SAME key order a freshly-built
+ * grant has, or the block's hash diverges and later proofs fail to verify.
+ * Keep `publicKey` before `functionIds`, matching the object literal pushed in
+ * `ShareData.addAuthorizedSigner`.
+ */
+export declare const IAuthorizedSignerSchema: z.ZodObject<{
+    publicKey: z.ZodString;
+    functionIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type IAuthorizedSigner = z.infer<typeof IAuthorizedSignerSchema>;
+/** Prefix marking a structural proof's `purpose` as a delegate registration. */
+export declare const DELEGATE_PURPOSE_PREFIX = "delegate:";
+/**
+ * Builds the canonical `purpose` for a delegated-signer registration proof.
+ *
+ * The registration proof is signed over the block's PRE-append state (the grant
+ * is not yet folded into `_authorizedSigners` at signing time), so the proof's
+ * `purpose` is the only thing that cryptographically attests to the exact
+ * `(signerPublicKey, functionIds)` grant. Binding both into the purpose means a
+ * tampered snapshot cannot widen a delegate's scope (add function ids) or lift
+ * the signature to authorize a different key without invalidating the proof.
+ *
+ * `functionIds` are normalized (trimmed, de-duped, sorted) and JSON-encoded so
+ * the encoding is collision-free regardless of characters in the ids and
+ * order-independent across live-create and replay.
+ */
+export declare const buildDelegatePurpose: (signerPublicKey: string, functionIds: string[]) => string;
+/**
+ * This contains the interface for the share data property config
+ * for creating strings from the object to ensure that signatures and
+ * hashes are consistent
+ */
+export declare const IShareDataPropertyConfigSchema: z.ZodObject<{
+    key: z.ZodString;
+    process: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodString>>;
+}, z.core.$strip>;
+export type IShareDataPropertyConfig = z.infer<typeof IShareDataPropertyConfigSchema>;
+/**
+ * This contains the interface for the share data config array
+ * for creating strings from the object to ensure that signatures and
+ * hashes are consistent
+ */
+export declare const IShareDataConfigSchema: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    process: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodString>>;
+}, z.core.$strip>>;
+export type IShareDataConfig = z.infer<typeof IShareDataConfigSchema>;
+/**
+ * This contains the interface for additional data to include in the share data string.
+ *
+ * `purpose` is required and identifies what this signed snapshot is attesting to
+ * (e.g. `'deposit'`, `'rule-balance'`, `'seed-function'`). It is folded into the
+ * canonical string `calculateShareDataString` produces, so two proofs taken
+ * over the same share-data state at the same moment but tagged with different
+ * purposes produce different hashes and therefore different signatures. This
+ * structurally prevents replaying a proof signed for one purpose as a proof
+ * for another.
+ */
+export declare const IShareDataAdditionalValuesToIncludeSchema: z.ZodObject<{
+    purpose: z.ZodString;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+        currentDataConditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"TYPEOF">;
+            conditionValue: z.ZodEnum<{
+                NULL: "NULL";
+                STRING: "STRING";
+                NUMBER: "NUMBER";
+                INTEGER: "INTEGER";
+                BOOLEAN: "BOOLEAN";
+                OBJECT: "OBJECT";
+                ARRAY: "ARRAY";
+                UNDEFINED: "UNDEFINED";
+                FUNCTION: "FUNCTION";
+                BIGINT: "BIGINT";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"EQUAL">;
+            conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+                GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+                LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+            }>;
+            conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"CONTAINS">;
+            conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                STARTS_WITH: "STARTS_WITH";
+                ENDS_WITH: "ENDS_WITH";
+            }>;
+            conditionValue: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"NULL">;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                TRUE: "TRUE";
+                FALSE: "FALSE";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"EMPTY">;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                PATTERN: "PATTERN";
+            }>;
+            conditionValue: z.ZodString;
+        }, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        proposedDataConditions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"TYPEOF">;
+            conditionValue: z.ZodEnum<{
+                NULL: "NULL";
+                STRING: "STRING";
+                NUMBER: "NUMBER";
+                INTEGER: "INTEGER";
+                BOOLEAN: "BOOLEAN";
+                OBJECT: "OBJECT";
+                ARRAY: "ARRAY";
+                UNDEFINED: "UNDEFINED";
+                FUNCTION: "FUNCTION";
+                BIGINT: "BIGINT";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"EQUAL">;
+            conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                GREATER_THAN: "GREATER_THAN";
+                LESS_THAN: "LESS_THAN";
+                GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+                LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+            }>;
+            conditionValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"CONTAINS">;
+            conditionValue: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                STARTS_WITH: "STARTS_WITH";
+                ENDS_WITH: "ENDS_WITH";
+            }>;
+            conditionValue: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"NULL">;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                TRUE: "TRUE";
+                FALSE: "FALSE";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodLiteral<"EMPTY">;
+        }, z.core.$strip>, z.ZodObject<{
+            conditionTypeQualifier: z.ZodEnum<{
+                IS: "IS";
+                IS_NOT: "IS_NOT";
+            }>;
+            targettedProperty: z.ZodString;
+            conditionType: z.ZodEnum<{
+                PATTERN: "PATTERN";
+            }>;
+            conditionValue: z.ZodString;
+        }, z.core.$strip>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        targettedProperty: z.ZodString;
+    }, z.core.$strip>>>;
+    functions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        groupingId: z.ZodString;
+        groupingName: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        hash: z.ZodString;
+        stringifiedFunction: z.ZodString;
+    }, z.core.$strip>>>;
+    transactionHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        ruleOutcome: z.ZodBoolean;
+        ruleFailures: z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+        }, z.core.$strip>>;
+        transactionFunction: z.ZodObject<{
+            input: z.ZodAny;
+            func: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+            output: z.ZodAny;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        shareData: z.ZodArray<z.ZodObject<{
+            shareDataId: z.ZodString;
+            functionId: z.ZodString;
+            shareDataInputs: z.ZodArray<z.ZodString>;
+            inputs: z.ZodAny;
+        }, z.core.$strip>>;
+        processingType: z.ZodEnum<{
+            parallel: "parallel";
+            linear: "linear";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type IShareDataAdditionalValuesToInclude = z.infer<typeof IShareDataAdditionalValuesToIncludeSchema>;
+//# sourceMappingURL=share-data-crypto-models.d.ts.map

package/dist/models/share-data/share-data-crypto-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-data-crypto-models.d.ts","sourceRoot":"","sources":["../../../src/models/share-data/share-data-crypto-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;iBAK5C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F;;;;;;;;;;GAUG;AASH,eAAO,MAAM,2BAA2B;;;;;;;iBAOtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;;kBAAoD,CAAC;AAEvF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,gFAAgF;AAChF,eAAO,MAAM,uBAAuB,cAAc,CAAC;AAEnD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,GAC7B,iBAAiB,MAAM,EACvB,aAAa,MAAM,EAAE,KACtB,MAKF,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;kBAA0C,CAAC;AAE9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMpD,CAAC;AACH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC"}

package/dist/models/share-data/share-data-crypto-models.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IShareDataAdditionalValuesToIncludeSchema = exports.IShareDataConfigSchema = exports.IShareDataPropertyConfigSchema = exports.buildDelegatePurpose = exports.DELEGATE_PURPOSE_PREFIX = exports.IAuthorizedSignerSchema = exports.ShareDataProofsSchema = exports.IShareDataCryptoProofSchema = exports.IShareDataInitialCryptoDataSchema = void 0;
+const zod_1 = require("zod");
+const share_rule_models_1 = require("../rules/share-rule-models");
+const share_data_models_1 = require("./share-data-models");
+const share_event_models_1 = require("../events/share-event-models");
+// This contains models that are used in the share data specifically around crypto
+//#region Share Data Crypto Schemas
+/**
+ * This contains the interface for the share data initial crypto data schema
+ */
+exports.IShareDataInitialCryptoDataSchema = zod_1.z.object({
+    publicKey: zod_1.z.string(), // the public key of the share data
+    shareDataHash: zod_1.z.string(), // the share data hash
+    shareDataSignature: zod_1.z.string(), // the share data signature
+    timestamp: zod_1.z.number(), // the timestamp of the initial crypto data (in milliseconds)
+});
+/**
+ * This contains the interface for the share data crypto proof schema.
+ *
+ * `purpose` identifies what this proof attests to (e.g. `'deposit'`,
+ * `'rule-balance'`, `'seed-function'`). It is folded into the canonical
+ * signed string so two proofs taken over the same share-data state at the
+ * same moment but tagged with different purposes produce different
+ * signatures. Verifiers consume `purpose` directly from the proof — the
+ * proof is self-describing, so the structural-add boundary
+ * (`addFunction` / `addRule`) does not need a separate purpose argument.
+ */
+// Field declaration order here is load-bearing, NOT cosmetic. Zod
+// reconstructs a parsed object in *schema-declaration* order, and the
+// canonical share-data hash folds structural proofs in via order-sensitive
+// `JSON.stringify` (see `getArrayString` / `calculateShareDataString`). So a
+// proof that round-trips through `.parse()` (wire load, HTTP create) must come
+// back with the SAME key order a freshly-minted proof has, or its hash
+// diverges and structural-proof verification fails. This order must therefore
+// mirror the object literal in `createShareDataProposalProof` exactly.
+exports.IShareDataCryptoProofSchema = zod_1.z.object({
+    publicKey: zod_1.z.string(), // the public key of the share data
+    shareDataHash: zod_1.z.string(), // the share data hash
+    shareDataPreviousHash: zod_1.z.string(), // the previous share data hash
+    shareDataSignature: zod_1.z.string(), // the share data signature
+    timestamp: zod_1.z.number(), // the timestamp of the initial crypto data (in milliseconds)
+    purpose: zod_1.z.string().min(1), // what this proof attests to (e.g. 'deposit', 'rule-balance')
+});
+/**
+ * A bundle of structural proofs keyed by their `purpose`, used as the
+ * wire-format input to ShareBlock factories when the client (rather than
+ * the server) signs each registration. Matches how `_structuralProofs`
+ * end up shaped on a constructed ShareData — one proof per
+ * `addFunction` / `addRule` call.
+ */
+exports.ShareDataProofsSchema = zod_1.z.record(zod_1.z.string(), exports.IShareDataCryptoProofSchema);
+/**
+ * A single delegated-signer grant on a block: a public key the block owner has
+ * authorized to propose runtime transactions, scoped to a specific set of
+ * function ids (least privilege — a granted key can only drive the function(s)
+ * it was delegated, not arbitrary mutations).
+ *
+ * Field-declaration order is load-bearing, NOT cosmetic — same constraint as
+ * {@link IShareDataCryptoProofSchema}. The grant is folded into the canonical
+ * share-data string via order-sensitive `JSON.stringify` (see `getArrayString`
+ * / `calculateShareDataString`), so a grant that round-trips through `.parse()`
+ * (persistence reload) must come back with the SAME key order a freshly-built
+ * grant has, or the block's hash diverges and later proofs fail to verify.
+ * Keep `publicKey` before `functionIds`, matching the object literal pushed in
+ * `ShareData.addAuthorizedSigner`.
+ */
+exports.IAuthorizedSignerSchema = zod_1.z.object({
+    publicKey: zod_1.z.string(), // the delegate's public key (hex)
+    functionIds: zod_1.z.array(zod_1.z.string()), // the function ids this key may drive (sorted)
+});
+/** Prefix marking a structural proof's `purpose` as a delegate registration. */
+exports.DELEGATE_PURPOSE_PREFIX = 'delegate:';
+/**
+ * Builds the canonical `purpose` for a delegated-signer registration proof.
+ *
+ * The registration proof is signed over the block's PRE-append state (the grant
+ * is not yet folded into `_authorizedSigners` at signing time), so the proof's
+ * `purpose` is the only thing that cryptographically attests to the exact
+ * `(signerPublicKey, functionIds)` grant. Binding both into the purpose means a
+ * tampered snapshot cannot widen a delegate's scope (add function ids) or lift
+ * the signature to authorize a different key without invalidating the proof.
+ *
+ * `functionIds` are normalized (trimmed, de-duped, sorted) and JSON-encoded so
+ * the encoding is collision-free regardless of characters in the ids and
+ * order-independent across live-create and replay.
+ */
+const buildDelegatePurpose = (signerPublicKey, functionIds) => {
+    const normalized = Array.from(new Set(functionIds.map((id) => id.trim()).filter((id) => id.length > 0))).sort();
+    return `${exports.DELEGATE_PURPOSE_PREFIX}${signerPublicKey}:${JSON.stringify(normalized)}`;
+};
+exports.buildDelegatePurpose = buildDelegatePurpose;
+//#endregion Share Data Crypto Schemas
+//#region Stringify Configurations
+/**
+ * This contains the interface for the share data property config
+ * for creating strings from the object to ensure that signatures and
+ * hashes are consistent
+ */
+exports.IShareDataPropertyConfigSchema = zod_1.z.object({
+    key: zod_1.z.string(),
+    process: zod_1.z.function({ input: zod_1.z.tuple([zod_1.z.any()]), output: zod_1.z.string() }).optional(), // Simplified process type
+});
+/**
+ * This contains the interface for the share data config array
+ * for creating strings from the object to ensure that signatures and
+ * hashes are consistent
+ */
+exports.IShareDataConfigSchema = zod_1.z.array(exports.IShareDataPropertyConfigSchema);
+//#endregion Stringify Configurations
+//#region Additional Data to include
+/**
+ * This contains the interface for additional data to include in the share data string.
+ *
+ * `purpose` is required and identifies what this signed snapshot is attesting to
+ * (e.g. `'deposit'`, `'rule-balance'`, `'seed-function'`). It is folded into the
+ * canonical string `calculateShareDataString` produces, so two proofs taken
+ * over the same share-data state at the same moment but tagged with different
+ * purposes produce different hashes and therefore different signatures. This
+ * structurally prevents replaying a proof signed for one purpose as a proof
+ * for another.
+ */
+exports.IShareDataAdditionalValuesToIncludeSchema = zod_1.z.object({
+    purpose: zod_1.z.string().min(1),
+    rules: zod_1.z.array(share_rule_models_1.IShareRuleAppliedSchema).optional(),
+    functions: zod_1.z.array(share_data_models_1.IShareFunctionRecordSchema).optional(),
+    transactionHistory: zod_1.z.array(share_data_models_1.IShareDataTransactionBaseSchema).optional(),
+    events: zod_1.z.array(share_event_models_1.IShareDataEventSchema).optional(),
+});
+//#endregion Additional Data to include

package/dist/models/share-data/share-data-models.d.ts

@@ -0,0 +1,114 @@
+import z from 'zod';
+import type { IShareDataCryptoProof } from './share-data-crypto-models';
+/**
+ * This contains the data for the share data object
+ */
+export declare enum ShareDataTypes {
+    AUTHORIZATION = "AUTHORIZATION",
+    RULE = "RULE",
+    FUNCTION = "FUNCTION",
+    TRANSACTION_HISTORY = "TRANSACTION_HISTORY",
+    DATA = "DATA"
+}
+export declare const ShareDataTypesSchema: z.ZodEnum<{
+    FUNCTION: "FUNCTION";
+    AUTHORIZATION: "AUTHORIZATION";
+    RULE: "RULE";
+    TRANSACTION_HISTORY: "TRANSACTION_HISTORY";
+    DATA: "DATA";
+}>;
+/**
+ * This contains the interface for a data in a share data object
+ */
+export declare const IShareDataSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export type IShareData = z.infer<typeof IShareDataSchema>;
+/**
+ * This contains the interface for a share function record in the share data object
+ */
+export declare const IShareFunctionRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    groupingId: z.ZodString;
+    groupingName: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    hash: z.ZodString;
+    stringifiedFunction: z.ZodString;
+}, z.core.$strip>;
+export type IShareFunctionRecord = z.infer<typeof IShareFunctionRecordSchema>;
+/**
+ * This contains the interface for a share function in the share data object
+ */
+export declare const IShareFunctionSchema: z.ZodObject<{
+    input: z.ZodAny;
+    func: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    output: z.ZodAny;
+}, z.core.$strip>;
+export interface IShareFunction<TInput, TFunction extends (...args: any[]) => any, TOutput> {
+    /**
+     * Stable identifier the host application can use to refer to this
+     * function from outside the runtime — e.g., when a client submits a
+     * `propose` over the realtime transport and needs to name which
+     * registered function should evaluate the proposal.
+     *
+     * Optional today for backwards compatibility with existing
+     * constructions that don't set it. Functions without an id are
+     * invisible to id-based lookup (see `createIdBasedFunctionResolver`
+     * in `@degenerate/realtime`); the host can still resolve them via a
+     * custom `FunctionResolver`.
+     */
+    id?: string;
+    input: TInput;
+    func: TFunction;
+    output: TOutput;
+}
+/**
+ * This contains the interface for the rule failures in the share data object
+ */
+export declare const IShareDataRuleFailuresSchema: z.ZodObject<{
+    ruleId: z.ZodString;
+}, z.core.$strip>;
+export type IShareDataRuleFailures = z.infer<typeof IShareDataRuleFailuresSchema>;
+/**
+ * This contains the interface for the share transaction history in the share data object
+ */
+export declare const IShareDataTransactionBaseSchema: z.ZodObject<{
+    ruleOutcome: z.ZodBoolean;
+    ruleFailures: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+    }, z.core.$strip>>;
+    transactionFunction: z.ZodObject<{
+        input: z.ZodAny;
+        func: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        output: z.ZodAny;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IShareDataTransactionBase = z.infer<typeof IShareDataTransactionBaseSchema>;
+/**
+ * This contains the interface for the share transaction history in the share data object
+ * This is done for storage
+ */
+export declare const IShareDataTransactionHistorySchema: z.ZodObject<{
+    ruleOutcome: z.ZodBoolean;
+    ruleFailures: z.ZodArray<z.ZodObject<{
+        ruleId: z.ZodString;
+    }, z.core.$strip>>;
+    transactionFunction: z.ZodObject<{
+        input: z.ZodAny;
+        func: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        output: z.ZodAny;
+    }, z.core.$strip>;
+    transactionId: z.ZodString;
+    transactionTime: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * `proof` is the transaction proposal proof that authorized this state change
+ * (present for transactions applied through the signed `addTransaction` path;
+ * absent for legacy/internal applies). It makes the audit log itself carry the
+ * signature, not just the function + rule outcome. Typed here rather than in
+ * the Zod schema to avoid a module load-time cycle — see the `import type` note
+ * at the top of this file.
+ */
+export type IShareDataTransactionHistory = z.infer<typeof IShareDataTransactionHistorySchema> & {
+    proof?: IShareDataCryptoProof;
+};
+//# sourceMappingURL=share-data-models.d.ts.map

package/dist/models/share-data/share-data-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-data-models.d.ts","sourceRoot":"","sources":["../../../src/models/share-data/share-data-models.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAOpB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAGxE;;GAEG;AACH,oBAAY,cAAc;IACtB,aAAa,kBAAkB;IAC/B,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,mBAAmB,wBAAwB;IAC3C,IAAI,SAAS;CAChB;AAED,eAAO,MAAM,oBAAoB;;;;;;EAM/B,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,gBAAgB,oCAAgC,CAAC;AAC9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;iBAQrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;iBAI/B,CAAC;AAGH,MAAM,WAAW,cAAc,CAAC,MAAM,EAAE,SAAS,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,OAAO;IACtF;;;;;;;;;;;OAWG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACnB;AAGD;;GAEG;AACH,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;iBAI1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;GAGG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;iBAG7C,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,GAAG;IAC5F,KAAK,CAAC,EAAE,qBAAqB,CAAC;CACjC,CAAC"}

package/dist/models/share-data/{share-data.js → share-data-models.js}

@@ -29,7 +29,7 @@ exports.ShareDataTypesSchema = zod_1.default.enum([
 /**
  * This contains the interface for a data in a share data object
  */
-exports.IShareDataSchema = zod_1.default.record(zod_1.default.any());
+exports.IShareDataSchema = zod_1.default.record(zod_1.default.string(), zod_1.default.any());
 /**
  * This contains the interface for a share function record in the share data object
  */