@degenerate/sharedata 0.4.0 → 0.6.0

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,SAqHxD,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

@@ -84,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/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/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

@@ -258,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}
@@ -267,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

@@ -448,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
@@ -459,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.4.0",
+  "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": "9453d9ab785e03fd01eb5b408ed0e3ca22baefd5",
+  "gitHead": "c8c1a2f456cdb01a74f85779275b246361e33b81",
   "dependencies": {
-    "@degenerate/generic": "^0.4.0",
-    "@degenerate/rules": "^0.4.0",
+    "@degenerate/generic": "^0.6.0",
+    "@degenerate/rules": "^0.6.0",
     "zod": "^4.4.3"
   },
   "engines": {