@degenerate/sharedata 0.2.6 → 0.3.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"share-data-repository.d.ts","sourceRoot":"","sources":["../../src/persistence/share-data-repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AASrD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,mBAAmB;IAChC,6EAA6E;IAC7E,IAAI,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElD;;;;OAIG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IAEjD;;;;OAIG;IACH,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAEhC;;;;;;;;OAQG;IACH,gBAAgB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;IAElD,wEAAwE;IACxE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,11 @@
+import { EllipticalCurvesSigning, IShareDataInitialCryptoData } from '@degenerate/generic';
+import { ShareData } from '../share-data';
+/**
+ * This function creates the initial crypto data for the share data.
+ *
+ * @param constructedShareData
+ */
+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;
+//# sourceMappingURL=create-share-data-initial-crypto.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShareDataInitialCrypto = void 0;
+const generic_1 = require("@degenerate/generic");
+const calculate_share_data_string_1 = require("../helpers/calculate-share-data-string");
+/**
+ * This function creates the initial crypto data for the share data.
+ *
+ * @param constructedShareData
+ */
+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 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 initialCryptoData = {
+        publicKey: keyPair.getPublic('hex'),
+        shareDataHash,
+        shareDataSignature,
+        timestamp: Date.now(),
+    };
+    return initialCryptoData;
+};
+exports.createShareDataInitialCrypto = createShareDataInitialCrypto;

package/dist/share-data/helpers/calculate-share-data-string.d.ts

@@ -0,0 +1,21 @@
+import { IShareDataAdditionalValuesToInclude, IShareDataConfig } from '@degenerate/generic';
+import { ShareData } from '../share-data';
+/**
+ * This function calculates the share data string from the share data object.
+ *
+ * When `additionalValuesToInclude` is supplied, its `purpose` field is folded
+ * into the output as a `|purpose:<value>` suffix. This is load-bearing: it
+ * guarantees that two proofs taken over the same share-data state but for
+ * different purposes (e.g. `'deposit'` vs `'rule-balance'`) sign over
+ * different strings, so verification cannot accept one proof in place of
+ * another even when state happens to be identical.
+ *
+ * @param shareData the share data object
+ * @param config the configuration for the share data string
+ * @param additionalValuesToInclude extra values to fold in. `purpose` is
+ *   required when this argument is supplied (enforced by the schema type).
+ * @returns the share data string
+ */
+export declare const calculateShareDataString: (shareData: ShareData, config?: IShareDataConfig, // Default config
+additionalValuesToInclude?: IShareDataAdditionalValuesToInclude) => string;
+//# sourceMappingURL=calculate-share-data-string.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-share-data-string.d.ts","sourceRoot":"","sources":["../../../src/share-data/helpers/calculate-share-data-string.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,mCAAmC,EACnC,gBAAgB,EAEnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,GACjC,WAAW,SAAS,EACpB,SAAQ,gBAA+C,EAAE,iBAAiB;AAC1E,4BAA4B,mCAAmC,WAqDlE,CAAC"}

