@degenerate/sharedata 0.3.1 → 0.6.0

package/dist/persistence/block-factory-registry.d.ts

@@ -1,4 +1,4 @@
-import { IShareDataInitialCryptoData, PersistedCreationConfig, ShareBlockType, ShareDataProofs } from '@degenerate/generic';
+import { IAuthorizedSigner, IShareDataInitialCryptoData, PersistedCreationConfig, ShareBlockType, ShareDataProofs } from '@degenerate/generic';
 import { ShareData } from '../share-data/share-data';
 /**
  * The inputs a block builder needs to replay construction of a persisted
@@ -10,12 +10,18 @@ import { ShareData } from '../share-data/share-data';
  *   - `initialCrypto` — the client-computed creation crypto, applied to the
  *     in-construction block on the first proof lookup.
  *   - `structuralProofs` — the per-purpose proof bundle, replayed in place of
- *     a live signer so the rebuilt block carries byte-identical proofs.
+ *     a live signer so the rebuilt block carries byte-identical proofs. This
+ *     bundle also contains the delegate registration proofs (keyed by their
+ *     `delegate:<key>:<ids>` purpose).
+ *   - `authorizedSigners` — the delegated-signer grant tuples to re-apply via
+ *     `addAuthorizedSigner`, so the rebuilt block re-derives the same signer
+ *     set (and canonical hash) it had live. Empty for non-delegating blocks.
  */
 export interface ShareBlockBuilderInput {
     creationConfig: PersistedCreationConfig;
     initialCrypto: IShareDataInitialCryptoData;
     structuralProofs: ShareDataProofs;
+    authorizedSigners: IAuthorizedSigner[];
 }
 /**
  * Rebuilds a ShareData of a single block type from its persisted recipe.

package/dist/persistence/block-factory-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block-factory-registry.d.ts","sourceRoot":"","sources":["../../src/persistence/block-factory-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,2BAA2B,EAC3B,uBAAuB,EACvB,cAAc,EACd,eAAe,EAClB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAgBrD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,sBAAsB;IACnC,cAAc,EAAE,uBAAuB,CAAC;IACxC,aAAa,EAAE,2BAA2B,CAAC;IAC3C,gBAAgB,EAAE,eAAe,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,sBAAsB,KAAK,SAAS,CAAC;AAQ7E;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GAClC,WAAW,cAAc,EACzB,SAAS,iBAAiB,KAC3B,IAEF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC7B,WAAW,cAAc,KAC1B,iBAAiB,GAAG,SAAoC,CAAC;AAE5D,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,GAAI,WAAW,cAAc,KAAG,OACtC,CAAC;AAE5B;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,QAAO,IAE1C,CAAC"}
+{"version":3,"file":"block-factory-registry.d.ts","sourceRoot":"","sources":["../../src/persistence/block-factory-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,iBAAiB,EACjB,2BAA2B,EAC3B,uBAAuB,EACvB,cAAc,EACd,eAAe,EAClB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAgBrD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,sBAAsB;IACnC,cAAc,EAAE,uBAAuB,CAAC;IACxC,aAAa,EAAE,2BAA2B,CAAC;IAC3C,gBAAgB,EAAE,eAAe,CAAC;IAClC,iBAAiB,EAAE,iBAAiB,EAAE,CAAC;CAC1C;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,sBAAsB,KAAK,SAAS,CAAC;AAQ7E;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GAClC,WAAW,cAAc,EACzB,SAAS,iBAAiB,KAC3B,IAEF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAC7B,WAAW,cAAc,KAC1B,iBAAiB,GAAG,SAAoC,CAAC;AAE5D,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,GAAI,WAAW,cAAc,KAAG,OACtC,CAAC;AAE5B;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,QAAO,IAE1C,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"deserialize-share-data.d.ts","sourceRoot":"","sources":["../../src/persistence/deserialize-share-data.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAYrD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,OAAO,KAAG,SAgHxD,CAAC"}
+{"version":3,"file":"deserialize-share-data.d.ts","sourceRoot":"","sources":["../../src/persistence/deserialize-share-data.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAYrD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,OAAO,KAAG,SAoHxD,CAAC"}

package/dist/persistence/deserialize-share-data.js

@@ -55,6 +55,7 @@ const deserializeShareData = (snapshot) => {
         creationConfig: parsed.creationConfig,
         initialCrypto: parsed.initialCrypto,
         structuralProofs: parsed.structuralProofs,
+        authorizedSigners: parsed.authorizedSigners,
     });
     // Replay the transaction log in recorded order.
     for (const entry of parsed.transactionLog) {
@@ -68,8 +69,12 @@ const deserializeShareData = (snapshot) => {
         // verification, so the proposer-identity gate (the same one
         // addTransaction enforces live) must run on replay too. Checked first
         // so a swapped key fails as a not-authorized error rather than a
-        // signature mismatch.
-        if (entry.proof.publicKey !== block.creationPublicKey) {
+        // signature mismatch. Uses the same widened predicate as the live gate:
+        // the creation key for any function, or a delegate for its granted
+        // function (`entry.proof.purpose` is the function id). The signer set was
+        // re-derived from re-verified registration proofs during construction
+        // above, so an injected grant with no valid proof never reaches here.
+        if (!block.isAuthorizedSigner(entry.proof.publicKey, entry.proof.purpose)) {
             throw new generic_1.ShareDataTransactionNotAuthorizedError(parsed.id, entry.proof.publicKey);
         }
         // Re-verify the transaction proof against the block at its pre-entry
@@ -79,7 +84,7 @@ const deserializeShareData = (snapshot) => {
         // throws ShareDataTransactionProofFailedError here rather than being
         // loaded. Verifying before the apply keeps the recomputed current hash
         // aligned with what the signer signed over.
-        (0, verify_transaction_proposal_proof_1.verifyTransactionProposalProof)(entry.proof, block, entry.proposedState, block.signingCurve);
+        (0, verify_transaction_proposal_proof_1.verifyTransactionProposalProof)(entry.proof, block, entry.proposedState);
         // addTransactionAlreadyValidated derives its accept/reject outcome
         // from (proposedResult && currentResult). Setting both to the stored
         // boolean replays the original outcome exactly: currentState is

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

@@ -1 +1 @@
-{"version":3,"file":"serialize-share-data.d.ts","sourceRoot":"","sources":["../../src/persistence/serialize-share-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EAEjB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAUrD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,GAC3B,WAAW,cAAc,EACzB,gBAAgB,uBAAuB,EACvC,OAAO,SAAS,EAChB,gBAAgB,oBAAoB,EAAE,KACvC,kBAgCF,CAAC"}
+{"version":3,"file":"serialize-share-data.d.ts","sourceRoot":"","sources":["../../src/persistence/serialize-share-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,uBAAuB,EACvB,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EAEjB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAUrD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,GAC3B,WAAW,cAAc,EACzB,gBAAgB,uBAAuB,EACvC,OAAO,SAAS,EAChB,gBAAgB,oBAAoB,EAAE,KACvC,kBAoCF,CAAC"}

package/dist/persistence/serialize-share-data.js

@@ -51,6 +51,10 @@ const serializeShareData = (blockType, creationConfig, block, transactionLog) =>
         },
         creationConfig,
         structuralProofs,
+        // The grant tuples re-applied via `addAuthorizedSigner` on replay; the
+        // matching registration proofs are already carried in `structuralProofs`
+        // (keyed by their `delegate:` purpose). Empty for non-delegating blocks.
+        authorizedSigners: block.authorizedSigners,
         transactionLog,
         expectedCurrentState: block.currentState,
         expectedCreationHash: block.creationHash,

package/dist/share-data/creation/create-share-data-initial-crypto.d.ts

@@ -1,11 +1,10 @@
-import { EllipticalCurvesSigning, IShareDataInitialCryptoData } from '@degenerate/generic';
+import { IShareDataInitialCryptoData } from '@degenerate/generic';
 import { ShareData } from '../share-data';
 /**
  * This function creates the initial crypto data for the share data.
  *
- * @param constructedShareData
+ * @param privateKey the 32-byte Ed25519 secret seed (hex) to sign with
+ * @param shareData the share data to create the initial crypto for
  */
