@degenerate/generic 0.3.2 → 0.6.0

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

@@ -138,6 +138,19 @@ export declare class ShareDataTransactionProofFailedError extends BaseError {
 export declare class ShareDataTransactionNotAuthorizedError extends BaseError {
     constructor(shareDataId: string, signingPublicKey: string);
 }
+/**
+ * This error is thrown when a delegated-signer registration is rejected.
+ * Distinct from {@link ShareDataTransactionNotAuthorizedError} (which rejects a
+ * runtime *transaction* whose signer is not authorized): this rejects the
+ * *registration* of a delegate — either because the registration proof was not
+ * signed by the block's `creationPublicKey` (only the owner may delegate; there
+ * is no transitive delegation), because the granted function-id set is empty,
+ * or because the proof's `purpose` does not bind the exact
+ * `(signerPublicKey, functionIds)` grant being registered.
+ */
+export declare class ShareDataDelegationNotAuthorizedError extends BaseError {
+    constructor(shareDataId: string, registeringPublicKey: string);
+}
 /**
  * This error is thrown when the system attempts to get the previous share data hash
  * but the share data has not been initialized for the proof yet.

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

@@ -1 +1 @@
-{"version":3,"file":"share-data-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/share-data/share-data-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACjD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc;CAGjE;AAED;;GAEG;AACH,qBAAa,2CAA4C,SAAQ,SAAS;IACtE;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IAClD;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,yDAA0D,SAAQ,SAAS;IACpF;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAI5E;AAGD;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,SAAS;IACxD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM;CAIjG;AAKD;;GAEG;AACH,qBAAa,yCAA0C,SAAQ,SAAS;IACpE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;IACrE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAID;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,SAAS;gBAC1C,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;gBACrC,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;gBACtC,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,iCAAkC,SAAQ,SAAS;gBAChD,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,6CAA8C,SAAQ,SAAS;gBAC5D,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,+BAAgC,SAAQ,SAAS;gBAC9C,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;gBACzD,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,mCAAoC,SAAQ,SAAS;gBAClD,WAAW,EAAE,MAAM;CAGlC;AAED;;;;;;;;;GASG;AACH,qBAAa,oCAAqC,SAAQ,SAAS;gBACnD,WAAW,EAAE,MAAM;CAGlC;AAED;;;;;;;;;GASG;AACH,qBAAa,sCAAuC,SAAQ,SAAS;gBACrD,WAAW,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;CAM5D;AAED;;;GAGG;AACH,qBAAa,sCAAuC,SAAQ,SAAS;gBACrD,WAAW,EAAE,MAAM;CAIlC;AAED;;;;;;GAMG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;gBACxC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAGlD"}
+{"version":3,"file":"share-data-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/share-data/share-data-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACjD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc;CAGjE;AAED;;GAEG;AACH,qBAAa,2CAA4C,SAAQ,SAAS;IACtE;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IAClD;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,yDAA0D,SAAQ,SAAS;IACpF;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAI5E;AAGD;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,SAAS;IACxD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM;CAIjG;AAKD;;GAEG;AACH,qBAAa,yCAA0C,SAAQ,SAAS;IACpE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;IACrE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAID;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,SAAS;gBAC1C,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;gBACrC,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;gBACtC,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,iCAAkC,SAAQ,SAAS;gBAChD,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,6CAA8C,SAAQ,SAAS;gBAC5D,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,+BAAgC,SAAQ,SAAS;gBAC9C,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;gBACzD,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,mCAAoC,SAAQ,SAAS;gBAClD,WAAW,EAAE,MAAM;CAGlC;AAED;;;;;;;;;GASG;AACH,qBAAa,oCAAqC,SAAQ,SAAS;gBACnD,WAAW,EAAE,MAAM;CAGlC;AAED;;;;;;;;;GASG;AACH,qBAAa,sCAAuC,SAAQ,SAAS;gBACrD,WAAW,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;CAM5D;AAED;;;;;;;;;GASG;AACH,qBAAa,qCAAsC,SAAQ,SAAS;gBACpD,WAAW,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM;CAOhE;AAED;;;GAGG;AACH,qBAAa,sCAAuC,SAAQ,SAAS;gBACrD,WAAW,EAAE,MAAM;CAIlC;AAED;;;;;;GAMG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;gBACxC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAGlD"}

package/dist/errors/share-data/share-data-errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShareDataPersistenceError = exports.ShareDataPreviousHashNotAvailableError = exports.ShareDataTransactionNotAuthorizedError = exports.ShareDataTransactionProofFailedError = exports.ShareDataStructuralProofFailedError = exports.ShareDataStructuralProofAlreadyExistsError = exports.ShareDataCryptoProofFailedError = exports.CryptoInitializationPublicKeyIsDifferentError = exports.ShareDataCryptoAlreadyExistsError = exports.ShareDataDuplicateError = exports.ShareDataNotFoundError = exports.ShareDataAlreadyExistsError = exports.ShareRuleProposedConditionsNotPresentError = exports.ShareRuleCurrentConditionsNotPresentError = exports.ShareDataFunctionHashNotValid = exports.ShareDataFunctionBeingAppliedDoesNotExistOnShareDataError = exports.ShareDataIntegrityError = exports.ShareDataCurrentAndProposalDataMatchesError = exports.ShareDataIsLockedError = void 0;
+exports.ShareDataPersistenceError = exports.ShareDataPreviousHashNotAvailableError = exports.ShareDataDelegationNotAuthorizedError = exports.ShareDataTransactionNotAuthorizedError = exports.ShareDataTransactionProofFailedError = exports.ShareDataStructuralProofFailedError = exports.ShareDataStructuralProofAlreadyExistsError = exports.ShareDataCryptoProofFailedError = exports.CryptoInitializationPublicKeyIsDifferentError = exports.ShareDataCryptoAlreadyExistsError = exports.ShareDataDuplicateError = exports.ShareDataNotFoundError = exports.ShareDataAlreadyExistsError = exports.ShareRuleProposedConditionsNotPresentError = exports.ShareRuleCurrentConditionsNotPresentError = exports.ShareDataFunctionHashNotValid = exports.ShareDataFunctionBeingAppliedDoesNotExistOnShareDataError = exports.ShareDataIntegrityError = exports.ShareDataCurrentAndProposalDataMatchesError = exports.ShareDataIsLockedError = void 0;
 const base_error_1 = require("../base-error");
 /**
  * This error is thrown when a function is tried to be applied to the share data thats state is locked.
@@ -195,6 +195,24 @@ class ShareDataTransactionNotAuthorizedError extends base_error_1.BaseError {
     }
 }
 exports.ShareDataTransactionNotAuthorizedError = ShareDataTransactionNotAuthorizedError;
+/**
+ * This error is thrown when a delegated-signer registration is rejected.
+ * Distinct from {@link ShareDataTransactionNotAuthorizedError} (which rejects a
+ * runtime *transaction* whose signer is not authorized): this rejects the
+ * *registration* of a delegate — either because the registration proof was not
+ * signed by the block's `creationPublicKey` (only the owner may delegate; there
+ * is no transitive delegation), because the granted function-id set is empty,
+ * or because the proof's `purpose` does not bind the exact
+ * `(signerPublicKey, functionIds)` grant being registered.
+ */
+class ShareDataDelegationNotAuthorizedError extends base_error_1.BaseError {
+    constructor(shareDataId, registeringPublicKey) {
+        super(`Share data with id ${shareDataId} rejected a delegated-signer registration: ` +
+            `key ${registeringPublicKey} is not authorized to delegate, or the registration ` +
+            `proof does not bind the requested grant.`);
+    }
+}
+exports.ShareDataDelegationNotAuthorizedError = ShareDataDelegationNotAuthorizedError;
 /**
  * This error is thrown when the system attempts to get the previous share data hash
  * but the share data has not been initialized for the proof yet.

package/dist/models/index.d.ts

@@ -17,5 +17,6 @@ export * from './safe/safe-transaction-models';
 export * from './share-data/share-data-crypto-models';
 export * from './share-data/share-data-models';
 export * from './share-data/share-data-persistence-models';
+export * from './settlement/settlement-models';
 export * from './shareblock/shareblock-models';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAEA,cAAc,sDAAsD,CAAC;AACrE,cAAc,yCAAyC,CAAC;AACxD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAElD,cAAc,2BAA2B,CAAC;AAE1C,cAAc,qDAAqD,CAAC;AACpE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,mDAAmD,CAAC;AAClE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,gCAAgC,CAAC;AAG/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAEA,cAAc,sDAAsD,CAAC;AACrE,cAAc,yCAAyC,CAAC;AACxD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,8CAA8C,CAAC;AAC7D,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,mCAAmC,CAAC;AAElD,cAAc,2BAA2B,CAAC;AAE1C,cAAc,qDAAqD,CAAC;AACpE,cAAc,gDAAgD,CAAC;AAC/D,cAAc,mDAAmD,CAAC;AAClE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,gCAAgC,CAAC;AAG/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC"}

package/dist/models/index.js

@@ -38,4 +38,5 @@ __exportStar(require("./safe/safe-transaction-models"), exports);
 __exportStar(require("./share-data/share-data-crypto-models"), exports);
 __exportStar(require("./share-data/share-data-models"), exports);
 __exportStar(require("./share-data/share-data-persistence-models"), exports);
+__exportStar(require("./settlement/settlement-models"), exports);
 __exportStar(require("./shareblock/shareblock-models"), exports);

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

@@ -33,6 +33,8 @@ export declare const ISAFETransactionShareDataDataSchema: z.ZodObject<{
             Clearing: "Clearing";
             Funding: "Funding";
             Distribution: "Distribution";
+            GraceRepayment: "GraceRepayment";
+            Settlement: "Settlement";
         }>;
         relatedLoanApplicationId: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
@@ -91,6 +93,8 @@ export declare const ISAFETransactionShareDataSchema: z.ZodObject<{
                     Clearing: "Clearing";
                     Funding: "Funding";
                     Distribution: "Distribution";
+                    GraceRepayment: "GraceRepayment";
+                    Settlement: "Settlement";
                 }>;
                 relatedLoanApplicationId: z.ZodOptional<z.ZodString>;
                 description: z.ZodOptional<z.ZodString>;
@@ -148,6 +152,8 @@ export declare const ISAFETransactionShareDataAddSchema: z.ZodObject<{
                     Clearing: "Clearing";
                     Funding: "Funding";
                     Distribution: "Distribution";
+                    GraceRepayment: "GraceRepayment";
+                    Settlement: "Settlement";
                 }>;
                 relatedLoanApplicationId: z.ZodOptional<z.ZodString>;
                 description: z.ZodOptional<z.ZodString>;
@@ -204,6 +210,8 @@ export declare const ISAFETransactionShareDataUpdateSchema: z.ZodObject<{
                     Clearing: "Clearing";
                     Funding: "Funding";
                     Distribution: "Distribution";
+                    GraceRepayment: "GraceRepayment";
+                    Settlement: "Settlement";
                 }>;
                 relatedLoanApplicationId: z.ZodOptional<z.ZodString>;
                 description: z.ZodOptional<z.ZodString>;
@@ -260,6 +268,8 @@ export declare const ISAFETransactionShareDataDeleteSchema: z.ZodObject<{
                     Clearing: "Clearing";
                     Funding: "Funding";
                     Distribution: "Distribution";
+                    GraceRepayment: "GraceRepayment";
+                    Settlement: "Settlement";
                 }>;
                 relatedLoanApplicationId: z.ZodOptional<z.ZodString>;
                 description: z.ZodOptional<z.ZodString>;

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;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"}
+{"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/settlement/settlement-models.d.ts

@@ -0,0 +1,221 @@
+import z from 'zod';
+/**
+ * Two-phase-commit phase of a settlement, journaled on the coordinator's
+ * state. The legal transition graph (enforced by `buildSettlementPhaseRule`):
+ *
+ *   PREPARING ──▶ COMMITTING ──▶ COMMITTED   (terminal)
+ *      │
+ *      └────────▶ ABORTING  ──▶ ABORTED      (terminal)
+ *
+ * `COMMITTING` is the point of no return: once reached, every leg was already
+ * reserved, so the settlement can only roll forward. Failures before that
+ * point route to `ABORTING`. Terminals are sinks.
+ */
+export declare const SettlementPhaseSchema: z.ZodEnum<{
+    PREPARING: "PREPARING";
+    COMMITTING: "COMMITTING";
+    ABORTING: "ABORTING";
+    COMMITTED: "COMMITTED";
+    ABORTED: "ABORTED";
+}>;
+export type SettlementPhase = z.infer<typeof SettlementPhaseSchema>;
+/**
+ * Per-leg status as tracked by the coordinator (a superset of the member
+ * block's `ReservationStatus`):
+ *
+ *   - `planned`   — in the plan, not yet reserved on its block.
+ *   - `reserved`  — successfully held on its block (PREPARE done for this leg).
+ *   - `committed` — finalized on its block.
+ *   - `released`  — unwound on its block (abort path).
+ *   - `failed`    — its reserve threw (drift/overdraw); triggers settlement
+ *                   abort.
+ */
+export declare const SettlementLegStatusSchema: z.ZodEnum<{
+    reserved: "reserved";
+    committed: "committed";
+    released: "released";
+    planned: "planned";
+    failed: "failed";
+}>;
+export type SettlementLegStatus = z.infer<typeof SettlementLegStatusSchema>;
+/**
+ * One leg of a settlement plan as recorded on the coordinator. A transfer is a
+ * `debit` leg (source) + a `credit` leg (destination) of equal `amountCents`.
+ * `againstHash` pins the leg to the target block's current-state hash at plan
+ * time (D5): if the block advanced, the reserve fails and the settlement
+ * aborts. `currency` is not carried per-leg — a settlement is single-currency
+ * (see the coordinator's `currency`).
+ */
+export declare const ISettlementLegSchema: z.ZodObject<{
+    blockId: z.ZodString;
+    direction: z.ZodEnum<{
+        debit: "debit";
+        credit: "credit";
+    }>;
+    amountCents: z.ZodNumber;
+    againstHash: z.ZodString;
+    status: z.ZodEnum<{
+        reserved: "reserved";
+        committed: "committed";
+        released: "released";
+        planned: "planned";
+        failed: "failed";
+    }>;
+}, z.core.$strip>;
+export type ISettlementLeg = z.infer<typeof ISettlementLegSchema>;
+/**
+ * The coordinator ShareBlock's state. A Settlement block is not a money-
+ * holding block — its inherited `balance` stays at zero and `participants` is
+ * empty; its real payload is the plan (`legs`), the 2PC `phase`, and the
+ * timestamps. The block's append-only transaction history is the durable
+ * journal that crash-recovery re-drives.
+ */
+export declare const ISettlementShareBlockStateSchema: z.ZodObject<{
+    balance: z.ZodNumber;
+    isOpen: z.ZodBoolean;
+    participants: z.ZodRecord<z.ZodString, z.ZodObject<{
+        userId: z.ZodString;
+        role: z.ZodEnum<{
+            Borrower: "Borrower";
+            Lender: "Lender";
+            Platform: "Platform";
+            Recipient: "Recipient";
+        }>;
+        committedAmount: z.ZodNumber;
+        settledAmount: z.ZodNumber;
+    }, z.core.$strip>>;
+    reservations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        settlementId: z.ZodString;
+        direction: z.ZodEnum<{
+            debit: "debit";
+            credit: "credit";
+        }>;
+        amountCents: z.ZodNumber;
+        currency: z.ZodString;
+        againstHash: z.ZodString;
+        status: z.ZodEnum<{
+            reserved: "reserved";
+            committed: "committed";
+            released: "released";
+        }>;
+    }, z.core.$strip>>>;
+    blockType: z.ZodLiteral<"Settlement">;
+    settlementId: z.ZodString;
+    currency: z.ZodString;
+    phase: z.ZodEnum<{
+        PREPARING: "PREPARING";
+        COMMITTING: "COMMITTING";
+        ABORTING: "ABORTING";
+        COMMITTED: "COMMITTED";
+        ABORTED: "ABORTED";
+    }>;
+    legs: z.ZodArray<z.ZodObject<{
+        blockId: z.ZodString;
+        direction: z.ZodEnum<{
+            debit: "debit";
+            credit: "credit";
+        }>;
+        amountCents: z.ZodNumber;
+        againstHash: z.ZodString;
+        status: z.ZodEnum<{
+            reserved: "reserved";
+            committed: "committed";
+            released: "released";
+            planned: "planned";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>>;
+    openedAtMs: z.ZodNumber;
+    terminalAtMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ISettlementShareBlockState = z.infer<typeof ISettlementShareBlockStateSchema>;
+/**
+ * Input for the coordinator `openSettlement` function — establishes the plan
+ * as the first journaled transaction (phase `PREPARING`, every leg `planned`).
+ */
+export declare const ISettlementOpenInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    settlementId: z.ZodString;
+    currency: z.ZodString;
+    legs: z.ZodArray<z.ZodObject<{
+        blockId: z.ZodString;
+        direction: z.ZodEnum<{
+            debit: "debit";
+            credit: "credit";
+        }>;
+        amountCents: z.ZodNumber;
+        againstHash: z.ZodString;
+        status: z.ZodEnum<{
+            reserved: "reserved";
+            committed: "committed";
+            released: "released";
+            planned: "planned";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>>;
+    openedAtMs: z.ZodNumber;
+}, z.core.$strip>;
+export type ISettlementOpenInput = z.infer<typeof ISettlementOpenInputSchema>;
+/**
+ * Input for `markLegReserved` — advances one leg `planned → reserved` once its
+ * block-side reserve succeeds. Legs are addressed by `blockId`.
+ */
+export declare const ISettlementMarkLegReservedInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    blockId: z.ZodString;
+}, z.core.$strip>;
+export type ISettlementMarkLegReservedInput = z.infer<typeof ISettlementMarkLegReservedInputSchema>;
+/**
+ * Input for `beginCommit` — the commit point: phase `PREPARING → COMMITTING`.
+ * Valid only when every leg is `reserved`.
+ */
+export declare const ISettlementBeginCommitInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+export type ISettlementBeginCommitInput = z.infer<typeof ISettlementBeginCommitInputSchema>;
+/**
+ * Input for `markLegCommitted` — advances one leg `reserved → committed` after
+ * its block-side commit lands.
+ */
+export declare const ISettlementMarkLegCommittedInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    blockId: z.ZodString;
+}, z.core.$strip>;
+export type ISettlementMarkLegCommittedInput = z.infer<typeof ISettlementMarkLegCommittedInputSchema>;
+/**
+ * Input for `finishCommit` — phase `COMMITTING → COMMITTED` (terminal) once
+ * every leg is committed. Stamps `terminalAtMs`.
+ */
+export declare const ISettlementFinishCommitInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    terminalAtMs: z.ZodNumber;
+}, z.core.$strip>;
+export type ISettlementFinishCommitInput = z.infer<typeof ISettlementFinishCommitInputSchema>;
+/**
+ * Input for `beginAbort` — phase `PREPARING → ABORTING` when a leg fails to
+ * reserve before the commit point. `reason` is optional audit context.
+ */
+export declare const ISettlementBeginAbortInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ISettlementBeginAbortInput = z.infer<typeof ISettlementBeginAbortInputSchema>;
+/**
+ * Input for `markLegReleased` — advances a `reserved` leg to `released` after
+ * its block-side release unwinds the hold (abort path).
+ */
+export declare const ISettlementMarkLegReleasedInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    blockId: z.ZodString;
+}, z.core.$strip>;
+export type ISettlementMarkLegReleasedInput = z.infer<typeof ISettlementMarkLegReleasedInputSchema>;
+/**
+ * Input for `finishAbort` — phase `ABORTING → ABORTED` (terminal) once every
+ * reserved leg is released. Stamps `terminalAtMs`.
+ */
+export declare const ISettlementFinishAbortInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    terminalAtMs: z.ZodNumber;
+}, z.core.$strip>;
+export type ISettlementFinishAbortInput = z.infer<typeof ISettlementFinishAbortInputSchema>;
+//# sourceMappingURL=settlement-models.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"settlement-models.d.ts","sourceRoot":"","sources":["../../../src/models/settlement/settlement-models.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AASpB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB;;;;;;EAMhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB;;;;;;EAMpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAM5E;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAM1F;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;iBAMrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,qCAAqC;;;iBAGhD,CAAC;AACH,MAAM,MAAM,+BAA+B,GACvC,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,iCAAiC;;iBAE5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACnC,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,sCAAsC;;;iBAGjD,CAAC;AACH,MAAM,MAAM,gCAAgC,GACxC,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,kCAAkC;;;iBAG7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACpC,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,gCAAgC;;;iBAG3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAClC,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,qCAAqC;;;iBAGhD,CAAC;AACH,MAAM,MAAM,+BAA+B,GACvC,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,iCAAiC;;;iBAG5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACnC,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC"}