package/dist/share-data/helpers/calculate-share-data-string.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateShareDataString = void 0;
+const generic_1 = require("@degenerate/generic");
+const default_share_data_string_config_1 = require("./config/default-share-data-string.config");
+/**
+ * This function calculates the share data string from the share data object.
+ *
+ * When `additionalValuesToInclude` is supplied, its `purpose` field is folded
+ * into the output as a `|purpose:<value>` suffix. This is load-bearing: it
+ * guarantees that two proofs taken over the same share-data state but for
+ * different purposes (e.g. `'deposit'` vs `'rule-balance'`) sign over
+ * different strings, so verification cannot accept one proof in place of
+ * another even when state happens to be identical.
+ *
+ * @param shareData the share data object
+ * @param config the configuration for the share data string
+ * @param additionalValuesToInclude extra values to fold in. `purpose` is
+ *   required when this argument is supplied (enforced by the schema type).
+ * @returns the share data string
+ */
+const calculateShareDataString = (shareData, config = default_share_data_string_config_1.defaultShareDataStringConfig, // Default config
+additionalValuesToInclude) => {
+    generic_1.IShareDataConfigSchema.parse(config);
+    // Enforce the `purpose: z.string().min(1)` constraint declared on the
+    // schema. Without this, callers can pass an empty-string or omitted
+    // purpose and proofs verify normally, softening the cross-purpose
+    // replay protection. Only the purpose is enforced here; the optional
+    // rules/functions/transactionHistory/events arrays are forwarded
+    // without re-parsing (callers controlling those are typically internal,
+    // and full schema parse here was too strict in practice).
+    if (additionalValuesToInclude !== undefined) {
+        const purpose = additionalValuesToInclude.purpose;
+        if (typeof purpose !== 'string' || purpose.length < 1) {
+            throw new Error('calculateShareDataString: additionalValuesToInclude.purpose is required and must be a non-empty string');
+        }
+    }
+    let fullString = '';
+    for (const configItem of config) {
+        const key = configItem.key.startsWith('_') ? configItem.key : `_${configItem.key}`;
+        if (key in shareData) {
+            const liveValue = shareData[key]; // Type assertion for dynamic access
+            // Default: hash whatever the share-data already holds. When the
+            // caller supplied a matching additional-values array, hash a
+            // freshly-merged copy so the live ShareData arrays stay
+            // untouched. The old `liveValue.push(...)` form permanently
+            // corrupted state across every signing call.
+            let value = liveValue;
+            if (typeof liveValue !== 'undefined' &&
+                Array.isArray(liveValue) &&
+                additionalValuesToInclude &&
+                configItem.key in additionalValuesToInclude) {
+                value = [...liveValue, ...additionalValuesToInclude[configItem.key]];
+            }
+            // Process the value if a process function is provided
+            if (configItem.process) {
+                fullString += configItem.process(value);
+            }
+            else {
+                fullString += value;
+            }
+        }
+    }
+    if (additionalValuesToInclude) {
+        // Bind the signed snapshot to a specific purpose so a proof signed
+        // for one purpose cannot be replayed as a proof for another.
+        fullString += `|purpose:${additionalValuesToInclude.purpose}`;
+    }
+    return fullString;
+};
+exports.calculateShareDataString = calculateShareDataString;

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

@@ -0,0 +1,7 @@
+import { IShareDataConfig } from '@degenerate/generic';
+/**
+ * This contains the default configuration for the share data.
+ * strigify function.
+ */
+export declare const defaultShareDataStringConfig: IShareDataConfig;
+//# sourceMappingURL=default-share-data-string.config.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultShareDataStringConfig = void 0;
+const get_array_string_1 = require("../get-array-string");
+const stringify_1 = require("./stringify");
+/**
+ * This contains the default configuration for the share data.
+ * strigify function.
+ */
+exports.defaultShareDataStringConfig = [
+    { key: 'id' },
+    { key: 'version' },
+    { key: 'lastUpdated' },
+    { key: 'isLocked' },
+    { key: 'creationPublicKey' },
+    { key: 'currentState', process: stringify_1.stringify },
+    { key: 'cryptoProofs', process: get_array_string_1.getArrayString },
+    { key: 'structuralProofs', 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 },
+    { key: 'transactionHistory', process: get_array_string_1.getArrayString },
+    { key: 'creationHash' },
+    { key: 'creationSignature' },
+];

package/dist/share-data/helpers/config/stringify.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Create a wrapper function with the expected signature
+ */
+export declare const stringify: (args_0: any, ...args: unknown[]) => string;
+//# sourceMappingURL=stringify.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stringify.d.ts","sourceRoot":"","sources":["../../../../src/share-data/helpers/config/stringify.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,GAAG,EAAE,GAAG,MAAM,OAAO,EAAE,KAAG,MAE3D,CAAC"}

