@degenerate/generic 0.2.6 → 0.3.2

package/dist/crypto/private-public-keys/create-key-pair-from-private-key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-key-pair-from-private-key.d.ts","sourceRoot":"","sources":["../../../src/crypto/private-public-keys/create-key-pair-from-private-key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AAE5G;;;;;GAKG;AACH,QAAA,MAAM,2BAA2B,UAAW,uBAAuB,GAAG,0BAA0B,cAChF,MAAM,KAAG,QAAQ,CAAC,EAAE,CAAC,OAKpC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}
+{"version":3,"file":"create-key-pair-from-private-key.d.ts","sourceRoot":"","sources":["../../../src/crypto/private-public-keys/create-key-pair-from-private-key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AAE5G;;;;;GAKG;AACH,QAAA,MAAM,2BAA2B,GAAI,OAAO,uBAAuB,GAAG,0BAA0B,EAC5F,YAAY,MAAM,KAAG,QAAQ,CAAC,EAAE,CAAC,OAKpC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/crypto/private-public-keys/create-key-pair-from-private-key.js

@@ -44,7 +44,7 @@ const Elliptic = __importStar(require("elliptic"));
  */
 const createKeyPairFromPrivateKey = (curve, privateKey) => {
     const ellipticalCurve = new Elliptic.ec(curve);
-    const keyPair = ellipticalCurve.keyFromPrivate(privateKey);
+    const keyPair = ellipticalCurve.keyFromPrivate(privateKey, 'hex');
     return keyPair;
 };
 exports.createKeyPairFromPrivateKey = createKeyPairFromPrivateKey;

package/dist/crypto/private-public-keys/create-key-pair-from-public-key.d.ts

@@ -0,0 +1,11 @@
+import * as Elliptic from 'elliptic';
+import { EllipticalCurvesEncryption, EllipticalCurvesSigning } from '../../_settings/cryptography-settings';
+/**
+ * This function creates a key pair from a public key using the elliptic library.
+ *
+ * @param curve the elliptical curve to create the key pair for.
+ * @param publicKey the public key in hexadecimal format.
+ * @returns
+ */
+export declare const createKeyPairFromPublicKey: (curve: EllipticalCurvesSigning | EllipticalCurvesEncryption, publicKey: string, encoding?: BufferEncoding) => Elliptic.ec.KeyPair;
+//# sourceMappingURL=create-key-pair-from-public-key.d.ts.map

package/dist/crypto/private-public-keys/create-key-pair-from-public-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-key-pair-from-public-key.d.ts","sourceRoot":"","sources":["../../../src/crypto/private-public-keys/create-key-pair-from-public-key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAE5G;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GACnC,OAAO,uBAAuB,GAAG,0BAA0B,EAC3D,WAAW,MAAM,EACjB,WAAU,cAAsB,KACjC,QAAQ,CAAC,EAAE,CAAC,OAKd,CAAC"}

package/dist/crypto/private-public-keys/create-key-pair-from-public-key.js

@@ -0,0 +1,51 @@
+"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.createKeyPairFromPublicKey = void 0;
+/* eslint-disable new-cap */
+const Elliptic = __importStar(require("elliptic"));
+/**
+ * This function creates a key pair from a public key using the elliptic library.
+ *
+ * @param curve the elliptical curve to create the key pair for.
+ * @param publicKey the public key in hexadecimal format.
+ * @returns
+ */
+const createKeyPairFromPublicKey = (curve, publicKey, encoding = 'hex') => {
+    const ellipticalCurve = new Elliptic.ec(curve);
+    const keyPair = ellipticalCurve.keyFromPublic(publicKey, encoding);
+    return keyPair;
+};
+exports.createKeyPairFromPublicKey = createKeyPairFromPublicKey;

package/dist/crypto/private-public-keys/generation/create-entropy-for-elliptical-curve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-entropy-for-elliptical-curve.d.ts","sourceRoot":"","sources":["../../../../src/crypto/private-public-keys/generation/create-entropy-for-elliptical-curve.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AAG/G;;;;;GAKG;AACH,QAAA,MAAM,8BAA8B,UAAW,uBAAuB,GAAG,0BAA0B,KAAG,MAQrG,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}
+{"version":3,"file":"create-entropy-for-elliptical-curve.d.ts","sourceRoot":"","sources":["../../../../src/crypto/private-public-keys/generation/create-entropy-for-elliptical-curve.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AAG/G;;;;;GAKG;AACH,QAAA,MAAM,8BAA8B,GAAI,OAAO,uBAAuB,GAAG,0BAA0B,KAAG,MAQrG,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

package/dist/crypto/private-public-keys/generation/generate-key-pair.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-key-pair.d.ts","sourceRoot":"","sources":["../../../../src/crypto/private-public-keys/generation/generate-key-pair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAC/G,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC;;;;;GAKG;AACH,QAAA,MAAM,eAAe,UAAW,uBAAuB,GAAG,0BAA0B,cAAc,MAAM,WAC3F,MAAM,KAAG,QAAQ,CAAC,EAAE,CAAC,OAMjC,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"generate-key-pair.d.ts","sourceRoot":"","sources":["../../../../src/crypto/private-public-keys/generation/generate-key-pair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAC/G,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC;;;;;GAKG;AACH,QAAA,MAAM,eAAe,GAAI,OAAO,uBAAuB,GAAG,0BAA0B,EAAE,YAAY,MAAM,EACpG,SAAS,MAAM,KAAG,QAAQ,CAAC,EAAE,CAAC,OAMjC,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"get-private-public-key-from-keypair.d.ts","sourceRoot":"","sources":["../../../../src/crypto/private-public-keys/generation/get-private-public-key-from-keypair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC;;;;GAIG;AACH,QAAA,MAAM,wBAAwB,YAAa,QAAQ,CAAC,EAAE,CAAC,OAAO,KAAG,MAEhE,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,uBAAuB,YAAa,QAAQ,CAAC,EAAE,CAAC,OAAO,KAAG,MAE/D,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"get-private-public-key-from-keypair.d.ts","sourceRoot":"","sources":["../../../../src/crypto/private-public-keys/generation/get-private-public-key-from-keypair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC;;;;GAIG;AACH,QAAA,MAAM,wBAAwB,GAAI,SAAS,QAAQ,CAAC,EAAE,CAAC,OAAO,KAAG,MAEhE,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,uBAAuB,GAAI,SAAS,QAAQ,CAAC,EAAE,CAAC,OAAO,KAAG,MAE/D,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,CAAC"}

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

@@ -3,6 +3,17 @@ import * as Elliptic from 'elliptic';
  * This function creates a signature for a hash using an elliptical curve.
  * @param keyPair the key pair to use for signing.
  * @param hashToSign the hash to sign.
+ *
+ * Implementation note: `elliptic.ec(curve).keyPair.sign(msg)` treats `msg`
+ * as a hex string, parses it to a BigInt, then truncates to the curve's
+ * `n.bitLength()` (~253 bits for `'ed25519'`) by right-shifting, discarding
+ * the LOW bits. For inputs longer than ~63 hex characters that means the
+ * signature only commits to the leading high bits of the input — bytes near
+ * the end of `hashToSign` contribute nothing to the signature. We always
+ * re-hash with SHA-256 first so the input handed to `sign` is a fixed-size
+ * 256-bit digest whose every bit depends on every input bit (avalanche),
+ * making the 3-bit ECDSA truncation harmless. `verifyCryptoSignatureByHash`
+ * mirrors this transformation.
  */
 declare const createEllipticalCurveSignature: (keyPair: Elliptic.ec.KeyPair, hashToSign: string) => string;
 export { createEllipticalCurveSignature };

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

@@ -1 +1 @@
-{"version":3,"file":"create-crypto-signature.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/create-crypto-signature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC;;;;GAIG;AACH,QAAA,MAAM,8BAA8B,YAAa,QAAQ,CAAC,EAAE,CAAC,OAAO,cAAc,MAAM,KAAG,MAG1F,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}
+{"version":3,"file":"create-crypto-signature.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/create-crypto-signature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAGrC;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,8BAA8B,GAAI,SAAS,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,MAAM,KAAG,MAI1F,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

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

@@ -1,13 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEllipticalCurveSignature = void 0;
+const calculate_hash_1 = require("../calculate-hash");
 /**
  * This function creates a signature for a hash using an elliptical curve.
  * @param keyPair the key pair to use for signing.
  * @param hashToSign the hash to sign.
+ *
+ * Implementation note: `elliptic.ec(curve).keyPair.sign(msg)` treats `msg`
+ * as a hex string, parses it to a BigInt, then truncates to the curve's
+ * `n.bitLength()` (~253 bits for `'ed25519'`) by right-shifting, discarding
+ * the LOW bits. For inputs longer than ~63 hex characters that means the
+ * signature only commits to the leading high bits of the input — bytes near
+ * the end of `hashToSign` contribute nothing to the signature. We always
+ * re-hash with SHA-256 first so the input handed to `sign` is a fixed-size
+ * 256-bit digest whose every bit depends on every input bit (avalanche),
+ * making the 3-bit ECDSA truncation harmless. `verifyCryptoSignatureByHash`
+ * mirrors this transformation.
  */
 const createEllipticalCurveSignature = (keyPair, hashToSign) => {
-    const signature = keyPair.sign(hashToSign).toDER('hex');
+    const digest = (0, calculate_hash_1.calculateHash)(hashToSign);
+    const signature = keyPair.sign(digest).toDER('hex');
     return signature;
 };
 exports.createEllipticalCurveSignature = createEllipticalCurveSignature;

package/dist/crypto/signature/verify-crypto-signature-by-data.d.ts

@@ -7,6 +7,10 @@ import { EllipticalCurvesSigning, EllipticalCurvesEncryption } from '../../_sett
  * @param signature the signature to verify
  * @param publicKey the public key to verify the signature
  * @returns
+ *
+ * Mirrors the `calculateHash`-before-sign step from
+ * `createEllipticalCurveSignature` so both sides see the same fixed-size
+ * 256-bit digest. See that function for the rationale.
  */
 declare const verifyCryptoSignatureByData: (curve: EllipticalCurvesSigning | EllipticalCurvesEncryption, data: any, signature: string, publicKey: string) => Promise<boolean>;
 export { verifyCryptoSignatureByData };

package/dist/crypto/signature/verify-crypto-signature-by-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify-crypto-signature-by-data.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/verify-crypto-signature-by-data.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AAE5G;;;;;;;;GAQG;AACH,QAAA,MAAM,2BAA2B,UAAiB,uBAAuB,GAAG,0BAA0B,QAAQ,GAAG,aAAa,MAAM,aACrH,MAAM,KAAG,OAAO,CAAC,OAAO,CAMtC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}
+{"version":3,"file":"verify-crypto-signature-by-data.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/verify-crypto-signature-by-data.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AAG5G;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,2BAA2B,GAAU,OAAO,uBAAuB,GAAG,0BAA0B,EAAE,MAAM,GAAG,EAAE,WAAW,MAAM,EAChI,WAAW,MAAM,KAAG,OAAO,CAAC,OAAO,CAOtC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/crypto/signature/verify-crypto-signature-by-data.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyCryptoSignatureByData = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const elliptic = __importStar(require("elliptic"));
+const calculate_hash_1 = require("../calculate-hash");
 /**
  * This function verifies the signature of the data using the public key
  *
@@ -44,12 +45,17 @@ const elliptic = __importStar(require("elliptic"));
  * @param signature the signature to verify
  * @param publicKey the public key to verify the signature
  * @returns
+ *
+ * Mirrors the `calculateHash`-before-sign step from
+ * `createEllipticalCurveSignature` so both sides see the same fixed-size
+ * 256-bit digest. See that function for the rationale.
  */
 const verifyCryptoSignatureByData = async (curve, data, signature, publicKey) => {
     // convert data to a string.
-    const hash = JSON.stringify(data);
+    const stringified = JSON.stringify(data);
     // eslint-disable-next-line new-cap
     const key = new elliptic.ec(curve).keyFromPublic(publicKey, 'hex');
-    return key.verify(hash, signature);
+    const digest = (0, calculate_hash_1.calculateHash)(stringified);
+    return key.verify(digest, signature);
 };
 exports.verifyCryptoSignatureByData = verifyCryptoSignatureByData;

package/dist/crypto/signature/verify-crypto-signature-by-hash.d.ts

@@ -7,6 +7,10 @@ import { EllipticalCurvesSigning, EllipticalCurvesEncryption } from '../../_sett
  * @param signature the signature to verify
  * @param publicKey the public key to verify the signature
  * @returns
+ *
+ * Mirrors the `calculateHash`-before-sign step from
+ * `createEllipticalCurveSignature` so both sides see the same fixed-size
+ * 256-bit digest. See that function for the rationale.
  */
 declare const verifyCryptoSignatureByHash: (curve: EllipticalCurvesSigning | EllipticalCurvesEncryption, hash: string, signature: string, publicKey: string) => Promise<boolean>;
 export { verifyCryptoSignatureByHash };

package/dist/crypto/signature/verify-crypto-signature-by-hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verify-crypto-signature-by-hash.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/verify-crypto-signature-by-hash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AAE5G;;;;;;;;GAQG;AACH,QAAA,MAAM,2BAA2B,UAAiB,uBAAuB,GAAG,0BAA0B,QAAQ,MAAM,aAAa,MAAM,aACxH,MAAM,KAAG,OAAO,CAAC,OAAO,CAItC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}
+{"version":3,"file":"verify-crypto-signature-by-hash.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/verify-crypto-signature-by-hash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AAG5G;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,2BAA2B,GAAU,OAAO,uBAAuB,GAAG,0BAA0B,EAAE,MAAM,MAAM,EAAE,WAAW,MAAM,EACnI,WAAW,MAAM,KAAG,OAAO,CAAC,OAAO,CAKtC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/crypto/signature/verify-crypto-signature-by-hash.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyCryptoSignatureByHash = void 0;
 const elliptic = __importStar(require("elliptic"));
+const calculate_hash_1 = require("../calculate-hash");
 /**
  * This function verifies the signature of the data using the public key
  *
@@ -43,10 +44,15 @@ const elliptic = __importStar(require("elliptic"));
  * @param signature the signature to verify
  * @param publicKey the public key to verify the signature
  * @returns
+ *
+ * Mirrors the `calculateHash`-before-sign step from
+ * `createEllipticalCurveSignature` so both sides see the same fixed-size
+ * 256-bit digest. See that function for the rationale.
  */
 const verifyCryptoSignatureByHash = async (curve, hash, signature, publicKey) => {
     // eslint-disable-next-line new-cap
     const key = new elliptic.ec(curve).keyFromPublic(publicKey, 'hex');
-    return key.verify(hash, signature);
+    const digest = (0, calculate_hash_1.calculateHash)(hash);
+    return key.verify(digest, signature);
 };
 exports.verifyCryptoSignatureByHash = verifyCryptoSignatureByHash;

package/dist/errors/index.d.ts

@@ -6,5 +6,7 @@ export * from './request/request-errors';
 export * from './safe/safe-rules-errors';
 export * from './scheduler/scheduler-errors';
 export * from './share-data/share-data-errors';
+export * from './shareblock/shareblock-errors';
+export * from './validation/crypto-validation-errors';
 export * from './base-error';
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/errors/index.js

@@ -22,5 +22,7 @@ __exportStar(require("./request/request-errors"), exports);
 __exportStar(require("./safe/safe-rules-errors"), exports);
 __exportStar(require("./scheduler/scheduler-errors"), exports);
 __exportStar(require("./share-data/share-data-errors"), exports);
+__exportStar(require("./shareblock/shareblock-errors"), exports);
+__exportStar(require("./validation/crypto-validation-errors"), exports);
 // Base error
 __exportStar(require("./base-error"), exports);

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

@@ -1,5 +1,5 @@
 import { BaseError } from '../base-error';
-import { ShareDataTypes } from '../../models/share-data/share-data';
+import { ShareDataTypes } from '../../models/share-data/share-data-models';
 import { IShareDataFunction } from '../../models/functions/share-data-function-models';
 /**
  * This error is thrown when a function is tried to be applied to the share data thats state is locked.
@@ -64,4 +64,95 @@ export declare class ShareRuleProposedConditionsNotPresentError extends BaseErro
      */
     constructor(ruleId: string);
 }
+/**
+ * This error is thrown when share data already exists.
+ */
+export declare class ShareDataAlreadyExistsError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when share data is not found.
+ */
+export declare class ShareDataNotFoundError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when there is duplicate share data.
+ */
+export declare class ShareDataDuplicateError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when share data crypto already exists.
+ */
+export declare class ShareDataCryptoAlreadyExistsError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when share data crypto initialization public key is different.
+ */
+export declare class CryptoInitializationPublicKeyIsDifferentError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when share data crypto proof failed.
+ */
+export declare class ShareDataCryptoProofFailedError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when share data structural proof already exists.
+ */
+export declare class ShareDataStructuralProofAlreadyExistsError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when share data structural proof failed.
+ */
+export declare class ShareDataStructuralProofFailedError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when a runtime transaction proposal proof fails to
+ * verify. Distinct from {@link ShareDataStructuralProofFailedError}: a
+ * structural proof attests only to the pre-mutation state under a purpose,
+ * whereas a transaction proof additionally binds the exact *proposed* state
+ * being applied. A failure here means the proof's signature does not cover
+ * the (current state, proposed state, function, chain position) tuple the
+ * caller is trying to apply — e.g. a proof minted for a different amount,
+ * a different function, or a structural proof replayed as a transaction.
+ */
+export declare class ShareDataTransactionProofFailedError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when a transaction proposal proof is cryptographically
+ * valid but signed by a key that is not authorized to mutate this block.
+ * Distinct from {@link ShareDataTransactionProofFailedError}: there the proof's
+ * signature does not cover the proposed transition; here the signature is
+ * sound, but `proof.publicKey` is not the block's `creationPublicKey`. Signature
+ * validity proves *someone* signed the transition — this gate proves the
+ * *authorized* someone did, closing the "any valid keypair signs a legal
+ * transition" hole on the runtime mutation path.
+ */
+export declare class ShareDataTransactionNotAuthorizedError extends BaseError {
+    constructor(shareDataId: string, signingPublicKey: string);
+}
+/**
+ * This error is thrown when the system attempts to get the previous share data hash
+ * but the share data has not been initialized for the proof yet.
+ */
+export declare class ShareDataPreviousHashNotAvailableError extends BaseError {
+    constructor(shareDataId: string);
+}
+/**
+ * This error is thrown when a persisted ShareData snapshot cannot be replayed — an
+ * unknown block type, an unrecognized schema version, or a transaction whose
+ * `functionId` does not resolve to a registered function on the rebuilt block.
+ * Distinct from {@link ShareDataIntegrityError}, which signals that a replay
+ * succeeded but its result diverged from the snapshot's `expected*` cross-checks.
+ */
+export declare class ShareDataPersistenceError extends BaseError {
+    constructor(shareDataId: string, reason: string);
+}
 //# sourceMappingURL=share-data-errors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"share-data-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/share-data/share-data-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACjD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc;CAGjE;AAED;;GAEG;AACH,qBAAa,2CAA4C,SAAQ,SAAS;IACtE;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IAClD;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,yDAA0D,SAAQ,SAAS;IACpF;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAI5E;AAGD;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,SAAS;IACxD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM;CAIjG;AAKD;;GAEG;AACH,qBAAa,yCAA0C,SAAQ,SAAS;IACpE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;IACrE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B"}
+{"version":3,"file":"share-data-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/share-data/share-data-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACjD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc;CAGjE;AAED;;GAEG;AACH,qBAAa,2CAA4C,SAAQ,SAAS;IACtE;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IAClD;;OAEG;gBACS,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,yDAA0D,SAAQ,SAAS;IACpF;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAI5E;AAGD;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,SAAS;IACxD;;OAEG;gBACS,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM;CAIjG;AAKD;;GAEG;AACH,qBAAa,yCAA0C,SAAQ,SAAS;IACpE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;IACrE;;OAEG;gBACS,MAAM,EAAE,MAAM;CAG7B;AAID;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,SAAS;gBAC1C,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;gBACrC,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;gBACtC,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,iCAAkC,SAAQ,SAAS;gBAChD,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,6CAA8C,SAAQ,SAAS;gBAC5D,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,+BAAgC,SAAQ,SAAS;gBAC9C,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;gBACzD,WAAW,EAAE,MAAM;CAGlC;AAED;;GAEG;AACH,qBAAa,mCAAoC,SAAQ,SAAS;gBAClD,WAAW,EAAE,MAAM;CAGlC;AAED;;;;;;;;;GASG;AACH,qBAAa,oCAAqC,SAAQ,SAAS;gBACnD,WAAW,EAAE,MAAM;CAGlC;AAED;;;;;;;;;GASG;AACH,qBAAa,sCAAuC,SAAQ,SAAS;gBACrD,WAAW,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;CAM5D;AAED;;;GAGG;AACH,qBAAa,sCAAuC,SAAQ,SAAS;gBACrD,WAAW,EAAE,MAAM;CAIlC;AAED;;;;;;GAMG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;gBACxC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAGlD"}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShareRuleProposedConditionsNotPresentError = exports.ShareRuleCurrentConditionsNotPresentError = exports.ShareDataFunctionHashNotValid = exports.ShareDataFunctionBeingAppliedDoesNotExistOnShareDataError = exports.ShareDataIntegrityError = exports.ShareDataCurrentAndProposalDataMatchesError = exports.ShareDataIsLockedError = void 0;
+exports.ShareDataPersistenceError = exports.ShareDataPreviousHashNotAvailableError = exports.ShareDataTransactionNotAuthorizedError = exports.ShareDataTransactionProofFailedError = exports.ShareDataStructuralProofFailedError = exports.ShareDataStructuralProofAlreadyExistsError = exports.ShareDataCryptoProofFailedError = exports.CryptoInitializationPublicKeyIsDifferentError = exports.ShareDataCryptoAlreadyExistsError = exports.ShareDataDuplicateError = exports.ShareDataNotFoundError = exports.ShareDataAlreadyExistsError = exports.ShareRuleProposedConditionsNotPresentError = exports.ShareRuleCurrentConditionsNotPresentError = exports.ShareDataFunctionHashNotValid = exports.ShareDataFunctionBeingAppliedDoesNotExistOnShareDataError = exports.ShareDataIntegrityError = exports.ShareDataCurrentAndProposalDataMatchesError = exports.ShareDataIsLockedError = void 0;
 const base_error_1 = require("../base-error");
 /**
  * This error is thrown when a function is tried to be applied to the share data thats state is locked.
@@ -90,3 +90,132 @@ class ShareRuleProposedConditionsNotPresentError extends base_error_1.BaseError
 }
 exports.ShareRuleProposedConditionsNotPresentError = ShareRuleProposedConditionsNotPresentError;
 //#endregion Rules
+/**
+ * This error is thrown when share data already exists.
+ */
+class ShareDataAlreadyExistsError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} already exists.`);
+    }
+}
+exports.ShareDataAlreadyExistsError = ShareDataAlreadyExistsError;
+/**
+ * This error is thrown when share data is not found.
+ */
+class ShareDataNotFoundError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} was not found.`);
+    }
+}
+exports.ShareDataNotFoundError = ShareDataNotFoundError;
+/**
+ * This error is thrown when there is duplicate share data.
+ */
+class ShareDataDuplicateError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Duplicate share data with id ${shareDataId} found.`);
+    }
+}
+exports.ShareDataDuplicateError = ShareDataDuplicateError;
+/**
+ * This error is thrown when share data crypto already exists.
+ */
+class ShareDataCryptoAlreadyExistsError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} already has existing crypto values exists.`);
+    }
+}
+exports.ShareDataCryptoAlreadyExistsError = ShareDataCryptoAlreadyExistsError;
+/**
+ * This error is thrown when share data crypto initialization public key is different.
+ */
+class CryptoInitializationPublicKeyIsDifferentError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} crypto initialization public key is different.`);
+    }
+}
+exports.CryptoInitializationPublicKeyIsDifferentError = CryptoInitializationPublicKeyIsDifferentError;
+/**
+ * This error is thrown when share data crypto proof failed.
+ */
+class ShareDataCryptoProofFailedError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} crypto proof failed.`);
+    }
+}
+exports.ShareDataCryptoProofFailedError = ShareDataCryptoProofFailedError;
+/**
+ * This error is thrown when share data structural proof already exists.
+ */
+class ShareDataStructuralProofAlreadyExistsError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} already has existing structural proof values exists.`);
+    }
+}
+exports.ShareDataStructuralProofAlreadyExistsError = ShareDataStructuralProofAlreadyExistsError;
+/**
+ * This error is thrown when share data structural proof failed.
+ */
+class ShareDataStructuralProofFailedError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} structural proof failed.`);
+    }
+}
+exports.ShareDataStructuralProofFailedError = ShareDataStructuralProofFailedError;
+/**
+ * This error is thrown when a runtime transaction proposal proof fails to
+ * verify. Distinct from {@link ShareDataStructuralProofFailedError}: a
+ * structural proof attests only to the pre-mutation state under a purpose,
+ * whereas a transaction proof additionally binds the exact *proposed* state
+ * being applied. A failure here means the proof's signature does not cover
+ * the (current state, proposed state, function, chain position) tuple the
+ * caller is trying to apply — e.g. a proof minted for a different amount,
+ * a different function, or a structural proof replayed as a transaction.
+ */
+class ShareDataTransactionProofFailedError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} transaction proposal proof failed.`);
+    }
+}
+exports.ShareDataTransactionProofFailedError = ShareDataTransactionProofFailedError;
+/**
+ * This error is thrown when a transaction proposal proof is cryptographically
+ * valid but signed by a key that is not authorized to mutate this block.
+ * Distinct from {@link ShareDataTransactionProofFailedError}: there the proof's
+ * signature does not cover the proposed transition; here the signature is
+ * sound, but `proof.publicKey` is not the block's `creationPublicKey`. Signature
+ * validity proves *someone* signed the transition — this gate proves the
+ * *authorized* someone did, closing the "any valid keypair signs a legal
+ * transition" hole on the runtime mutation path.
+ */
+class ShareDataTransactionNotAuthorizedError extends base_error_1.BaseError {
+    constructor(shareDataId, signingPublicKey) {
+        super(`Share data with id ${shareDataId} rejected a transaction proposal: ` +
+            `signing key ${signingPublicKey} is not authorized to mutate this block.`);
+    }
+}
+exports.ShareDataTransactionNotAuthorizedError = ShareDataTransactionNotAuthorizedError;
+/**
+ * This error is thrown when the system attempts to get the previous share data hash
+ * but the share data has not been initialized for the proof yet.
+ */
+class ShareDataPreviousHashNotAvailableError extends base_error_1.BaseError {
+    constructor(shareDataId) {
+        super(`Share data with id ${shareDataId} previous hash is not available. ` +
+            `This is likely due to the share data not being initialized.`);
+    }
+}
+exports.ShareDataPreviousHashNotAvailableError = ShareDataPreviousHashNotAvailableError;
+/**
+ * This error is thrown when a persisted ShareData snapshot cannot be replayed — an
+ * unknown block type, an unrecognized schema version, or a transaction whose
+ * `functionId` does not resolve to a registered function on the rebuilt block.
+ * Distinct from {@link ShareDataIntegrityError}, which signals that a replay
+ * succeeded but its result diverged from the snapshot's `expected*` cross-checks.
+ */
+class ShareDataPersistenceError extends base_error_1.BaseError {
+    constructor(shareDataId, reason) {
+        super(`Share data with id ${shareDataId} could not be reconstructed from its persisted snapshot: ${reason}`);
+    }
+}
+exports.ShareDataPersistenceError = ShareDataPersistenceError;

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

@@ -0,0 +1,40 @@
+import { BaseError } from '../base-error';
+import { ShareBlockType } from '../../models/shareblock/shareblock-models';
+/**
+ * Thrown by a ShareBlock factory when the supplied metadata's `blockType`
+ * doesn't match the factory's variant. Each factory expects a specific
+ * `ShareBlockType` — e.g. `createFundingShareBlock` requires
+ * `metadata.blockType === ShareBlockType.Funding`.
+ */
+export declare class ShareBlockTypeMismatchError extends BaseError {
+    readonly shareBlockId: string;
+    readonly expected: ShareBlockType;
+    readonly received: ShareBlockType;
+    constructor(shareBlockId: string, expected: ShareBlockType, received: ShareBlockType);
+}
+/**
+ * Thrown by Funding/Distribution factories when
+ * `metadata.relatedLoanApplicationId` is missing. Both variants always tie
+ * back to a specific loan application; constructing one without an id is a
+ * caller bug (caught at construction rather than first transaction so the
+ * error surfaces as close to the wiring mistake as possible).
+ */
+export declare class ShareBlockMissingLoanApplicationIdError extends BaseError {
+    readonly shareBlockId: string;
+    readonly blockType: ShareBlockType;
+    constructor(shareBlockId: string, blockType: ShareBlockType);
+}
+/**
+ * Thrown when a wire-format proof bundle is missing a proof for one of the
+ * purposes the target ShareBlock variant requires. The HTTP route uses the
+ * per-variant `*_REQUIRED_PROOF_PURPOSES` array (exported from each
+ * `create-*-shareblock` module) to detect this early — before any state
+ * lands — so callers get one explicit "you forgot purpose X" instead of a
+ * confusing chain of verifyStructuralProof failures.
+ */
+export declare class MissingRequiredProofError extends BaseError {
+    readonly blockType: ShareBlockType;
+    readonly purpose: string;
+    constructor(blockType: ShareBlockType, purpose: string);
+}
+//# sourceMappingURL=shareblock-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shareblock-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/shareblock/shareblock-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,2CAA2C,CAAC;AAE3E;;;;;GAKG;AACH,qBAAa,2BAA4B,SAAQ,SAAS;IACtD,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,QAAQ,EAAE,cAAc,CAAC;IACzC,SAAgB,QAAQ,EAAE,cAAc,CAAC;gBAE7B,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc;CAQvF;AAED;;;;;;GAMG;AACH,qBAAa,uCAAwC,SAAQ,SAAS;IAClE,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,SAAS,EAAE,cAAc,CAAC;gBAE9B,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc;CAO9D;AAED;;;;;;;GAOG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACpD,SAAgB,SAAS,EAAE,cAAc,CAAC;IAC1C,SAAgB,OAAO,EAAE,MAAM,CAAC;gBAEpB,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM;CAOzD"}

package/dist/errors/shareblock/shareblock-errors.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingRequiredProofError = exports.ShareBlockMissingLoanApplicationIdError = exports.ShareBlockTypeMismatchError = void 0;
+const base_error_1 = require("../base-error");
+/**
+ * Thrown by a ShareBlock factory when the supplied metadata's `blockType`
+ * doesn't match the factory's variant. Each factory expects a specific
+ * `ShareBlockType` — e.g. `createFundingShareBlock` requires
+ * `metadata.blockType === ShareBlockType.Funding`.
+ */
+class ShareBlockTypeMismatchError extends base_error_1.BaseError {
+    constructor(shareBlockId, expected, received) {
+        super(`ShareBlock ${shareBlockId}: factory for type ${expected} received metadata.blockType === ${received}.`);
+        this.shareBlockId = shareBlockId;
+        this.expected = expected;
+        this.received = received;
+    }
+}
+exports.ShareBlockTypeMismatchError = ShareBlockTypeMismatchError;
+/**
+ * Thrown by Funding/Distribution factories when
+ * `metadata.relatedLoanApplicationId` is missing. Both variants always tie
+ * back to a specific loan application; constructing one without an id is a
+ * caller bug (caught at construction rather than first transaction so the
+ * error surfaces as close to the wiring mistake as possible).
+ */
+class ShareBlockMissingLoanApplicationIdError extends base_error_1.BaseError {
+    constructor(shareBlockId, blockType) {
+        super(`ShareBlock ${shareBlockId}: ${blockType} blocks require metadata.relatedLoanApplicationId, none was provided.`);
+        this.shareBlockId = shareBlockId;
+        this.blockType = blockType;
+    }
+}
+exports.ShareBlockMissingLoanApplicationIdError = ShareBlockMissingLoanApplicationIdError;
+/**
+ * Thrown when a wire-format proof bundle is missing a proof for one of the
+ * purposes the target ShareBlock variant requires. The HTTP route uses the
+ * per-variant `*_REQUIRED_PROOF_PURPOSES` array (exported from each
+ * `create-*-shareblock` module) to detect this early — before any state
+ * lands — so callers get one explicit "you forgot purpose X" instead of a
+ * confusing chain of verifyStructuralProof failures.
+ */
+class MissingRequiredProofError extends base_error_1.BaseError {
+    constructor(blockType, purpose) {
+        super(`Missing required proof for purpose '${purpose}' on ${blockType} ShareBlock construction.`);
+        this.blockType = blockType;
+        this.purpose = purpose;
+    }
+}
+exports.MissingRequiredProofError = MissingRequiredProofError;

package/dist/errors/validation/crypto-validation-errors.d.ts

@@ -0,0 +1,8 @@
+import { BaseError } from '../base-error';
+/**
+ * This is thrown when the crypto proof is not valid on the shared data object.
+ */
+export declare class ShareDataCryptoProofNotValidError extends BaseError {
+    constructor(shareDataId: string, cryptoProof: string, publicKey: string);
+}
+//# sourceMappingURL=crypto-validation-errors.d.ts.map

package/dist/errors/validation/crypto-validation-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-validation-errors.d.ts","sourceRoot":"","sources":["../../../src/errors/validation/crypto-validation-errors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C;;GAEG;AACH,qBAAa,iCAAkC,SAAQ,SAAS;gBAChD,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAI1E"}