@degenerate/sharedata 0.4.0 → 0.7.0

package/dist/share-data/proofs/creation/create-share-data-proposal-proof.js

@@ -7,23 +7,22 @@ const get_previous_hash_from_share_data_1 = require("../helpers/get-previous-has
 const create_share_data_string_to_sign_1 = require("../helpers/create-share-data-string-to-sign");
 /**
  * This function creates a share data proposal proof.
- * @param privateKey the private key to sign the share data proof
+ * @param privateKey the 32-byte Ed25519 secret seed (hex) to sign the proof with
  * @param shareData the share data object
  * @param additionalValuesToInclude the additional values to include in the share data string
- * @param ellipticalCurve the elliptical curve to use for signing
  * @returns
  */
-const createShareDataProposalProof = (privateKey, shareData, additionalValuesToInclude, ellipticalCurve = generic_1.EllipticalCurvesSigning.Curve25519) => {
-    const keyPair = (0, generic_1.createKeyPairFromPrivateKey)(ellipticalCurve, privateKey);
+const createShareDataProposalProof = (privateKey, shareData, additionalValuesToInclude) => {
+    const publicKey = (0, generic_1.getEd25519PublicKeyFromPrivateKey)(privateKey);
     const shareDataString = (0, calculate_share_data_string_1.calculateShareDataString)(shareData, undefined, additionalValuesToInclude);
     const shareDataPreviousHash = (0, get_previous_hash_from_share_data_1.getPreviousHashFromShareData)(shareData);
     const shareDataHash = (0, generic_1.calculateHash)(shareDataString);
     const currentTimestamp = Date.now();
     // calculate the current signature for the share data proof
     const shareDataSignatureString = (0, create_share_data_string_to_sign_1.createShareDataStringToSign)(shareDataHash, shareDataPreviousHash, currentTimestamp);
-    const shareDataSignature = (0, generic_1.createEllipticalCurveSignature)(keyPair, shareDataSignatureString);
+    const shareDataSignature = (0, generic_1.createEd25519Signature)(privateKey, shareDataSignatureString);
     const shareDataCryptoProof = {
-        publicKey: keyPair.getPublic('hex'),
+        publicKey,
         shareDataHash,
         shareDataPreviousHash,
         shareDataSignature,

package/dist/share-data/proofs/creation/create-transaction-proposal-proof.d.ts

@@ -1,4 +1,4 @@
-import { EllipticalCurvesSigning, IShareData, IShareDataCryptoProof } from '@degenerate/generic';
+import { IShareData, IShareDataCryptoProof } from '@degenerate/generic';
 import { ShareData } from '../../share-data';
 /**
  * Mint a transaction proposal proof: a signed attestation that the holder of
@@ -17,11 +17,10 @@ import { ShareData } from '../../share-data';
  * state it is handed at apply time, so it never needs to be stored in the
  * proof — keeping the wire / persistence / history shape unchanged.
  *
- * @param privateKey hex private key authorized for this share-data
+ * @param privateKey 32-byte Ed25519 secret seed (hex) authorized for this share-data
  * @param shareData the share-data the transaction will mutate
  * @param proposedState the exact state the function proposes to apply
  * @param functionId stable id of the function producing `proposedState`
- * @param ellipticalCurve the signing curve (defaults to Curve25519)
  */
-export declare const createTransactionProposalProof: (privateKey: string, shareData: ShareData, proposedState: IShareData, functionId: string, ellipticalCurve?: EllipticalCurvesSigning) => IShareDataCryptoProof;
+export declare const createTransactionProposalProof: (privateKey: string, shareData: ShareData, proposedState: IShareData, functionId: string) => IShareDataCryptoProof;
 //# sourceMappingURL=create-transaction-proposal-proof.d.ts.map

package/dist/share-data/proofs/creation/create-transaction-proposal-proof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-transaction-proposal-proof.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/creation/create-transaction-proposal-proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,8BAA8B,GACvC,YAAY,MAAM,EAClB,WAAW,SAAS,EACpB,eAAe,UAAU,EACzB,YAAY,MAAM,EAClB,kBAAiB,uBAA4D,KAC9E,qBAkCF,CAAC"}
+{"version":3,"file":"create-transaction-proposal-proof.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/creation/create-transaction-proposal-proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,UAAU,EACV,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,8BAA8B,GACvC,YAAY,MAAM,EAClB,WAAW,SAAS,EACpB,eAAe,UAAU,EACzB,YAAY,MAAM,KACnB,qBAkCF,CAAC"}

package/dist/share-data/proofs/creation/create-transaction-proposal-proof.js

@@ -23,17 +23,16 @@ const hash_proposed_state_1 = require("../helpers/hash-proposed-state");
  * state it is handed at apply time, so it never needs to be stored in the
  * proof — keeping the wire / persistence / history shape unchanged.
  *
- * @param privateKey hex private key authorized for this share-data
+ * @param privateKey 32-byte Ed25519 secret seed (hex) authorized for this share-data
  * @param shareData the share-data the transaction will mutate
  * @param proposedState the exact state the function proposes to apply
  * @param functionId stable id of the function producing `proposedState`
- * @param ellipticalCurve the signing curve (defaults to Curve25519)
  */
-const createTransactionProposalProof = (privateKey, shareData, proposedState, functionId, ellipticalCurve = generic_1.EllipticalCurvesSigning.Curve25519) => {
+const createTransactionProposalProof = (privateKey, shareData, proposedState, functionId) => {
     if (typeof functionId !== 'string' || functionId.length < 1) {
         throw new Error('createTransactionProposalProof: functionId is required and must be a non-empty string');
     }
-    const keyPair = (0, generic_1.createKeyPairFromPrivateKey)(ellipticalCurve, privateKey);
+    const publicKey = (0, generic_1.getEd25519PublicKeyFromPrivateKey)(privateKey);
     // Current-state hash uses functionId as the purpose, mirroring how the
     // verifier recomputes it from `proof.purpose`.
     const currentString = (0, calculate_share_data_string_1.calculateShareDataString)(shareData, undefined, { purpose: functionId });
@@ -42,11 +41,11 @@ const createTransactionProposalProof = (privateKey, shareData, proposedState, fu
     const previousHash = (0, get_previous_hash_from_share_data_1.getPreviousHashFromShareData)(shareData);
     const timestamp = Date.now();
     const signedString = (0, create_transaction_proposal_string_to_sign_1.createTransactionProposalStringToSign)(currentHash, proposedStateHash, functionId, previousHash, timestamp);
-    const signature = (0, generic_1.createEllipticalCurveSignature)(keyPair, signedString);
+    const signature = (0, generic_1.createEd25519Signature)(privateKey, signedString);
     // Field order mirrors IShareDataCryptoProofSchema exactly — load-bearing,
     // see the schema docs in share-data-crypto-models.ts.
     const proof = {
-        publicKey: keyPair.getPublic('hex'),
+        publicKey,
         shareDataHash: currentHash,
         shareDataPreviousHash: previousHash,
         shareDataSignature: signature,

package/dist/share-data/proofs/testing/test-proof-signer.d.ts

@@ -1,15 +1,15 @@
-import { EllipticalCurvesSigning, IShareData, IShareDataCryptoProof } from '@degenerate/generic';
+import { IShareData, IShareDataCryptoProof } from '@degenerate/generic';
 import { ShareData } from '../../share-data';
 /**
- * Generate a fresh elliptic keypair suitable for signing ShareData proofs
- * in tests. Returns the hex-encoded private and public keys so the caller
- * can use the public half as the ShareData's `creationPublicKey` and the
+ * Generate a fresh Ed25519 (EdDSA) keypair suitable for signing ShareData
+ * proofs in tests. Returns the hex-encoded private seed and public key so the
+ * caller can use the public half as the ShareData's `creationPublicKey` and the
  * private half to mint real signed proofs.
  *
  * Test-only helper — not exported from the package barrel. Real signing
  * keys must come from a key manager in production.
  */
-export declare const generateTestSigningKey: (curve?: EllipticalCurvesSigning) => {
+export declare const generateTestSigningKey: () => {
     privateKey: string;
     publicKey: string;
 };
@@ -24,7 +24,7 @@ export declare const generateTestSigningKey: (curve?: EllipticalCurvesSigning) =
  * `buildEllipticalCurvesProofFor` from `@degenerate/shareblock` which
  * handles the same plumbing through a documented public API.
  */
-export declare const createTestProofFor: (privateKey: string, curve?: EllipticalCurvesSigning) => (purpose: string, shareData: ShareData) => IShareDataCryptoProof;
+export declare const createTestProofFor: (privateKey: string) => (purpose: string, shareData: ShareData) => IShareDataCryptoProof;
 /**
  * Build a `(proposedState, functionId, shareData) => IShareDataCryptoProof`
  * callback that mints a *transaction* proposal proof (binds the proposed
@@ -36,7 +36,7 @@ export declare const createTestProofFor: (privateKey: string, curve?: Elliptical
  *
  * Test-only helper. Production flows mint these from a key manager.
  */
-export declare const createTestTransactionProofFor: (privateKey: string, curve?: EllipticalCurvesSigning) => (proposedState: IShareData, functionId: string, shareData: ShareData) => IShareDataCryptoProof;
+export declare const createTestTransactionProofFor: (privateKey: string) => (proposedState: IShareData, functionId: string, shareData: ShareData) => IShareDataCryptoProof;
 /**
  * Convenience wrapper: generate a fresh signing keypair AND return a
  * matching proof signer in one call. Returns both so the test can use the
@@ -44,7 +44,7 @@ export declare const createTestTransactionProofFor: (privateKey: string, curve?:
  * structural proofs (addFunction/addRule); `transactionProofFor` mints
  * runtime transaction proposal proofs.
  */
-export declare const generateTestSigner: (curve?: EllipticalCurvesSigning) => {
+export declare const generateTestSigner: () => {
     privateKey: string;
     publicKey: string;
     proofFor: ReturnType<typeof createTestProofFor>;

package/dist/share-data/proofs/testing/test-proof-signer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-proof-signer.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/testing/test-proof-signer.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,GAC/B,QAAO,uBAA4D,KACpE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAOzC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAC3B,YAAY,MAAM,EAClB,QAAO,uBAA4D,MAE3D,SAAS,MAAM,EAAE,WAAW,SAAS,KAAG,qBAYnD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,GACtC,YAAY,MAAM,EAClB,QAAO,uBAA4D,MAG/D,eAAe,UAAU,EACzB,YAAY,MAAM,EAClB,WAAW,SAAS,KACrB,qBAEN,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC3B,QAAO,uBAA4D,KACpE;IACC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAChD,mBAAmB,EAAE,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC;CASzE,CAAC"}
+{"version":3,"file":"test-proof-signer.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/testing/test-proof-signer.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,UAAU,EACV,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,QAAO;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAMhF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,MACzC,SAAS,MAAM,EAAE,WAAW,SAAS,KAAG,qBAOnD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,GAAI,YAAY,MAAM,MAExD,eAAe,UAAU,EACzB,YAAY,MAAM,EAClB,WAAW,SAAS,KACrB,qBAEN,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAO;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAChD,mBAAmB,EAAE,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC;CASzE,CAAC"}

package/dist/share-data/proofs/testing/test-proof-signer.js

@@ -34,27 +34,25 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTestSigner = exports.createTestTransactionProofFor = exports.createTestProofFor = exports.generateTestSigningKey = void 0;
-/* eslint-disable new-cap */
-const elliptic = __importStar(require("elliptic"));
+const crypto = __importStar(require("crypto"));
 const generic_1 = require("@degenerate/generic");
 const create_share_data_initial_crypto_1 = require("../../creation/create-share-data-initial-crypto");
 const create_share_data_proposal_proof_1 = require("../creation/create-share-data-proposal-proof");
 const create_transaction_proposal_proof_1 = require("../creation/create-transaction-proposal-proof");
 /**
- * Generate a fresh elliptic keypair suitable for signing ShareData proofs
- * in tests. Returns the hex-encoded private and public keys so the caller
- * can use the public half as the ShareData's `creationPublicKey` and the
+ * Generate a fresh Ed25519 (EdDSA) keypair suitable for signing ShareData
+ * proofs in tests. Returns the hex-encoded private seed and public key so the
+ * caller can use the public half as the ShareData's `creationPublicKey` and the
  * private half to mint real signed proofs.
  *
  * Test-only helper — not exported from the package barrel. Real signing
  * keys must come from a key manager in production.
  */
-const generateTestSigningKey = (curve = generic_1.EllipticalCurvesSigning.Curve25519) => {
-    const ec = new elliptic.ec(curve);
-    const keyPair = ec.genKeyPair();
+const generateTestSigningKey = () => {
+    const privateKey = crypto.randomBytes(32).toString('hex');
     return {
-        privateKey: keyPair.getPrivate('hex'),
-        publicKey: keyPair.getPublic('hex'),
+        privateKey,
+        publicKey: (0, generic_1.getEd25519PublicKeyFromPrivateKey)(privateKey),
     };
 };
 exports.generateTestSigningKey = generateTestSigningKey;
@@ -69,13 +67,13 @@ exports.generateTestSigningKey = generateTestSigningKey;
  * `buildEllipticalCurvesProofFor` from `@degenerate/shareblock` which
  * handles the same plumbing through a documented public API.
  */
-const createTestProofFor = (privateKey, curve = generic_1.EllipticalCurvesSigning.Curve25519) => {
+const createTestProofFor = (privateKey) => {
     return (purpose, shareData) => {
         if (!shareData.creationHash && shareData.structuralProofs.length === 0) {
-            const initialCrypto = (0, create_share_data_initial_crypto_1.createShareDataInitialCrypto)(privateKey, shareData, curve);
+            const initialCrypto = (0, create_share_data_initial_crypto_1.createShareDataInitialCrypto)(privateKey, shareData);
             shareData.initializeCrypto(initialCrypto);
         }
-        return (0, create_share_data_proposal_proof_1.createShareDataProposalProof)(privateKey, shareData, { purpose }, curve);
+        return (0, create_share_data_proposal_proof_1.createShareDataProposalProof)(privateKey, shareData, { purpose });
     };
 };
 exports.createTestProofFor = createTestProofFor;
@@ -90,8 +88,8 @@ exports.createTestProofFor = createTestProofFor;
  *
  * Test-only helper. Production flows mint these from a key manager.
  */
-const createTestTransactionProofFor = (privateKey, curve = generic_1.EllipticalCurvesSigning.Curve25519) => {
-    return (proposedState, functionId, shareData) => (0, create_transaction_proposal_proof_1.createTransactionProposalProof)(privateKey, shareData, proposedState, functionId, curve);
+const createTestTransactionProofFor = (privateKey) => {
+    return (proposedState, functionId, shareData) => (0, create_transaction_proposal_proof_1.createTransactionProposalProof)(privateKey, shareData, proposedState, functionId);
 };
 exports.createTestTransactionProofFor = createTestTransactionProofFor;
 /**
@@ -101,13 +99,13 @@ exports.createTestTransactionProofFor = createTestTransactionProofFor;
  * structural proofs (addFunction/addRule); `transactionProofFor` mints
  * runtime transaction proposal proofs.
  */
-const generateTestSigner = (curve = generic_1.EllipticalCurvesSigning.Curve25519) => {
-    const { privateKey, publicKey } = (0, exports.generateTestSigningKey)(curve);
+const generateTestSigner = () => {
+    const { privateKey, publicKey } = (0, exports.generateTestSigningKey)();
     return {
         privateKey,
         publicKey,
-        proofFor: (0, exports.createTestProofFor)(privateKey, curve),
-        transactionProofFor: (0, exports.createTestTransactionProofFor)(privateKey, curve),
+        proofFor: (0, exports.createTestProofFor)(privateKey),
+        transactionProofFor: (0, exports.createTestTransactionProofFor)(privateKey),
     };
 };
 exports.generateTestSigner = generateTestSigner;

package/dist/share-data/proofs/verification/verify-share-data-proposal-proof.d.ts

@@ -1,4 +1,4 @@
-import { EllipticalCurvesSigning, IShareDataCryptoProof } from '@degenerate/generic';
+import { IShareDataCryptoProof } from '@degenerate/generic';
 import { ShareData } from '../../share-data';
 /**
  * Verifies that an `IShareDataCryptoProof` is a faithful attestation of the
@@ -12,10 +12,8 @@ import { ShareData } from '../../share-data';
  * requires the private key).
  *
  * Synchronous on purpose — `addFunction` / `addRule` are synchronous and we
- * don't want to cascade-async every caller in the codebase.
- * `elliptic.ec().keyFromPublic().verify()` is itself synchronous; the
- * project's existing `verifyCryptoSignatureByHash` wrapper is `async` only
- * cosmetically.
+ * don't want to cascade-async every caller in the codebase. `@noble/ed25519`'s
+ * `verify` is itself synchronous (backed by a synchronous SHA-512 hook).
  *
  * Verification proceeds in this order:
  *   1. Recompute the canonical share-data string + hash, folding in
@@ -36,5 +34,5 @@ import { ShareData } from '../../share-data';
  * `(hash, previousHash, timestamp)` triple, not that the hash matches
  * anything real.
  */
-export declare const verifyShareDataProposalProof: (proof: IShareDataCryptoProof, shareData: ShareData, ellipticalCurve?: EllipticalCurvesSigning) => true;
+export declare const verifyShareDataProposalProof: (proof: IShareDataCryptoProof, shareData: ShareData) => true;
 //# sourceMappingURL=verify-share-data-proposal-proof.d.ts.map

package/dist/share-data/proofs/verification/verify-share-data-proposal-proof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify-share-data-proposal-proof.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/verification/verify-share-data-proposal-proof.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,uBAAuB,EACvB,qBAAqB,EAExB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,4BAA4B,GACrC,OAAO,qBAAqB,EAC5B,WAAW,SAAS,EACpB,kBAAiB,uBAA4D,KAC9E,IAoDF,CAAC"}
+{"version":3,"file":"verify-share-data-proposal-proof.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/verification/verify-share-data-proposal-proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,qBAAqB,EAGxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,4BAA4B,GACrC,OAAO,qBAAqB,EAC5B,WAAW,SAAS,KACrB,IAwCF,CAAC"}

package/dist/share-data/proofs/verification/verify-share-data-proposal-proof.js

@@ -1,40 +1,6 @@
 "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.verifyShareDataProposalProof = void 0;
-const elliptic = __importStar(require("elliptic"));
 const generic_1 = require("@degenerate/generic");
 const calculate_share_data_string_1 = require("../../helpers/calculate-share-data-string");
 const get_previous_hash_from_share_data_1 = require("../helpers/get-previous-hash-from-share-data");
@@ -51,10 +17,8 @@ const create_share_data_string_to_sign_1 = require("../helpers/create-share-data
  * requires the private key).
  *
  * Synchronous on purpose — `addFunction` / `addRule` are synchronous and we
- * don't want to cascade-async every caller in the codebase.
- * `elliptic.ec().keyFromPublic().verify()` is itself synchronous; the
- * project's existing `verifyCryptoSignatureByHash` wrapper is `async` only
- * cosmetically.
+ * don't want to cascade-async every caller in the codebase. `@noble/ed25519`'s
+ * `verify` is itself synchronous (backed by a synchronous SHA-512 hook).
  *
  * Verification proceeds in this order:
  *   1. Recompute the canonical share-data string + hash, folding in
@@ -75,7 +39,7 @@ const create_share_data_string_to_sign_1 = require("../helpers/create-share-data
  * `(hash, previousHash, timestamp)` triple, not that the hash matches
  * anything real.
  */
-const verifyShareDataProposalProof = (proof, shareData, ellipticalCurve = generic_1.EllipticalCurvesSigning.Curve25519) => {
+const verifyShareDataProposalProof = (proof, shareData) => {
     // Step 1: hash of current state matches what the proof claims. The
     // purpose comes from the proof itself, so a tampered purpose produces
     // a different hash and gets caught here.
@@ -101,24 +65,11 @@ const verifyShareDataProposalProof = (proof, shareData, ellipticalCurve = generi
     // Step 3: signature verifies against the proof's publicKey for the
     // (now-validated) hash + previousHash + timestamp triple.
     const signedString = (0, create_share_data_string_to_sign_1.createShareDataStringToSign)(proof.shareDataHash, proof.shareDataPreviousHash, proof.timestamp);
-    let signatureValid;
-    try {
-        // eslint-disable-next-line new-cap
-        const key = new elliptic.ec(ellipticalCurve).keyFromPublic(proof.publicKey, 'hex');
-        // Mirror the hash-before-sign step in `createEllipticalCurveSignature`
-        // so the verifier sees the same fixed-size 256-bit digest the signer
-        // operated on. Without this, elliptic's ECDSA on ed25519 silently
-        // truncates inputs longer than ~253 bits and the signature stops
-        // binding the trailing bytes (timestamp, tail of previousHash).
-        const digest = (0, generic_1.calculateHash)(signedString);
-        signatureValid = key.verify(digest, proof.shareDataSignature);
-    }
-    catch {
-        // elliptic throws on malformed signature/key strings rather than
-        // returning false — normalize to a single rejection mode.
-        throw new generic_1.ShareDataStructuralProofFailedError(shareData.id);
-    }
-    if (!signatureValid) {
+    // EdDSA signs the message bytes directly (Ed25519 hashes internally with
+    // SHA-512), so no SHA-256 pre-hash here — the signer didn't pre-hash either.
+    // `verifyEd25519Signature` already normalizes malformed key/signature hex
+    // to a `false` return rather than throwing.
+    if (!(0, generic_1.verifyEd25519Signature)(proof.publicKey, signedString, proof.shareDataSignature)) {
         throw new generic_1.ShareDataStructuralProofFailedError(shareData.id);
     }
     return true;

package/dist/share-data/proofs/verification/verify-transaction-proposal-proof.d.ts

@@ -1,4 +1,4 @@
-import { EllipticalCurvesSigning, IShareData, IShareDataCryptoProof } from '@degenerate/generic';
+import { IShareData, IShareDataCryptoProof } from '@degenerate/generic';
 import { ShareData } from '../../share-data';
 /**
  * Verify a transaction proposal proof against the live `shareData` and the
@@ -30,8 +30,8 @@ import { ShareData } from '../../share-data';
  * hash, a structural proof's signature can never satisfy this check — the two
  * proof kinds are non-interchangeable.
  *
- * Synchronous to match the rest of the proof pipeline; elliptic's `verify`
- * is itself synchronous.
+ * Synchronous to match the rest of the proof pipeline; `@noble/ed25519`'s
+ * `verify` is itself synchronous.
  */
-export declare const verifyTransactionProposalProof: (proof: IShareDataCryptoProof, shareData: ShareData, proposedState: IShareData, ellipticalCurve?: EllipticalCurvesSigning) => true;
+export declare const verifyTransactionProposalProof: (proof: IShareDataCryptoProof, shareData: ShareData, proposedState: IShareData) => true;
 //# sourceMappingURL=verify-transaction-proposal-proof.d.ts.map

package/dist/share-data/proofs/verification/verify-transaction-proposal-proof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify-transaction-proposal-proof.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/verification/verify-transaction-proposal-proof.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EAExB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,8BAA8B,GACvC,OAAO,qBAAqB,EAC5B,WAAW,SAAS,EACpB,eAAe,UAAU,EACzB,kBAAiB,uBAA4D,KAC9E,IAwDF,CAAC"}
+{"version":3,"file":"verify-transaction-proposal-proof.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/verification/verify-transaction-proposal-proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,UAAU,EACV,qBAAqB,EAGxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAK7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,8BAA8B,GACvC,OAAO,qBAAqB,EAC5B,WAAW,SAAS,EACpB,eAAe,UAAU,KAC1B,IA6CF,CAAC"}

package/dist/share-data/proofs/verification/verify-transaction-proposal-proof.js

@@ -1,40 +1,6 @@
 "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.verifyTransactionProposalProof = void 0;
-const elliptic = __importStar(require("elliptic"));
 const generic_1 = require("@degenerate/generic");
 const calculate_share_data_string_1 = require("../../helpers/calculate-share-data-string");
 const get_previous_hash_from_share_data_1 = require("../helpers/get-previous-hash-from-share-data");
@@ -70,10 +36,10 @@ const hash_proposed_state_1 = require("../helpers/hash-proposed-state");
  * hash, a structural proof's signature can never satisfy this check — the two
  * proof kinds are non-interchangeable.
  *
- * Synchronous to match the rest of the proof pipeline; elliptic's `verify`
- * is itself synchronous.
+ * Synchronous to match the rest of the proof pipeline; `@noble/ed25519`'s
+ * `verify` is itself synchronous.
  */
-const verifyTransactionProposalProof = (proof, shareData, proposedState, ellipticalCurve = generic_1.EllipticalCurvesSigning.Curve25519) => {
+const verifyTransactionProposalProof = (proof, shareData, proposedState) => {
     // Step 1: current-state hash matches what the proof claims. The purpose
     // (functionId) comes from the proof itself, so a tampered purpose
     // produces a different hash and is caught here.
@@ -101,23 +67,11 @@ const verifyTransactionProposalProof = (proof, shareData, proposedState, ellipti
     // Step 4: signature verifies over the full transaction payload (which
     // includes the proposed-state hash and the `tx:` discriminator).
     const signedString = (0, create_transaction_proposal_string_to_sign_1.createTransactionProposalStringToSign)(proof.shareDataHash, proposedStateHash, proof.purpose, proof.shareDataPreviousHash, proof.timestamp);
-    let signatureValid;
-    try {
-        // eslint-disable-next-line new-cap
-        const key = new elliptic.ec(ellipticalCurve).keyFromPublic(proof.publicKey, 'hex');
-        // Mirror the hash-before-sign step in `createEllipticalCurveSignature`
-        // so the verifier operates on the same fixed-size digest the signer
-        // did. Without this, elliptic's ECDSA on ed25519 silently truncates
-        // long inputs and stops binding the trailing bytes.
-        const digest = (0, generic_1.calculateHash)(signedString);
-        signatureValid = key.verify(digest, proof.shareDataSignature);
-    }
-    catch {
-        // elliptic throws on malformed signature/key strings rather than
-        // returning false — normalize to a single rejection mode.
-        throw new generic_1.ShareDataTransactionProofFailedError(shareData.id);
-    }
-    if (!signatureValid) {
+    // EdDSA signs the message bytes directly (Ed25519 hashes internally with
+    // SHA-512), so no SHA-256 pre-hash here — the signer didn't pre-hash either.
+    // `verifyEd25519Signature` already normalizes malformed key/signature hex
+    // to a `false` return rather than throwing.
+    if (!(0, generic_1.verifyEd25519Signature)(proof.publicKey, signedString, proof.shareDataSignature)) {
         throw new generic_1.ShareDataTransactionProofFailedError(shareData.id);
     }
     return true;

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

@@ -1,4 +1,4 @@
-import { IShareData, IShareDataEvent, IShareFunction, IShareRuleApplied, IShareRuleEvalutionResult, IShareDataTransactionHistory, IShareDataCryptoProof, EllipticalCurvesSigning, IShareDataInitialCryptoData, IAuthorizedSigner } from '@degenerate/generic';
+import { IShareData, IShareDataEvent, IShareFunction, IShareRuleApplied, IShareRuleEvalutionResult, IShareDataTransactionHistory, IShareDataCryptoProof, EllipticalCurvesSigning, IShareDataInitialCryptoData, IAuthorizedSigner, ILibraryRuleReferenceBinding, LibraryStore } from '@degenerate/generic';
 /**
  * This contains the interface for the share data object
  */
@@ -19,6 +19,9 @@ export declare class ShareData {
     private _lastUpdated;
     private _structuralProofs;
     private _authorizedSigners;
+    private _ruleReferences;
+    private _libraryStore?;
+    private _hydratedReferenceRules?;
     /**
      * This is the constructor for the share data object
      * @param id the id of the share data
@@ -99,6 +102,12 @@ export declare class ShareData {
      * NOT listed here.
      */
     get authorizedSigners(): IAuthorizedSigner[];
+    /**
+     * The library rule references governing this block. Each binding pairs a
+     * library reference (id + pinned `currentHash`) with the root property it
+     * governs. Frozen after `initialize()` like rules/functions.
+     */
+    get ruleReferences(): ILibraryRuleReferenceBinding[];
     /**
      * This gets the transaction history for the share block
      */
@@ -122,6 +131,31 @@ export declare class ShareData {
      * @param rule the rule to add to the share block
      */
     addRule(rule: IShareRuleApplied, cryptoProof: IShareDataCryptoProof): void;
+    /**
+     * Registers a library rule reference governing this block. The reference
+     * (id + pinned `currentHash`) plus the governed `targettedProperty` are
+     * folded into the signed structure, so a tampered snapshot cannot add or
+     * retarget a rule reference without breaking the hash chain. Creation-time
+     * only (rejected once locked); verified against the pre-append state,
+     * mirroring `addRule` / `addFunction`.
+     */
+    addRuleReference(binding: ILibraryRuleReferenceBinding, cryptoProof: IShareDataCryptoProof): void;
+    /**
+     * Injects the library store used to resolve this block's rule references at
+     * change time. This is runtime infrastructure — it is NOT folded into the
+     * canonical hash or the signed structure, so setting it does not affect any
+     * proof. Replacing the store clears the resolved-rule cache.
+     */
+    setLibraryStore(store: LibraryStore): void;
+    /**
+     * Resolves `_ruleReferences` into executable applied rules via the library
+     * store, materializing the lean "reference" block into the rules needed to
+     * evaluate a change. The result is cached (references are pinned to
+     * content-addressed versions, so the resolution is stable). Fail-closed: if
+     * references exist but no store was injected, evaluation refuses to proceed
+     * rather than silently dropping the governing rules.
+     */
+    private resolveReferenceRules;
     /**
      * Delegates `signerPublicKey` the right to propose runtime transactions for
      * the given `functionIds` (and ONLY those — least privilege). Creation-time
@@ -193,10 +227,10 @@ export declare class ShareData {
      * @param proposedData the proposed data
      * @param transactionFunction the function that was attempted
      */
-    addTransactionNotValidated(proposedData: IShareData, transactionFunction: IShareFunction<any, (...args: any[]) => any, any>): {
+    addTransactionNotValidated(proposedData: IShareData, transactionFunction: IShareFunction<any, (...args: any[]) => any, any>): Promise<{
         accepted: boolean;
         transactionId: string;
-    };
+    }>;
     /**
      * Signed runtime mutation path. Verifies that `proof` cryptographically
      * authorizes applying `transactionFunction` to move this share-data to
@@ -230,10 +264,10 @@ export declare class ShareData {
      * @param transactionFunction the function producing `proposedData`
      * @param proof the transaction proposal proof authorizing the change
      */
-    addTransaction(proposedData: IShareData, transactionFunction: IShareFunction<any, (...args: any[]) => any, any>, proof: IShareDataCryptoProof): {
+    addTransaction(proposedData: IShareData, transactionFunction: IShareFunction<any, (...args: any[]) => any, any>, proof: IShareDataCryptoProof): Promise<{
         accepted: boolean;
         transactionId: string;
-    };
+    }>;
     /**
      * Shared rule-evaluate → apply-if-valid → record path used by both
      * {@link addTransactionNotValidated} (no proof) and {@link addTransaction}
@@ -258,7 +292,7 @@ export declare class ShareData {
      * success; throws `ShareDataStructuralProofFailedError` on any mismatch
      * (hash, previousHash, signature, or purpose).
      */
-    verifyStructuralProof(proof: IShareDataCryptoProof, curve?: EllipticalCurvesSigning): true;
+    verifyStructuralProof(proof: IShareDataCryptoProof): true;
     /**
      * Verifies that `proof` authorizes applying a transaction that moves this
      * share-data to exactly `proposedData`. Unlike {@link verifyStructuralProof}
@@ -267,7 +301,7 @@ export declare class ShareData {
      * verify against any other. Returns `true`; throws
      * `ShareDataTransactionProofFailedError` on any mismatch.
      */
-    verifyTransactionProof(proof: IShareDataCryptoProof, proposedData: IShareData, curve?: EllipticalCurvesSigning): true;
+    verifyTransactionProof(proof: IShareDataCryptoProof, proposedData: IShareData): true;
     /**
      * This adds a structure proof to the share data
      * @param proof the structure proof to add

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

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