package/dist/share-data/helpers/config/stringify.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = void 0;
+/**
+ * Create a wrapper function with the expected signature
+ */
+const stringify = (args_0, ...args) => {
+    return JSON.stringify(args_0, ...args);
+};
+exports.stringify = stringify;

package/dist/share-data/helpers/get-array-string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This function joins an array of strings into a single string.
+ * It explicitly converts undefined values to null before stringifying.
+ */
+export declare const getArrayString: (array: any[]) => string;
+//# sourceMappingURL=get-array-string.d.ts.map

package/dist/share-data/helpers/get-array-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-array-string.d.ts","sourceRoot":"","sources":["../../../src/share-data/helpers/get-array-string.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,GAAG,EAAE,WAO1C,CAAA"}

package/dist/share-data/helpers/get-array-string.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayString = void 0;
+/**
+ * This function joins an array of strings into a single string.
+ * It explicitly converts undefined values to null before stringifying.
+ */
+const getArrayString = (array) => {
+    if (array.length === 0)
+        return '';
+    return array.map(item => {
+        // Explicitly convert undefined to null
+        const valueToStringify = item === undefined ? null : item;
+        return JSON.stringify(valueToStringify);
+    }).join('');
+};
+exports.getArrayString = getArrayString;

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

@@ -0,0 +1,57 @@
+import { EllipticalCurvesSigning, IShareData, IShareDataCryptoProof } from '@degenerate/generic';
+import { ShareData } from '../../share-data';
+/**
+ * Configuration for the production transaction-proposal signer returned by
+ * {@link buildTransactionProposalSigner}.
+ */
+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
+     * 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
+ * exact state change. Hand it the proposed state, the function producing
+ * that state, and the live share-data, and it returns a proof the runtime
+ * mutation path (`ShareData.addTransaction` / `ShareDataManager.applyTransaction`)
+ * will accept.
+ */
+export type TransactionProposalSigner = (proposedState: IShareData, functionId: string, shareData: ShareData) => IShareDataCryptoProof;
+/**
+ * Returns a production-ready {@link TransactionProposalSigner} that signs each
+ * runtime transaction with `config.privateKey`. This is the transaction-path
+ * analog of `buildEllipticalCurvesProofFor` (from `@degenerate/shareblock`):
+ * where that one mints *structural* proofs as a block is assembled, this one
+ * mints *transaction* proofs that authorize mutating an already-built,
+ * already-locked block at runtime.
+ *
+ * Wire it into the proposer adapter that drives the events/realtime mutation
+ * path:
+ *
+ * ```ts
+ * const sign = buildTransactionProposalSigner({
+ *     privateKey: keyManager.getSigningKey(shareDataId),
+ * });
+ * const proof = sign(proposedState, functionId, shareData);
+ * manager.applyTransaction(shareDataId, proposedState, fn, proof);
+ * ```
+ *
+ * Unlike the structural signer, this one performs **no** crypto
+ * initialization: at runtime the block's crypto chain is already established
+ * and the block is locked, so `createTransactionProposalProof` has a previous
+ * hash to chain to. The proof binds the proposed-state hash and `functionId`
+ * into the signature, so it authorizes exactly one state change and cannot be
+ * replayed for a different amount or a different function.
+ */
+export declare const buildTransactionProposalSigner: (config: ITransactionProposalSignerConfig) => TransactionProposalSigner;
+//# sourceMappingURL=build-transaction-proposal-signer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,36 @@
+"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
+ * runtime transaction with `config.privateKey`. This is the transaction-path
+ * analog of `buildEllipticalCurvesProofFor` (from `@degenerate/shareblock`):
+ * where that one mints *structural* proofs as a block is assembled, this one
+ * mints *transaction* proofs that authorize mutating an already-built,
+ * already-locked block at runtime.
+ *
+ * Wire it into the proposer adapter that drives the events/realtime mutation
+ * path:
+ *
+ * ```ts
+ * const sign = buildTransactionProposalSigner({
+ *     privateKey: keyManager.getSigningKey(shareDataId),
+ * });
+ * const proof = sign(proposedState, functionId, shareData);
+ * manager.applyTransaction(shareDataId, proposedState, fn, proof);
+ * ```
+ *
+ * Unlike the structural signer, this one performs **no** crypto
+ * initialization: at runtime the block's crypto chain is already established
+ * and the block is locked, so `createTransactionProposalProof` has a previous
+ * hash to chain to. The proof binds the proposed-state hash and `functionId`
+ * into the signature, so it authorizes exactly one state change and cannot be
+ * 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);
+};
+exports.buildTransactionProposalSigner = buildTransactionProposalSigner;

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

