@degenerate/generic 0.4.0 → 0.6.0

package/dist/_settings/cryptography-settings.d.ts

@@ -30,7 +30,11 @@ export declare enum EllipticalCurvesEncryption {
     P521 = "p521"
 }
 /**
- * This contains the values for the elliptical curvers for signing
+ * This contains the values for the elliptical curves for signing.
+ *
+ * `Curve25519 = 'ed25519'` selects the Edwards25519 curve, signed with true
+ * EdDSA (RFC 8032) via `@noble/ed25519`. `P521` is retained as a recorded curve
+ * label for persistence forward-compatibility; no shipped factory uses it.
  */
 export declare enum EllipticalCurvesSigning {
     Curve25519 = "ed25519",

package/dist/_settings/cryptography-settings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cryptography-settings.d.ts","sourceRoot":"","sources":["../../src/_settings/cryptography-settings.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC;;GAEG;AACH,eAAO,MAAM,cAAc;;;;gBAIF,MAAM,CAAC,oBAAoB;;;;;;kBAMxB,MAAM,CAAC,QAAQ;CAC1C,CAAC;AAGF,eAAO,MAAM,cAAc,EAAe,cAAc,CAAC;AACzD,eAAO,MAAM,WAAW,EAAY,cAAc,CAAC;AAGnD,eAAO,MAAM,iBAAiB,SAAS,CAAC;AACxC,eAAO,MAAM,iBAAiB,SAAS,CAAC;AACxC,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC;;GAEG;AACH,oBAAY,0BAA0B;IAClC,UAAU,eAAe;IACzB,IAAI,SAAS;CAChB;AAED;;GAEG;AACH,oBAAY,uBAAuB;IAC/B,UAAU,YAAY;IACtB,IAAI,SAAS;CAChB"}
+{"version":3,"file":"cryptography-settings.d.ts","sourceRoot":"","sources":["../../src/_settings/cryptography-settings.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC;;GAEG;AACH,eAAO,MAAM,cAAc;;;;gBAIF,MAAM,CAAC,oBAAoB;;;;;;kBAMxB,MAAM,CAAC,QAAQ;CAC1C,CAAC;AAGF,eAAO,MAAM,cAAc,EAAe,cAAc,CAAC;AACzD,eAAO,MAAM,WAAW,EAAY,cAAc,CAAC;AAGnD,eAAO,MAAM,iBAAiB,SAAS,CAAC;AACxC,eAAO,MAAM,iBAAiB,SAAS,CAAC;AACxC,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC;;GAEG;AACH,oBAAY,0BAA0B;IAClC,UAAU,eAAe;IACzB,IAAI,SAAS;CAChB;AAED;;;;;;GAMG;AACH,oBAAY,uBAAuB;IAC/B,UAAU,YAAY;IACtB,IAAI,SAAS;CAChB"}

package/dist/_settings/cryptography-settings.js

@@ -32,7 +32,11 @@ var EllipticalCurvesEncryption;
     EllipticalCurvesEncryption["P521"] = "p521";
 })(EllipticalCurvesEncryption || (exports.EllipticalCurvesEncryption = EllipticalCurvesEncryption = {}));
 /**
- * This contains the values for the elliptical curvers for signing
+ * This contains the values for the elliptical curves for signing.
+ *
+ * `Curve25519 = 'ed25519'` selects the Edwards25519 curve, signed with true
+ * EdDSA (RFC 8032) via `@noble/ed25519`. `P521` is retained as a recorded curve
+ * label for persistence forward-compatibility; no shipped factory uses it.
  */
 var EllipticalCurvesSigning;
 (function (EllipticalCurvesSigning) {

package/dist/crypto/index.d.ts

@@ -1,15 +1,11 @@
 export * from './calculate-hash';
 export * from './calculate-combined-hash';
 export * from './private-public-keys/generation/create-256-private-key-from-mnemonic';
-export * from './private-public-keys/generation/create-entropy-for-elliptical-curve';
 export * from './private-public-keys/generation/create-random-256-private-key';
 export * from './private-public-keys/generation/create-random-512-key-pair';
-export * from './private-public-keys/generation/generate-key-pair';
-export * from './private-public-keys/generation/get-private-public-key-from-keypair';
-export * from './private-public-keys/create-key-pair-from-private-key';
-export * from './private-public-keys/create-key-pair-from-mnemonic';
-export * from './private-public-keys/create-key-pair-from-public-key';
-export * from './signature/create-crypto-signature';
-export * from './signature/verify-crypto-signature-by-data';
-export * from './signature/verify-crypto-signature-by-hash';
+export * from './private-public-keys/create-ed25519-keys-from-mnemonic';
+export * from './private-public-keys/get-ed25519-public-key-from-private-key';
+export * from './signature/ed25519-primitives';
+export * from './signature/create-ed25519-signature';
+export * from './signature/verify-ed25519-signature';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAK1C,cAAc,uEAAuE,CAAC;AACtF,cAAc,sEAAsE,CAAC;AACrF,cAAc,gEAAgE,CAAC;AAC/E,cAAc,6DAA6D,CAAC;AAC5E,cAAc,oDAAoD,CAAC;AACnE,cAAc,sEAAsE,CAAC;AAGrF,cAAc,wDAAwD,CAAC;AACvE,cAAc,qDAAqD,CAAC;AACpE,cAAc,uDAAuD,CAAC;AAMtE,cAAc,qCAAqC,CAAC;AACpD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAK1C,cAAc,uEAAuE,CAAC;AACtF,cAAc,gEAAgE,CAAC;AAC/E,cAAc,6DAA6D,CAAC;AAI5E,cAAc,yDAAyD,CAAC;AACxE,cAAc,+DAA+D,CAAC;AAO9E,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC"}

package/dist/crypto/index.js

@@ -19,18 +19,16 @@ __exportStar(require("./calculate-combined-hash"), exports);
 //#region folder private-public-keys
 //#region folder generation
 __exportStar(require("./private-public-keys/generation/create-256-private-key-from-mnemonic"), exports);
-__exportStar(require("./private-public-keys/generation/create-entropy-for-elliptical-curve"), exports);
 __exportStar(require("./private-public-keys/generation/create-random-256-private-key"), exports);
 __exportStar(require("./private-public-keys/generation/create-random-512-key-pair"), exports);
-__exportStar(require("./private-public-keys/generation/generate-key-pair"), exports);
-__exportStar(require("./private-public-keys/generation/get-private-public-key-from-keypair"), exports);
 //#endregion folder generation
-__exportStar(require("./private-public-keys/create-key-pair-from-private-key"), exports);
-__exportStar(require("./private-public-keys/create-key-pair-from-mnemonic"), exports);
-__exportStar(require("./private-public-keys/create-key-pair-from-public-key"), exports);
+// EdDSA (true Ed25519) key derivation — the sole signing-key path.
+__exportStar(require("./private-public-keys/create-ed25519-keys-from-mnemonic"), exports);
+__exportStar(require("./private-public-keys/get-ed25519-public-key-from-private-key"), exports);
 //#endregion folder private-public-keys
 //#region folder signature
-__exportStar(require("./signature/create-crypto-signature"), exports);
-__exportStar(require("./signature/verify-crypto-signature-by-data"), exports);
-__exportStar(require("./signature/verify-crypto-signature-by-hash"), exports);
+// EdDSA (true Ed25519) signing primitives — the sole signature path.
+__exportStar(require("./signature/ed25519-primitives"), exports);
+__exportStar(require("./signature/create-ed25519-signature"), exports);
+__exportStar(require("./signature/verify-ed25519-signature"), exports);
 //#endregion folder signature

package/dist/crypto/private-public-keys/create-ed25519-keys-from-mnemonic.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Derives a true Ed25519 (EdDSA) keypair from a mnemonic.
+ *
+ * Derivation (pinned, RFC 8032): the 32-byte Ed25519 secret SEED is
+ * `SHA-256(mnemonic)` — the same 32 bytes the legacy `elliptic` path fed into
+ * `keyFromPrivate`, but here interpreted as an Ed25519 seed rather than an ECDSA
+ * private scalar. The public key is `ed25519.getPublicKey(seed)`.
+ *
+ * Because EdDSA hashes-and-clamps the seed to form its scalar, the PUBLIC KEY for
+ * a given mnemonic differs from the legacy ECDSA-over-ed25519 public key derived
+ * from the same mnemonic. The mnemonic still works, but the identity it maps to
+ * changes — the "same mnemonic → different identity" break in the migration plan
+ * (§3c). Any record of "this mnemonic owns public key X" must be re-derived.
+ *
+ * @param mnemonic the BIP39 mnemonic phrase.
+ * @returns hex-encoded `{ privateKey (32-byte seed), publicKey (32-byte) }`.
+ */
+export declare const createEd25519KeysFromMnemonic: (mnemonic: string) => {
+    privateKey: string;
+    publicKey: string;
+};
+//# sourceMappingURL=create-ed25519-keys-from-mnemonic.d.ts.map

package/dist/crypto/private-public-keys/create-ed25519-keys-from-mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-ed25519-keys-from-mnemonic.d.ts","sourceRoot":"","sources":["../../../src/crypto/private-public-keys/create-ed25519-keys-from-mnemonic.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,6BAA6B,GACtC,UAAU,MAAM,KACjB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAOzC,CAAC"}

package/dist/crypto/private-public-keys/create-ed25519-keys-from-mnemonic.js

@@ -0,0 +1,65 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEd25519KeysFromMnemonic = void 0;
+const crypto = __importStar(require("crypto"));
+const ed25519_primitives_1 = require("../signature/ed25519-primitives");
+const cryptography_settings_1 = require("../../_settings/cryptography-settings");
+/**
+ * Derives a true Ed25519 (EdDSA) keypair from a mnemonic.
+ *
+ * Derivation (pinned, RFC 8032): the 32-byte Ed25519 secret SEED is
+ * `SHA-256(mnemonic)` — the same 32 bytes the legacy `elliptic` path fed into
+ * `keyFromPrivate`, but here interpreted as an Ed25519 seed rather than an ECDSA
+ * private scalar. The public key is `ed25519.getPublicKey(seed)`.
+ *
+ * Because EdDSA hashes-and-clamps the seed to form its scalar, the PUBLIC KEY for
+ * a given mnemonic differs from the legacy ECDSA-over-ed25519 public key derived
+ * from the same mnemonic. The mnemonic still works, but the identity it maps to
+ * changes — the "same mnemonic → different identity" break in the migration plan
+ * (§3c). Any record of "this mnemonic owns public key X" must be re-derived.
+ *
+ * @param mnemonic the BIP39 mnemonic phrase.
+ * @returns hex-encoded `{ privateKey (32-byte seed), publicKey (32-byte) }`.
+ */
+const createEd25519KeysFromMnemonic = (mnemonic) => {
+    const seedHex = crypto
+        .createHash(cryptography_settings_1.CryptoSettings.Hash.Algorithm)
+        .update(mnemonic, cryptography_settings_1.CryptoSettings.TextEncoding)
+        .digest(cryptography_settings_1.CryptoSettings.Hash.Digest);
+    const publicKey = ed25519_primitives_1.ed.etc.bytesToHex(ed25519_primitives_1.ed.getPublicKey(ed25519_primitives_1.ed.etc.hexToBytes(seedHex)));
+    return { privateKey: seedHex, publicKey };
+};
+exports.createEd25519KeysFromMnemonic = createEd25519KeysFromMnemonic;

package/dist/crypto/private-public-keys/get-ed25519-public-key-from-private-key.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Derives the 32-byte Ed25519 public key (hex) from a 32-byte Ed25519 secret
+ * seed (hex). The EdDSA counterpart to `getPublicKeyFromKeyPair` for the legacy
+ * path — useful when only the private seed is on hand (e.g. recovered from a
+ * mnemonic) and the matching public identity is needed.
+ *
+ * @param privateKey 32-byte Ed25519 secret seed as hex.
+ * @returns the 32-byte Ed25519 public key as hex (64 chars).
+ */
+export declare const getEd25519PublicKeyFromPrivateKey: (privateKey: string) => string;
+//# sourceMappingURL=get-ed25519-public-key-from-private-key.d.ts.map

package/dist/crypto/private-public-keys/get-ed25519-public-key-from-private-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-ed25519-public-key-from-private-key.d.ts","sourceRoot":"","sources":["../../../src/crypto/private-public-keys/get-ed25519-public-key-from-private-key.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,GAAI,YAAY,MAAM,KAAG,MACF,CAAC"}

package/dist/crypto/private-public-keys/get-ed25519-public-key-from-private-key.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEd25519PublicKeyFromPrivateKey = void 0;
+const ed25519_primitives_1 = require("../signature/ed25519-primitives");
+/**
+ * Derives the 32-byte Ed25519 public key (hex) from a 32-byte Ed25519 secret
+ * seed (hex). The EdDSA counterpart to `getPublicKeyFromKeyPair` for the legacy
+ * path — useful when only the private seed is on hand (e.g. recovered from a
+ * mnemonic) and the matching public identity is needed.
+ *
+ * @param privateKey 32-byte Ed25519 secret seed as hex.
+ * @returns the 32-byte Ed25519 public key as hex (64 chars).
+ */
+const getEd25519PublicKeyFromPrivateKey = (privateKey) => ed25519_primitives_1.ed.etc.bytesToHex(ed25519_primitives_1.ed.getPublicKey(ed25519_primitives_1.ed.etc.hexToBytes(privateKey)));
+exports.getEd25519PublicKeyFromPrivateKey = getEd25519PublicKeyFromPrivateKey;

package/dist/crypto/signature/create-ed25519-signature.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Signs a message with a true Ed25519 (EdDSA) secret seed.
+ *
+ * Unlike `createEllipticalCurveSignature`, this does NOT pre-hash the message.
+ * Ed25519 hashes the full message with SHA-512 internally (RFC 8032) and has no
+ * input-length truncation, so the SHA-256 pre-hash the ECDSA path needs to
+ * defend its 3-bit truncation would only discard information here. The UTF-8
+ * bytes of `message` are signed directly; `verifyEd25519Signature` mirrors this
+ * exactly.
+ *
+ * @param privateKey 32-byte Ed25519 secret seed as hex (e.g. SHA-256(mnemonic)).
+ * @param message the message string to sign.
+ * @returns the 64-byte EdDSA signature as hex (128 chars).
+ */
+export declare const createEd25519Signature: (privateKey: string, message: string) => string;
+//# sourceMappingURL=create-ed25519-signature.d.ts.map

package/dist/crypto/signature/create-ed25519-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-ed25519-signature.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/create-ed25519-signature.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GAAI,YAAY,MAAM,EAAE,SAAS,MAAM,KAAG,MAK5E,CAAC"}

package/dist/crypto/signature/create-ed25519-signature.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEd25519Signature = void 0;
+const ed25519_primitives_1 = require("./ed25519-primitives");
+const cryptography_settings_1 = require("../../_settings/cryptography-settings");
+/**
+ * Signs a message with a true Ed25519 (EdDSA) secret seed.
+ *
+ * Unlike `createEllipticalCurveSignature`, this does NOT pre-hash the message.
+ * Ed25519 hashes the full message with SHA-512 internally (RFC 8032) and has no
+ * input-length truncation, so the SHA-256 pre-hash the ECDSA path needs to
+ * defend its 3-bit truncation would only discard information here. The UTF-8
+ * bytes of `message` are signed directly; `verifyEd25519Signature` mirrors this
+ * exactly.
+ *
+ * @param privateKey 32-byte Ed25519 secret seed as hex (e.g. SHA-256(mnemonic)).
+ * @param message the message string to sign.
+ * @returns the 64-byte EdDSA signature as hex (128 chars).
+ */
+const createEd25519Signature = (privateKey, message) => {
+    const seed = ed25519_primitives_1.ed.etc.hexToBytes(privateKey);
+    const messageBytes = Buffer.from(message, cryptography_settings_1.CryptoSettings.TextEncoding);
+    const signature = ed25519_primitives_1.ed.sign(messageBytes, seed);
+    return ed25519_primitives_1.ed.etc.bytesToHex(signature);
+};
+exports.createEd25519Signature = createEd25519Signature;

package/dist/crypto/signature/ed25519-primitives.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared access point to the configured `@noble/ed25519` module.
+ *
+ * `@noble/ed25519` v3 ships ESM-only (`"type": "module"`, no CommonJS build).
+ * Our packages emit CommonJS (`module: "node16"`), where a static
+ * `import * as ed from '@noble/ed25519'` makes `tsc` emit a `require()` of an
+ * ESM module and reject it at compile time (TS1479). Node ≥22.12 can `require()`
+ * a synchronous ESM graph, and noble has no top-level await, so a runtime
+ * `require` resolves fine. `typeof import(...)` is a type-only query — fully
+ * erased, emits no import — so it gives full typings without re-triggering
+ * TS1479. Jest loads the same specifier via its `@noble/ed25519` → source-`.ts`
+ * moduleNameMapper + transformIgnorePatterns exception.
+ *
+ * v3's synchronous API (`getPublicKey` / `sign` / `verify`) refuses to run until
+ * a synchronous SHA-512 is wired into `ed.hashes.sha512`. We back it with Node's
+ * `crypto` so the rest of the codebase keeps its synchronous signing/verification
+ * call shape — the structural-proof verifier (`verifyShareDataProposalProof`) is
+ * synchronous on purpose and we don't want to cascade-async every caller.
+ *
+ * The hook receives the already-concatenated message bytes and must return a
+ * 64-byte digest. Guarded so re-importing this module does not re-assign it.
+ */
+declare const ed: typeof import('@noble/ed25519', { with: { 'resolution-mode': 'import' } });
+export { ed };
+//# sourceMappingURL=ed25519-primitives.d.ts.map

package/dist/crypto/signature/ed25519-primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519-primitives.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/ed25519-primitives.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,QAAA,MAAM,EAAE,EAAE,cAAc,gBAAgB,EAAU,UAAE,iBAAiB,EAAE,QAAQ,IAAE,CACpD,CAAC;AAM9B,OAAO,EAAE,EAAE,EAAE,CAAC"}

package/dist/crypto/signature/ed25519-primitives.js

@@ -0,0 +1,65 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed = void 0;
+const crypto = __importStar(require("crypto"));
+/**
+ * Shared access point to the configured `@noble/ed25519` module.
+ *
+ * `@noble/ed25519` v3 ships ESM-only (`"type": "module"`, no CommonJS build).
+ * Our packages emit CommonJS (`module: "node16"`), where a static
+ * `import * as ed from '@noble/ed25519'` makes `tsc` emit a `require()` of an
+ * ESM module and reject it at compile time (TS1479). Node ≥22.12 can `require()`
+ * a synchronous ESM graph, and noble has no top-level await, so a runtime
+ * `require` resolves fine. `typeof import(...)` is a type-only query — fully
+ * erased, emits no import — so it gives full typings without re-triggering
+ * TS1479. Jest loads the same specifier via its `@noble/ed25519` → source-`.ts`
+ * moduleNameMapper + transformIgnorePatterns exception.
+ *
+ * v3's synchronous API (`getPublicKey` / `sign` / `verify`) refuses to run until
+ * a synchronous SHA-512 is wired into `ed.hashes.sha512`. We back it with Node's
+ * `crypto` so the rest of the codebase keeps its synchronous signing/verification
+ * call shape — the structural-proof verifier (`verifyShareDataProposalProof`) is
+ * synchronous on purpose and we don't want to cascade-async every caller.
+ *
+ * The hook receives the already-concatenated message bytes and must return a
+ * 64-byte digest. Guarded so re-importing this module does not re-assign it.
+ */
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const ed = require('@noble/ed25519');
+exports.ed = ed;
+if (!ed.hashes.sha512) {
+    ed.hashes.sha512 = (message) => Uint8Array.from(crypto.createHash('sha512').update(message).digest());
+}

package/dist/crypto/signature/verify-ed25519-signature.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Verifies a true Ed25519 (EdDSA) signature over `message` for `publicKey`.
+ *
+ * Mirrors `createEd25519Signature`: the raw UTF-8 bytes of `message` are
+ * verified directly, with no SHA-256 pre-hash (Ed25519 hashes internally).
+ *
+ * @param publicKey 32-byte Ed25519 public key as hex (64 chars).
+ * @param message the message string that was signed.
+ * @param signature the 64-byte EdDSA signature as hex.
+ * @returns `true` when the signature is valid, `false` otherwise.
+ */
+export declare const verifyEd25519Signature: (publicKey: string, message: string, signature: string) => boolean;
+//# sourceMappingURL=verify-ed25519-signature.d.ts.map

package/dist/crypto/signature/verify-ed25519-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-ed25519-signature.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/verify-ed25519-signature.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GAC/B,WAAW,MAAM,EACjB,SAAS,MAAM,EACf,WAAW,MAAM,KAClB,OAYF,CAAC"}

package/dist/crypto/signature/verify-ed25519-signature.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyEd25519Signature = void 0;
+const ed25519_primitives_1 = require("./ed25519-primitives");
+const cryptography_settings_1 = require("../../_settings/cryptography-settings");
+/**
+ * Verifies a true Ed25519 (EdDSA) signature over `message` for `publicKey`.
+ *
+ * Mirrors `createEd25519Signature`: the raw UTF-8 bytes of `message` are
+ * verified directly, with no SHA-256 pre-hash (Ed25519 hashes internally).
+ *
+ * @param publicKey 32-byte Ed25519 public key as hex (64 chars).
+ * @param message the message string that was signed.
+ * @param signature the 64-byte EdDSA signature as hex.
+ * @returns `true` when the signature is valid, `false` otherwise.
+ */
+const verifyEd25519Signature = (publicKey, message, signature) => {
+    try {
+        const publicKeyBytes = ed25519_primitives_1.ed.etc.hexToBytes(publicKey);
+        const signatureBytes = ed25519_primitives_1.ed.etc.hexToBytes(signature);
+        const messageBytes = Buffer.from(message, cryptography_settings_1.CryptoSettings.TextEncoding);
+        return ed25519_primitives_1.ed.verify(signatureBytes, messageBytes, publicKeyBytes);
+    }
+    catch {
+        // noble throws (TypeError/RangeError) on malformed hex or wrong byte
+        // lengths rather than returning false. Normalize to a single rejection
+        // mode so a tampered/garbage signature reads as "invalid", not an error.
+        return false;
+    }
+};
+exports.verifyEd25519Signature = verifyEd25519Signature;

package/dist/errors/index.d.ts

@@ -5,6 +5,7 @@ export * from './generic/generic-errors';
 export * from './request/request-errors';
 export * from './safe/safe-rules-errors';
 export * from './scheduler/scheduler-errors';
+export * from './settlement/settlement-errors';
 export * from './share-data/share-data-errors';
 export * from './shareblock/shareblock-errors';
 export * from './validation/crypto-validation-errors';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AAGtD,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AAGtD,cAAc,cAAc,CAAC"}

package/dist/errors/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./generic/generic-errors"), exports);
 __exportStar(require("./request/request-errors"), exports);
 __exportStar(require("./safe/safe-rules-errors"), exports);
 __exportStar(require("./scheduler/scheduler-errors"), exports);
+__exportStar(require("./settlement/settlement-errors"), exports);
 __exportStar(require("./share-data/share-data-errors"), exports);
 __exportStar(require("./shareblock/shareblock-errors"), exports);
 __exportStar(require("./validation/crypto-validation-errors"), exports);

package/dist/errors/settlement/settlement-errors.d.ts

@@ -0,0 +1,74 @@
+import { BaseError } from '../base-error';
+import { SettlementPhase } from '../../models/settlement/settlement-models';
+/**
+ * Thrown when a settlement leg's target block has advanced since the leg was
+ * signed. The leg's `againstHash` no longer matches the block's current-state
+ * hash, so reserving against it would bind a stale transition (D5 drift
+ * guard). The orchestrator treats this as a reserve failure and aborts the
+ * whole settlement.
+ */
+export declare class SettlementLegDriftError extends BaseError {
+    readonly settlementId: string;
+    readonly blockId: string;
+    readonly expectedHash: string;
+    readonly actualHash: string;
+    constructor(settlementId: string, blockId: string, expectedHash: string, actualHash: string);
+}
+/**
+ * Thrown when a coordinator phase transition is illegal under the 2PC graph
+ * (e.g. `PREPARING → COMMITTED` skipping `COMMITTING`, or any move out of a
+ * terminal phase). Enforced by `buildSettlementPhaseRule`.
+ */
+export declare class SettlementPhaseError extends BaseError {
+    readonly settlementId: string;
+    readonly fromPhase: SettlementPhase;
+    readonly toPhase: SettlementPhase;
+    constructor(settlementId: string, fromPhase: SettlementPhase, toPhase: SettlementPhase);
+}
+/**
+ * Thrown when a settlement tries to reserve against a block that already holds
+ * a different, conflicting reservation under the same `settlementId`. (A
+ * re-drive with identical terms is idempotent and is not a conflict.)
+ */
+export declare class SettlementReservationConflictError extends BaseError {
+    readonly settlementId: string;
+    readonly blockId: string;
+    constructor(settlementId: string, blockId: string);
+}
+/**
+ * Thrown when an operation references a leg (by `blockId`) that is not part of
+ * the settlement's plan.
+ */
+export declare class SettlementLegNotFoundError extends BaseError {
+    readonly settlementId: string;
+    readonly blockId: string;
+    constructor(settlementId: string, blockId: string);
+}
+/**
+ * Thrown when a mutating operation targets a settlement already in a terminal
+ * phase (`COMMITTED` or `ABORTED`). The journal says it finished; it cannot be
+ * reopened.
+ */
+export declare class SettlementAlreadyTerminalError extends BaseError {
+    readonly settlementId: string;
+    readonly phase: SettlementPhase;
+    constructor(settlementId: string, phase: SettlementPhase);
+}
+/**
+ * Thrown when a leg's block-side reserve does not take hold — the member block
+ * refused the PREPARE. The reserve function no-ops (returns `current`) on an
+ * overdraw, a closed block, a currency mismatch, or malformed input, and the
+ * rule engine can reject a crafted proposal; in every case the post-condition
+ * (`reservations[settlementId]` present and matching the leg) is unmet. The
+ * in-process executor surfaces that as this error, which the orchestrator
+ * treats as a reserve failure and aborts the whole settlement. `reason` carries
+ * human-readable context (the underlying cause cannot always be distinguished
+ * from a no-op flag alone).
+ */
+export declare class SettlementLegReserveFailedError extends BaseError {
+    readonly settlementId: string;
+    readonly blockId: string;
+    readonly reason: string;
+    constructor(settlementId: string, blockId: string, reason: string);
+}
+//# sourceMappingURL=settlement-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"settlement-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/settlement/settlement-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAE5E;;;;;;GAMG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IAClD,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,UAAU,EAAE,MAAM,CAAC;gBAEvB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAS9F;AAED;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAC/C,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,SAAS,EAAE,eAAe,CAAC;IAC3C,SAAgB,OAAO,EAAE,eAAe,CAAC;gBAE7B,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe;CAQzF;AAED;;;;GAIG;AACH,qBAAa,kCAAmC,SAAQ,SAAS;IAC7D,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,CAAC;gBAEpB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAOpD;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,SAAS;IACrD,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,CAAC;gBAEpB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAOpD;AAED;;;;GAIG;AACH,qBAAa,8BAA+B,SAAQ,SAAS;IACzD,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,KAAK,EAAE,eAAe,CAAC;gBAE3B,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe;CAO3D;AAED;;;;;;;;;;GAUG;AACH,qBAAa,+BAAgC,SAAQ,SAAS;IAC1D,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEnB,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQpE"}

package/dist/errors/settlement/settlement-errors.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettlementLegReserveFailedError = exports.SettlementAlreadyTerminalError = exports.SettlementLegNotFoundError = exports.SettlementReservationConflictError = exports.SettlementPhaseError = exports.SettlementLegDriftError = void 0;
+const base_error_1 = require("../base-error");
+/**
+ * Thrown when a settlement leg's target block has advanced since the leg was
+ * signed. The leg's `againstHash` no longer matches the block's current-state
+ * hash, so reserving against it would bind a stale transition (D5 drift
+ * guard). The orchestrator treats this as a reserve failure and aborts the
+ * whole settlement.
+ */
+class SettlementLegDriftError extends base_error_1.BaseError {
+    constructor(settlementId, blockId, expectedHash, actualHash) {
+        super(`Settlement ${settlementId}: block ${blockId} drifted — leg signed against ${expectedHash}, block is now ${actualHash}.`);
+        this.settlementId = settlementId;
+        this.blockId = blockId;
+        this.expectedHash = expectedHash;
+        this.actualHash = actualHash;
+    }
+}
+exports.SettlementLegDriftError = SettlementLegDriftError;
+/**
+ * Thrown when a coordinator phase transition is illegal under the 2PC graph
+ * (e.g. `PREPARING → COMMITTED` skipping `COMMITTING`, or any move out of a
+ * terminal phase). Enforced by `buildSettlementPhaseRule`.
+ */
+class SettlementPhaseError extends base_error_1.BaseError {
+    constructor(settlementId, fromPhase, toPhase) {
+        super(`Settlement ${settlementId}: illegal phase transition ${fromPhase} → ${toPhase}.`);
+        this.settlementId = settlementId;
+        this.fromPhase = fromPhase;
+        this.toPhase = toPhase;
+    }
+}
+exports.SettlementPhaseError = SettlementPhaseError;
+/**
+ * Thrown when a settlement tries to reserve against a block that already holds
+ * a different, conflicting reservation under the same `settlementId`. (A
+ * re-drive with identical terms is idempotent and is not a conflict.)
+ */
+class SettlementReservationConflictError extends base_error_1.BaseError {
+    constructor(settlementId, blockId) {
+        super(`Settlement ${settlementId}: block ${blockId} already has a conflicting reservation for this settlement.`);
+        this.settlementId = settlementId;
+        this.blockId = blockId;
+    }
+}
+exports.SettlementReservationConflictError = SettlementReservationConflictError;
+/**
+ * Thrown when an operation references a leg (by `blockId`) that is not part of
+ * the settlement's plan.
+ */
+class SettlementLegNotFoundError extends base_error_1.BaseError {
+    constructor(settlementId, blockId) {
+        super(`Settlement ${settlementId}: no leg for block ${blockId} in the plan.`);
+        this.settlementId = settlementId;
+        this.blockId = blockId;
+    }
+}
+exports.SettlementLegNotFoundError = SettlementLegNotFoundError;
+/**
+ * Thrown when a mutating operation targets a settlement already in a terminal
+ * phase (`COMMITTED` or `ABORTED`). The journal says it finished; it cannot be
+ * reopened.
+ */
+class SettlementAlreadyTerminalError extends base_error_1.BaseError {
+    constructor(settlementId, phase) {
+        super(`Settlement ${settlementId}: already terminal (${phase}); no further transitions allowed.`);
+        this.settlementId = settlementId;
+        this.phase = phase;
+    }
+}
+exports.SettlementAlreadyTerminalError = SettlementAlreadyTerminalError;
+/**
+ * Thrown when a leg's block-side reserve does not take hold — the member block
+ * refused the PREPARE. The reserve function no-ops (returns `current`) on an
+ * overdraw, a closed block, a currency mismatch, or malformed input, and the
+ * rule engine can reject a crafted proposal; in every case the post-condition
+ * (`reservations[settlementId]` present and matching the leg) is unmet. The
+ * in-process executor surfaces that as this error, which the orchestrator
+ * treats as a reserve failure and aborts the whole settlement. `reason` carries
+ * human-readable context (the underlying cause cannot always be distinguished
+ * from a no-op flag alone).
+ */
+class SettlementLegReserveFailedError extends base_error_1.BaseError {
+    constructor(settlementId, blockId, reason) {
+        super(`Settlement ${settlementId}: reserve failed for block ${blockId} — ${reason}.`);
+        this.settlementId = settlementId;
+        this.blockId = blockId;
+        this.reason = reason;
+    }
+}
+exports.SettlementLegReserveFailedError = SettlementLegReserveFailedError;

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);