package/dist/models/settlement/settlement-models.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISettlementFinishAbortInputSchema = exports.ISettlementMarkLegReleasedInputSchema = exports.ISettlementBeginAbortInputSchema = exports.ISettlementFinishCommitInputSchema = exports.ISettlementMarkLegCommittedInputSchema = exports.ISettlementBeginCommitInputSchema = exports.ISettlementMarkLegReservedInputSchema = exports.ISettlementOpenInputSchema = exports.ISettlementShareBlockStateSchema = exports.ISettlementLegSchema = exports.SettlementLegStatusSchema = exports.SettlementPhaseSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const shareblock_models_1 = require("../shareblock/shareblock-models");
+//#region Phase + leg status
+/**
+ * Two-phase-commit phase of a settlement, journaled on the coordinator's
+ * state. The legal transition graph (enforced by `buildSettlementPhaseRule`):
+ *
+ *   PREPARING ──▶ COMMITTING ──▶ COMMITTED   (terminal)
+ *      │
+ *      └────────▶ ABORTING  ──▶ ABORTED      (terminal)
+ *
+ * `COMMITTING` is the point of no return: once reached, every leg was already
+ * reserved, so the settlement can only roll forward. Failures before that
+ * point route to `ABORTING`. Terminals are sinks.
+ */
+exports.SettlementPhaseSchema = zod_1.default.enum([
+    'PREPARING',
+    'COMMITTING',
+    'ABORTING',
+    'COMMITTED',
+    'ABORTED',
+]);
+/**
+ * Per-leg status as tracked by the coordinator (a superset of the member
+ * block's `ReservationStatus`):
+ *
+ *   - `planned`   — in the plan, not yet reserved on its block.
+ *   - `reserved`  — successfully held on its block (PREPARE done for this leg).
+ *   - `committed` — finalized on its block.
+ *   - `released`  — unwound on its block (abort path).
+ *   - `failed`    — its reserve threw (drift/overdraw); triggers settlement
+ *                   abort.
+ */
+exports.SettlementLegStatusSchema = zod_1.default.enum([
+    'planned',
+    'reserved',
+    'committed',
+    'released',
+    'failed',
+]);
+//#endregion Phase + leg status
+//#region Leg + coordinator state
+/**
+ * One leg of a settlement plan as recorded on the coordinator. A transfer is a
+ * `debit` leg (source) + a `credit` leg (destination) of equal `amountCents`.
+ * `againstHash` pins the leg to the target block's current-state hash at plan
+ * time (D5): if the block advanced, the reserve fails and the settlement
+ * aborts. `currency` is not carried per-leg — a settlement is single-currency
+ * (see the coordinator's `currency`).
+ */
+exports.ISettlementLegSchema = zod_1.default.object({
+    blockId: zod_1.default.string(),
+    direction: shareblock_models_1.SettlementLegDirectionSchema,
+    amountCents: zod_1.default.number().int().positive(),
+    againstHash: zod_1.default.string(),
+    status: exports.SettlementLegStatusSchema,
+});
+/**
+ * The coordinator ShareBlock's state. A Settlement block is not a money-
+ * holding block — its inherited `balance` stays at zero and `participants` is
+ * empty; its real payload is the plan (`legs`), the 2PC `phase`, and the
+ * timestamps. The block's append-only transaction history is the durable
+ * journal that crash-recovery re-drives.
+ */
+exports.ISettlementShareBlockStateSchema = shareblock_models_1.IShareBlockStateSchema.extend({
+    blockType: zod_1.default.literal(shareblock_models_1.ShareBlockTypeSchema.enum.Settlement),
+    settlementId: zod_1.default.string(),
+    // Opaque currency code; equality-checked against member legs, never
+    // converted. Loosened from the base `min(3).max(3)` per the settlement
+    // design (one settlement = one currency).
+    currency: zod_1.default.string(),
+    phase: exports.SettlementPhaseSchema,
+    legs: zod_1.default.array(exports.ISettlementLegSchema),
+    openedAtMs: zod_1.default.number().int().nonnegative(),
+    /** Stamped when the block reaches a terminal phase (COMMITTED/ABORTED). */
+    terminalAtMs: zod_1.default.number().int().nonnegative().optional(),
+});
+//#endregion Leg + coordinator state
+//#region Coordinator function inputs
+/**
+ * Input for the coordinator `openSettlement` function — establishes the plan
+ * as the first journaled transaction (phase `PREPARING`, every leg `planned`).
+ */
+exports.ISettlementOpenInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    settlementId: zod_1.default.string(),
+    currency: zod_1.default.string(),
+    legs: zod_1.default.array(exports.ISettlementLegSchema),
+    openedAtMs: zod_1.default.number().int().nonnegative(),
+});
+/**
+ * Input for `markLegReserved` — advances one leg `planned → reserved` once its
+ * block-side reserve succeeds. Legs are addressed by `blockId`.
+ */
+exports.ISettlementMarkLegReservedInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    blockId: zod_1.default.string(),
+});
+/**
+ * Input for `beginCommit` — the commit point: phase `PREPARING → COMMITTING`.
+ * Valid only when every leg is `reserved`.
+ */
+exports.ISettlementBeginCommitInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+});
+/**
+ * Input for `markLegCommitted` — advances one leg `reserved → committed` after
+ * its block-side commit lands.
+ */
+exports.ISettlementMarkLegCommittedInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    blockId: zod_1.default.string(),
+});
+/**
+ * Input for `finishCommit` — phase `COMMITTING → COMMITTED` (terminal) once
+ * every leg is committed. Stamps `terminalAtMs`.
+ */
+exports.ISettlementFinishCommitInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    terminalAtMs: zod_1.default.number().int().nonnegative(),
+});
+/**
+ * Input for `beginAbort` — phase `PREPARING → ABORTING` when a leg fails to
+ * reserve before the commit point. `reason` is optional audit context.
+ */
+exports.ISettlementBeginAbortInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    reason: zod_1.default.string().optional(),
+});
+/**
+ * Input for `markLegReleased` — advances a `reserved` leg to `released` after
+ * its block-side release unwinds the hold (abort path).
+ */
+exports.ISettlementMarkLegReleasedInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    blockId: zod_1.default.string(),
+});
+/**
+ * Input for `finishAbort` — phase `ABORTING → ABORTED` (terminal) once every
+ * reserved leg is released. Stamps `terminalAtMs`.
+ */
+exports.ISettlementFinishAbortInputSchema = zod_1.default.object({
+    userId: zod_1.default.string(),
+    terminalAtMs: zod_1.default.number().int().nonnegative(),
+});
+//#endregion Coordinator function inputs

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

@@ -45,6 +45,43 @@ export declare const ShareDataProofsSchema: z.ZodRecord<z.ZodString, z.ZodObject
     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

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

@@ -1 +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;AAMpE;;;;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"}
+{"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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IShareDataAdditionalValuesToIncludeSchema = exports.IShareDataConfigSchema = exports.IShareDataPropertyConfigSchema = exports.ShareDataProofsSchema = exports.IShareDataCryptoProofSchema = exports.IShareDataInitialCryptoDataSchema = void 0;
+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");
@@ -51,6 +51,46 @@ exports.IShareDataCryptoProofSchema = zod_1.z.object({
  * `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
 /**