@@ -0,0 +1,12 @@
+import { EllipticalCurvesSigning, 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 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;
+//# sourceMappingURL=create-share-data-proposal-proof.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShareDataProposalProof = void 0;
+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");
+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 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 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 shareDataCryptoProof = {
+        publicKey: keyPair.getPublic('hex'),
+        shareDataHash,
+        shareDataPreviousHash,
+        shareDataSignature,
+        // Reuse the timestamp folded into the signed string above. Calling
+        // Date.now() a second time here would let a millisecond tick
+        // between the two reads, so the proof's `timestamp` would not match
+        // what was signed — verification would then fail intermittently.
+        timestamp: currentTimestamp,
+        // The proof carries its own purpose so verifiers don't need a
+        // separate parameter at the boundary — see schema docs.
+        purpose: additionalValuesToInclude.purpose,
+    };
+    return shareDataCryptoProof;
+};
+exports.createShareDataProposalProof = createShareDataProposalProof;

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

@@ -0,0 +1,27 @@
+import { EllipticalCurvesSigning, IShareData, IShareDataCryptoProof } from '@degenerate/generic';
+import { ShareData } from '../../share-data';
+/**
+ * Mint a transaction proposal proof: a signed attestation that the holder of
+ * `privateKey` authorizes applying `functionId` to move `shareData` from its
+ * current state to exactly `proposedState`.
+ *
+ * Unlike a structural proof (which binds only the current state + a purpose),
+ * this proof folds the *proposed* state hash and the function id into the
+ * signed string. That closes the runtime replay hole: the signature is valid
+ * only for the one proposed state it was minted for, so it cannot be replayed
+ * to authorize a different amount or a different function.
+ *
+ * The wire shape is the existing `IShareDataCryptoProof`: `purpose` carries
+ * the `functionId`, and the proposed-state binding lives entirely in the
+ * signature. The verifier recomputes the proposed-state hash from the proposed
+ * 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 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;
+//# sourceMappingURL=create-transaction-proposal-proof.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransactionProposalProof = void 0;
+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");
+const create_transaction_proposal_string_to_sign_1 = require("../helpers/create-transaction-proposal-string-to-sign");
+const hash_proposed_state_1 = require("../helpers/hash-proposed-state");
+/**
+ * Mint a transaction proposal proof: a signed attestation that the holder of
+ * `privateKey` authorizes applying `functionId` to move `shareData` from its
+ * current state to exactly `proposedState`.
+ *
+ * Unlike a structural proof (which binds only the current state + a purpose),
+ * this proof folds the *proposed* state hash and the function id into the
+ * signed string. That closes the runtime replay hole: the signature is valid
+ * only for the one proposed state it was minted for, so it cannot be replayed
+ * to authorize a different amount or a different function.
+ *
+ * The wire shape is the existing `IShareDataCryptoProof`: `purpose` carries
+ * the `functionId`, and the proposed-state binding lives entirely in the
+ * signature. The verifier recomputes the proposed-state hash from the proposed
+ * 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 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) => {
+    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);
+    // 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 });
+    const currentHash = (0, generic_1.calculateHash)(currentString);
+    const proposedStateHash = (0, hash_proposed_state_1.hashProposedState)(proposedState);
+    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);
+    // Field order mirrors IShareDataCryptoProofSchema exactly — load-bearing,
+    // see the schema docs in share-data-crypto-models.ts.
+    const proof = {
+        publicKey: keyPair.getPublic('hex'),
+        shareDataHash: currentHash,
+        shareDataPreviousHash: previousHash,
+        shareDataSignature: signature,
+        timestamp,
+        purpose: functionId,
+    };
+    return proof;
+};
+exports.createTransactionProposalProof = createTransactionProposalProof;

package/dist/share-data/proofs/helpers/create-share-data-string-to-sign.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This function creates the string to sign for the crypto proof
+ *
+ * @param currentShareDataHash the current share data hash
+ * @param previousShareDataHash the previous share data hash
+ * @param timeStamp the timestamp of the crypto proof
+ * @returns
+ */
+export declare const createShareDataStringToSign: (currentShareDataHash: string, // the current share data hash
+previousShareDataHash: string, // the previous share data hash
+timeStamp: number) => string;
+//# sourceMappingURL=create-share-data-string-to-sign.d.ts.map