-export declare const createShareDataInitialCrypto: (privateKey: string, // the private key in hex format
-shareData: ShareData, // the share data to create the initial crypto for
-signingCurve?: EllipticalCurvesSigning) => IShareDataInitialCryptoData;
+export declare const createShareDataInitialCrypto: (privateKey: string, shareData: ShareData) => IShareDataInitialCryptoData;
 //# sourceMappingURL=create-share-data-initial-crypto.d.ts.map

package/dist/share-data/creation/create-share-data-initial-crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-share-data-initial-crypto.d.ts","sourceRoot":"","sources":["../../../src/share-data/creation/create-share-data-initial-crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,uBAAuB,EACvB,2BAA2B,EAC9B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,GACrC,YAAY,MAAM,EAAE,gCAAgC;AACpD,WAAW,SAAS,EAAE,kDAAkD;AACxE,eAAc,uBAA4D,KAC3E,2BAYF,CAAA"}
+{"version":3,"file":"create-share-data-initial-crypto.d.ts","sourceRoot":"","sources":["../../../src/share-data/creation/create-share-data-initial-crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,2BAA2B,EAC9B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,GACrC,YAAY,MAAM,EAClB,WAAW,SAAS,KACrB,2BAYF,CAAA"}

package/dist/share-data/creation/create-share-data-initial-crypto.js

@@ -6,17 +6,16 @@ const calculate_share_data_string_1 = require("../helpers/calculate-share-data-s
 /**
  * This function creates the initial crypto data for the share data.
  *
- * @param constructedShareData
+ * @param privateKey the 32-byte Ed25519 secret seed (hex) to sign with
+ * @param shareData the share data to create the initial crypto for
  */
-const createShareDataInitialCrypto = (privateKey, // the private key in hex format
-shareData, // the share data to create the initial crypto for
-signingCurve = generic_1.EllipticalCurvesSigning.Curve25519) => {
-    const keyPair = (0, generic_1.createKeyPairFromPrivateKey)(signingCurve, privateKey);
+const createShareDataInitialCrypto = (privateKey, shareData) => {
+    const publicKey = (0, generic_1.getEd25519PublicKeyFromPrivateKey)(privateKey);
     const shareDataString = (0, calculate_share_data_string_1.calculateShareDataString)(shareData);
     const shareDataHash = (0, generic_1.calculateHash)(shareDataString);
-    const shareDataSignature = (0, generic_1.createEllipticalCurveSignature)(keyPair, shareDataHash);
+    const shareDataSignature = (0, generic_1.createEd25519Signature)(privateKey, shareDataHash);
     const initialCryptoData = {
-        publicKey: keyPair.getPublic('hex'),
+        publicKey,
         shareDataHash,
         shareDataSignature,
         timestamp: Date.now(),

package/dist/share-data/helpers/config/default-share-data-string.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"default-share-data-string.config.d.ts","sourceRoot":"","sources":["../../../../src/share-data/helpers/config/default-share-data-string.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAIvD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,gBAe1C,CAAC"}
+{"version":3,"file":"default-share-data-string.config.d.ts","sourceRoot":"","sources":["../../../../src/share-data/helpers/config/default-share-data-string.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAIvD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,gBAoB1C,CAAC"}

package/dist/share-data/helpers/config/default-share-data-string.config.js

@@ -16,6 +16,11 @@ exports.defaultShareDataStringConfig = [
     { key: 'currentState', process: stringify_1.stringify },
     { key: 'cryptoProofs', process: get_array_string_1.getArrayString },
     { key: 'structuralProofs', process: get_array_string_1.getArrayString },
+    // Folds the delegated authorized-signer set into the signed structure so a
+    // tampered snapshot cannot widen authorization without breaking the hash
+    // chain. `getArrayString([])` returns '', so blocks with no delegates hash
+    // identically to before this field existed — existing proofs stay valid.
+    { key: 'authorizedSigners', process: get_array_string_1.getArrayString },
     { key: 'events', process: get_array_string_1.getArrayString },
     { key: 'functions', process: get_array_string_1.getArrayString },
     { key: 'rules', process: get_array_string_1.getArrayString },

package/dist/share-data/proofs/creation/build-transaction-proposal-signer.d.ts

@@ -1,4 +1,4 @@
-import { EllipticalCurvesSigning, IShareData, IShareDataCryptoProof } from '@degenerate/generic';
+import { IShareData, IShareDataCryptoProof } from '@degenerate/generic';
 import { ShareData } from '../../share-data';
 /**
  * Configuration for the production transaction-proposal signer returned by
@@ -6,18 +6,13 @@ import { ShareData } from '../../share-data';
  */
 export interface ITransactionProposalSignerConfig {
     /**
-     * Hex-encoded private key authorized to mutate the target share-data
-     * (must correspond to its `creationPublicKey`). Captured in the returned
-     * closure and never leaves it. In production this should come from a
-     * secure key manager (KMS / HSM / encrypted environment value), not a
+     * Hex-encoded 32-byte Ed25519 secret seed authorized to mutate the target
+     * share-data (must correspond to its `creationPublicKey`). Captured in the
+     * returned closure and never leaves it. In production this should come from
+     * a secure key manager (KMS / HSM / encrypted environment value), not a
      * literal string in code.
      */
     privateKey: string;
-    /**
-     * Elliptical curve to sign with. Defaults to `Curve25519`, matching the
-     * `ShareData` constructor default.
-     */
-    curve?: EllipticalCurvesSigning;
 }
 /**
  * A bound signer that mints a transaction proposal proof authorizing one

package/dist/share-data/proofs/creation/build-transaction-proposal-signer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-transaction-proposal-signer.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/creation/build-transaction-proposal-signer.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG7C;;;GAGG;AACH,MAAM,WAAW,gCAAgC;IAC7C;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACnC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,CACpC,aAAa,EAAE,UAAU,EACzB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,SAAS,KACnB,qBAAqB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,8BAA8B,GACvC,QAAQ,gCAAgC,KACzC,yBAUF,CAAC"}
+{"version":3,"file":"build-transaction-proposal-signer.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/creation/build-transaction-proposal-signer.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,UAAU,EACV,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG7C;;;GAGG;AACH,MAAM,WAAW,gCAAgC;IAC7C;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG,CACpC,aAAa,EAAE,UAAU,EACzB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,SAAS,KACnB,qBAAqB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,8BAA8B,GACvC,QAAQ,gCAAgC,KACzC,yBAQF,CAAC"}

package/dist/share-data/proofs/creation/build-transaction-proposal-signer.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildTransactionProposalSigner = void 0;
-const generic_1 = require("@degenerate/generic");
 const create_transaction_proposal_proof_1 = require("./create-transaction-proposal-proof");
 /**
  * Returns a production-ready {@link TransactionProposalSigner} that signs each
@@ -30,7 +29,6 @@ const create_transaction_proposal_proof_1 = require("./create-transaction-propos
  * replayed for a different amount or a different function.
  */
 const buildTransactionProposalSigner = (config) => {
-    const curve = config.curve ?? generic_1.EllipticalCurvesSigning.Curve25519;
-    return (proposedState, functionId, shareData) => (0, create_transaction_proposal_proof_1.createTransactionProposalProof)(config.privateKey, shareData, proposedState, functionId, curve);
+    return (proposedState, functionId, shareData) => (0, create_transaction_proposal_proof_1.createTransactionProposalProof)(config.privateKey, shareData, proposedState, functionId);
 };
 exports.buildTransactionProposalSigner = buildTransactionProposalSigner;

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

@@ -1,12 +1,11 @@
-import { EllipticalCurvesSigning, IShareDataAdditionalValuesToInclude, IShareDataCryptoProof } from '@degenerate/generic';
+import { IShareDataAdditionalValuesToInclude, IShareDataCryptoProof } from '@degenerate/generic';
 import { ShareData } from '../../share-data';
 /**
  * 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
  */
-export declare const createShareDataProposalProof: (privateKey: string, shareData: ShareData, additionalValuesToInclude: IShareDataAdditionalValuesToInclude, ellipticalCurve?: EllipticalCurvesSigning) => IShareDataCryptoProof;
+export declare const createShareDataProposalProof: (privateKey: string, shareData: ShareData, additionalValuesToInclude: IShareDataAdditionalValuesToInclude) => IShareDataCryptoProof;
 //# sourceMappingURL=create-share-data-proposal-proof.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"create-share-data-proposal-proof.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/creation/create-share-data-proposal-proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,uBAAuB,EACvB,mCAAmC,EACnC,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,GACrC,YAAY,MAAM,EAClB,WAAW,SAAS,EACpB,2BAA2B,mCAAmC,EAC9D,kBAAiB,uBAA4D,KAC9E,qBA0BF,CAAC"}
+{"version":3,"file":"create-share-data-proposal-proof.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/creation/create-share-data-proposal-proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,mCAAmC,EACnC,qBAAqB,EACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAI7C;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GACrC,YAAY,MAAM,EAClB,WAAW,SAAS,EACpB,2BAA2B,mCAAmC,KAC/D,qBA0BF,CAAC"}

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 } from '@degenerate/generic';
+import { IShareData, IShareDataEvent, IShareFunction, IShareRuleApplied, IShareRuleEvalutionResult, IShareDataTransactionHistory, IShareDataCryptoProof, EllipticalCurvesSigning, IShareDataInitialCryptoData, IAuthorizedSigner } from '@degenerate/generic';
 /**
  * This contains the interface for the share data object
  */
@@ -18,6 +18,7 @@ export declare class ShareData {
     private _signingCurve;
     private _lastUpdated;
     private _structuralProofs;
+    private _authorizedSigners;
     /**
      * This is the constructor for the share data object
      * @param id the id of the share data
@@ -90,6 +91,14 @@ export declare class ShareData {
      * This gets the structure proofs for the share data
      */
     get structuralProofs(): IShareDataCryptoProof[];
+    /**
+     * This gets the delegated authorized-signer grants for the share data.
+     * Each grant is a `{ publicKey, functionIds }` pair: a key the owner has
+     * delegated the right to propose transactions for, scoped to those function
+     * ids. The block owner (`creationPublicKey`) is always authorized and is
+     * NOT listed here.
+     */
+    get authorizedSigners(): IAuthorizedSigner[];
     /**
      * This gets the transaction history for the share block
      */
@@ -113,6 +122,49 @@ export declare class ShareData {
      * @param rule the rule to add to the share block
      */
     addRule(rule: IShareRuleApplied, cryptoProof: IShareDataCryptoProof): void;
+    /**
+     * Delegates `signerPublicKey` the right to propose runtime transactions for
+     * the given `functionIds` (and ONLY those — least privilege). Creation-time
+     * only: rejected once the block is locked. The registration is part of the
+     * signed structure, so a delegate cannot be injected into a tampered
+     * snapshot without invalidating the chain.
+     *
+     * Three gates, in order:
+     *   1. Owner-identity: `registrationProof.publicKey === creationPublicKey`.
+     *      ONLY the block owner may delegate — this is the check `addFunction` /
+     *      `addRule` deliberately omit (the HTTP layer supplies it there). It
+     *      must live here because the security of the widened transaction gate
+     *      (see {@link isAuthorizedSigner}) rests on "the allow-list was
+     *      authorized by the owner." It also blocks transitive delegation: a
+     *      delegate's key is never the creation key, so a delegate can never
+     *      register further delegates.
+     *   2. Grant binding: the proof's `purpose` must equal
+     *      `buildDelegatePurpose(signerPublicKey, functionIds)`. The proof signs
+     *      over the PRE-append state (the grant is not yet folded into
+     *      `_authorizedSigners`), so the purpose is the only thing that attests
+     *      to the exact `(key, functionIds)` grant — without this a tampered
+     *      snapshot could widen a delegate's scope without breaking the
+     *      signature.
+     *   3. Structural verification against the current (pre-append) state,
+     *      reusing the same machinery `addFunction` / `addRule` use; folds the
+     *      proof into the hash chain and verifies the owner's signature.
+     *
+     * Throws {@link ShareDataIsLockedError} if locked,
+     * {@link ShareDataDelegationNotAuthorizedError} for a non-owner registrant /
+     * empty grant / mismatched purpose, and
+     * {@link ShareDataStructuralProofFailedError} if the proof does not verify.
+     */
+    addAuthorizedSigner(signerPublicKey: string, functionIds: string[], registrationProof: IShareDataCryptoProof): void;
+    /**
+     * Whether `publicKey` is authorized to propose a transaction for
+     * `functionId` on this block. The block owner (`creationPublicKey`) is
+     * always authorized for every function; a delegated key is authorized only
+     * for the function ids its registration granted. This is the single
+     * predicate behind the proposer-identity gate, called from both the live
+     * mutation path ({@link addTransaction}) and the persistence replay path so
+     * the two cannot drift.
+     */
+    isAuthorizedSigner(publicKey: string, functionId: string): boolean;
     /**
      * Append a pre-validated transaction to the history. Pass `transactionTime`
      * when the caller needs the recorded timestamp to be deterministic — for
@@ -159,12 +211,12 @@ export declare class ShareData {
      *      This binds the proof to *this* function so a proof minted for one
      *      function can't be replayed to drive another even if the proposed
      *      state would satisfy both functions' rules.
-     *   3. The proof's signer must be authorized for this block —
-     *      `proof.publicKey === creationPublicKey`. Signature validity alone
-     *      only proves *someone* signed the transition; this binds the
-     *      *authorized* someone (the block's creation key, the same key the
-     *      HTTP create/delete ACL authorizes against). Without it any valid
-     *      keypair could sign a legal transition.
+     *   3. The proof's signer must be authorized for this block AND this
+     *      function — the creation key for any function, or a delegated key for
+     *      the function ids its registration granted (`isAuthorizedSigner`).
+     *      Signature validity alone only proves *someone* signed the transition;
+     *      this binds the *authorized* someone. Without it any valid keypair
+     *      could sign a legal transition.
      *   4. The proof must verify against the current state AND `proposedData`
      *      (closes the amount-replay hole — see
      *      `verifyTransactionProposalProof`).
@@ -206,7 +258,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}
@@ -215,7 +267,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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"}

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

@@ -30,6 +30,7 @@ class ShareData {
         this._cryptoProofs = [];
         this._signingCurve = signingCurve;
         this._structuralProofs = [];
+        this._authorizedSigners = [];
     }
     /**
      * This initializes the cryptographic properties of the share data
@@ -139,6 +140,16 @@ class ShareData {
     get structuralProofs() {
         return this._structuralProofs;
     }
+    /**
+     * This gets the delegated authorized-signer grants for the share data.
+     * Each grant is a `{ publicKey, functionIds }` pair: a key the owner has
+     * delegated the right to propose transactions for, scoped to those function
+     * ids. The block owner (`creationPublicKey`) is always authorized and is
+     * NOT listed here.
+     */
+    get authorizedSigners() {
+        return this._authorizedSigners;
+    }
     /**
      * This gets the transaction history for the share block
      */
@@ -189,6 +200,78 @@ class ShareData {
         this._structuralProofs.push(cryptoProof);
         this._rules.push(rule);
     }
+    /**
+     * Delegates `signerPublicKey` the right to propose runtime transactions for
+     * the given `functionIds` (and ONLY those — least privilege). Creation-time
+     * only: rejected once the block is locked. The registration is part of the
+     * signed structure, so a delegate cannot be injected into a tampered
+     * snapshot without invalidating the chain.
+     *
+     * Three gates, in order:
+     *   1. Owner-identity: `registrationProof.publicKey === creationPublicKey`.
+     *      ONLY the block owner may delegate — this is the check `addFunction` /
+     *      `addRule` deliberately omit (the HTTP layer supplies it there). It
+     *      must live here because the security of the widened transaction gate
+     *      (see {@link isAuthorizedSigner}) rests on "the allow-list was
+     *      authorized by the owner." It also blocks transitive delegation: a
+     *      delegate's key is never the creation key, so a delegate can never
+     *      register further delegates.
+     *   2. Grant binding: the proof's `purpose` must equal
+     *      `buildDelegatePurpose(signerPublicKey, functionIds)`. The proof signs
+     *      over the PRE-append state (the grant is not yet folded into
+     *      `_authorizedSigners`), so the purpose is the only thing that attests
+     *      to the exact `(key, functionIds)` grant — without this a tampered
+     *      snapshot could widen a delegate's scope without breaking the
+     *      signature.
+     *   3. Structural verification against the current (pre-append) state,
+     *      reusing the same machinery `addFunction` / `addRule` use; folds the
+     *      proof into the hash chain and verifies the owner's signature.
+     *
+     * Throws {@link ShareDataIsLockedError} if locked,
+     * {@link ShareDataDelegationNotAuthorizedError} for a non-owner registrant /
+     * empty grant / mismatched purpose, and
+     * {@link ShareDataStructuralProofFailedError} if the proof does not verify.
+     */
+    addAuthorizedSigner(signerPublicKey, functionIds, registrationProof) {
+        if (this._isLocked) {
+            throw new generic_1.ShareDataIsLockedError(this._id, generic_1.ShareDataTypes.AUTHORIZATION);
+        }
+        // Gate 1: owner-identity. Only the creation key may delegate.
+        if (registrationProof.publicKey !== this._creationPublicKey) {
+            throw new generic_1.ShareDataDelegationNotAuthorizedError(this._id, registrationProof.publicKey);
+        }
+        // Normalize so the purpose, the stored grant, and the canonical hash all
+        // agree byte-for-byte on live-create and on replay.
+        const normalizedFunctionIds = Array.from(new Set(functionIds.map((id) => id.trim()).filter((id) => id.length > 0))).sort();
+        if (normalizedFunctionIds.length === 0) {
+            throw new generic_1.ShareDataDelegationNotAuthorizedError(this._id, registrationProof.publicKey);
+        }
+        // Gate 2: the proof must bind this exact (key, functionIds) grant.
+        const expectedPurpose = (0, generic_1.buildDelegatePurpose)(signerPublicKey, normalizedFunctionIds);
+        if (registrationProof.purpose !== expectedPurpose) {
+            throw new generic_1.ShareDataDelegationNotAuthorizedError(this._id, registrationProof.publicKey);
+        }
+        // Gate 3: structural verification (pre-append, mirroring addFunction).
+        this.verifyStructuralProof(registrationProof);
+        this._structuralProofs.push(registrationProof);
+        this._authorizedSigners.push({ publicKey: signerPublicKey, functionIds: normalizedFunctionIds });
+    }
+    /**
+     * Whether `publicKey` is authorized to propose a transaction for
+     * `functionId` on this block. The block owner (`creationPublicKey`) is
+     * always authorized for every function; a delegated key is authorized only
+     * for the function ids its registration granted. This is the single
+     * predicate behind the proposer-identity gate, called from both the live
+     * mutation path ({@link addTransaction}) and the persistence replay path so
+     * the two cannot drift.
+     */
+    isAuthorizedSigner(publicKey, functionId) {
+        if (publicKey === this._creationPublicKey) {
+            return true;
+        }
+        const grant = this._authorizedSigners.find((s) => s.publicKey === publicKey);
+        return grant !== undefined && grant.functionIds.includes(functionId);
+    }
     /**
      * Append a pre-validated transaction to the history. Pass `transactionTime`
      * when the caller needs the recorded timestamp to be deterministic — for
@@ -254,12 +337,12 @@ class ShareData {
      *      This binds the proof to *this* function so a proof minted for one
      *      function can't be replayed to drive another even if the proposed
      *      state would satisfy both functions' rules.
-     *   3. The proof's signer must be authorized for this block —
-     *      `proof.publicKey === creationPublicKey`. Signature validity alone
-     *      only proves *someone* signed the transition; this binds the
-     *      *authorized* someone (the block's creation key, the same key the
-     *      HTTP create/delete ACL authorizes against). Without it any valid
-     *      keypair could sign a legal transition.
+     *   3. The proof's signer must be authorized for this block AND this
+     *      function — the creation key for any function, or a delegated key for
+     *      the function ids its registration granted (`isAuthorizedSigner`).
+     *      Signature validity alone only proves *someone* signed the transition;
+     *      this binds the *authorized* someone. Without it any valid keypair
+     *      could sign a legal transition.
      *   4. The proof must verify against the current state AND `proposedData`
      *      (closes the amount-replay hole — see
      *      `verifyTransactionProposalProof`).
@@ -289,10 +372,14 @@ class ShareData {
         if (proof.purpose !== functionId) {
             throw new generic_1.ShareDataTransactionProofFailedError(this._id);
         }
-        // Gate 3: bind the proposer identity. Only the block's creation key may
-        // authorize runtime mutations. Checked before the (more expensive)
-        // signature verification so an unauthorized signer fails fast.
-        if (proof.publicKey !== this._creationPublicKey) {
+        // Gate 3: bind the proposer identity. The block's creation key may
+        // authorize any function; a delegated key may authorize only the
+        // function ids it was granted (see addAuthorizedSigner / isAuthorizedSigner).
+        // `functionId` equals `proof.purpose` here (enforced by Gate 2), so the
+        // scope check is against the function the proof is bound to. Checked
+        // before the (more expensive) signature verification so an unauthorized
+        // signer fails fast.
+        if (!this.isAuthorizedSigner(proof.publicKey, functionId)) {
             throw new generic_1.ShareDataTransactionNotAuthorizedError(this._id, proof.publicKey);
         }
         // Gate 4: proof binds current state + proposed state + chain position.
@@ -361,8 +448,8 @@ class ShareData {
      * success; throws `ShareDataStructuralProofFailedError` on any mismatch
      * (hash, previousHash, signature, or purpose).
      */
-    verifyStructuralProof(proof, curve = this._signingCurve) {
-        return (0, verify_share_data_proposal_proof_1.verifyShareDataProposalProof)(proof, this, curve);
+    verifyStructuralProof(proof) {
+        return (0, verify_share_data_proposal_proof_1.verifyShareDataProposalProof)(proof, this);
     }
     /**
      * Verifies that `proof` authorizes applying a transaction that moves this
@@ -372,8 +459,8 @@ class ShareData {
      * verify against any other. Returns `true`; throws
      * `ShareDataTransactionProofFailedError` on any mismatch.
      */
-    verifyTransactionProof(proof, proposedData, curve = this._signingCurve) {
-        return (0, verify_transaction_proposal_proof_1.verifyTransactionProposalProof)(proof, this, proposedData, curve);
+    verifyTransactionProof(proof, proposedData) {
+        return (0, verify_transaction_proposal_proof_1.verifyTransactionProposalProof)(proof, this, proposedData);
     }
     //#endregion Crypto Proofs
     //#region Structure Proofs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@degenerate/sharedata",
-  "version": "0.3.1",
+  "version": "0.6.0",
   "description": "This contains the ShareData Adaptive Framework Ecosystem (SAFE) network core code",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,10 +49,10 @@
     "url": "https://github.com/syncrude/safe/issues"
   },
   "homepage": "https://github.com/syncrude/safe#readme",
-  "gitHead": "c33ed2f06679f5bd76c2eccf7054212c1820a014",
+  "gitHead": "c8c1a2f456cdb01a74f85779275b246361e33b81",
   "dependencies": {
-    "@degenerate/generic": "^0.3.0",
-    "@degenerate/rules": "^0.3.0",
+    "@degenerate/generic": "^0.6.0",
+    "@degenerate/rules": "^0.6.0",
     "zod": "^4.4.3"
   },
   "engines": {