package/dist/share-data/proofs/helpers/create-share-data-string-to-sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-share-data-string-to-sign.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/helpers/create-share-data-string-to-sign.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,GACpC,sBAAsB,MAAM,EAAE,8BAA8B;AAC5D,uBAAuB,MAAM,EAAE,+BAA+B;AAC9D,WAAW,MAAM,KAClB,MAEF,CAAC"}

package/dist/share-data/proofs/helpers/create-share-data-string-to-sign.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShareDataStringToSign = void 0;
+/**
+ * This function creates the string to sign for the crypto proof
+ *
+ * @param currentShareDataHash the current share data hash
+ * @param previousShareDataHash the previous share data hash
+ * @param timeStamp the timestamp of the crypto proof
+ * @returns
+ */
+const createShareDataStringToSign = (currentShareDataHash, // the current share data hash
+previousShareDataHash, // the previous share data hash
+timeStamp) => {
+    return `${currentShareDataHash}${previousShareDataHash}${timeStamp}`;
+};
+exports.createShareDataStringToSign = createShareDataStringToSign;

package/dist/share-data/proofs/helpers/create-transaction-proposal-string-to-sign.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Builds the canonical string a transaction proposal proof signs over.
+ *
+ * Deliberately distinct from `createShareDataStringToSign` (the structural /
+ * creation proof payload). A structural proof signs
+ * `${hash}${previousHash}${timestamp}` with no delimiters; this payload adds a
+ * `tx:` prefix, pipe delimiters, the *proposed* state hash, and the function
+ * id. Because the two signed strings can never collide, a structural proof's
+ * signature can never satisfy transaction verification and vice versa — the
+ * proof kinds are cryptographically non-interchangeable even though they share
+ * the `IShareDataCryptoProof` wire shape.
+ *
+ * The `proposedStateHash` component is what closes the runtime replay hole:
+ * the signature binds the exact post-transaction state, so a proof minted for
+ * a 1000-unit deposit cannot authorize a 9000-unit deposit.
+ *
+ * @param currentShareDataHash hash of the share-data state before the transaction
+ * @param proposedStateHash hash of the proposed (post-transaction) state
+ * @param functionId id of the function authorized to produce the proposed state
+ * @param previousShareDataHash previous hash anchoring the chain position
+ * @param timeStamp the timestamp folded into the signature
+ */
+export declare const createTransactionProposalStringToSign: (currentShareDataHash: string, proposedStateHash: string, functionId: string, previousShareDataHash: string, timeStamp: number) => string;
+//# sourceMappingURL=create-transaction-proposal-string-to-sign.d.ts.map

package/dist/share-data/proofs/helpers/create-transaction-proposal-string-to-sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-transaction-proposal-string-to-sign.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/helpers/create-transaction-proposal-string-to-sign.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,qCAAqC,GAC9C,sBAAsB,MAAM,EAC5B,mBAAmB,MAAM,EACzB,YAAY,MAAM,EAClB,uBAAuB,MAAM,EAC7B,WAAW,MAAM,KAClB,MAEF,CAAC"}

package/dist/share-data/proofs/helpers/create-transaction-proposal-string-to-sign.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransactionProposalStringToSign = void 0;
+/**
+ * Builds the canonical string a transaction proposal proof signs over.
+ *
+ * Deliberately distinct from `createShareDataStringToSign` (the structural /
+ * creation proof payload). A structural proof signs
+ * `${hash}${previousHash}${timestamp}` with no delimiters; this payload adds a
+ * `tx:` prefix, pipe delimiters, the *proposed* state hash, and the function
+ * id. Because the two signed strings can never collide, a structural proof's
+ * signature can never satisfy transaction verification and vice versa — the
+ * proof kinds are cryptographically non-interchangeable even though they share
+ * the `IShareDataCryptoProof` wire shape.
+ *
+ * The `proposedStateHash` component is what closes the runtime replay hole:
+ * the signature binds the exact post-transaction state, so a proof minted for
+ * a 1000-unit deposit cannot authorize a 9000-unit deposit.
+ *
+ * @param currentShareDataHash hash of the share-data state before the transaction
+ * @param proposedStateHash hash of the proposed (post-transaction) state
+ * @param functionId id of the function authorized to produce the proposed state
+ * @param previousShareDataHash previous hash anchoring the chain position
+ * @param timeStamp the timestamp folded into the signature
+ */
+const createTransactionProposalStringToSign = (currentShareDataHash, proposedStateHash, functionId, previousShareDataHash, timeStamp) => {
+    return `tx:${currentShareDataHash}|${proposedStateHash}|${functionId}|${previousShareDataHash}|${timeStamp}`;
+};
+exports.createTransactionProposalStringToSign = createTransactionProposalStringToSign;

package/dist/share-data/proofs/helpers/get-previous-hash-from-share-data.d.ts

@@ -0,0 +1,9 @@
+import { ShareData } from '../../share-data';
+/**
+ * This gets the previous hash from the share data object.
+ *
+ * @param shareData the share data object
+ * @returns the previous hash
+ */
+export declare const getPreviousHashFromShareData: (shareData: ShareData) => string;
+//# sourceMappingURL=get-previous-hash-from-share-data.d.ts.map

package/dist/share-data/proofs/helpers/get-previous-hash-from-share-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-previous-hash-from-share-data.d.ts","sourceRoot":"","sources":["../../../../src/share-data/proofs/helpers/get-previous-hash-from-share-data.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,GAAI,WAAW,SAAS,KAAG,MAmBnE,CAAC"}

package/dist/share-data/proofs/helpers/get-previous-hash-from-share-data.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPreviousHashFromShareData = void 0;
+const generic_1 = require("@degenerate/generic");
+/**
+ * This gets the previous hash from the share data object.
+ *
+ * @param shareData the share data object
+ * @returns the previous hash
+ */
+const getPreviousHashFromShareData = (shareData) => {
+    if (shareData.isLocked) {
+        if (shareData.cryptoProofs.length !== 0) {
+            return shareData.cryptoProofs[shareData.cryptoProofs.length - 1].shareDataHash;
+        }
+        return shareData.structuralProofs[shareData.structuralProofs.length - 1].shareDataHash;
+    }
+    if (shareData.structuralProofs.length !== 0) {
+        return shareData.structuralProofs[shareData.structuralProofs.length - 1].shareDataHash;
+    }
+    // If the share data is not locked and there are no structural proofs,
+    // then the creation hash is the previous hash
+    if (!shareData.creationHash) {
+        throw new generic_1.ShareDataPreviousHashNotAvailableError(shareData.id);
+    }
+    return shareData.creationHash;
+};
+exports.getPreviousHashFromShareData = getPreviousHashFromShareData;