@bcts/shamir 1.0.0-alpha.8 → 1.0.0-beta.0

package/dist/index.d.mts

@@ -1,18 +1,39 @@
 import { RandomNumberGenerator } from "@bcts/rand";
 
 //#region src/error.d.ts
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
 /**
  * Error types for Shamir secret sharing operations.
+ *
+ * Each variant mirrors a corresponding `Error::*` enum in
+ * `bc-shamir-rust/src/error.rs` with the same trigger conditions and the
+ * same default `Display` strings.
+ *
+ * Note on `InterpolationFailure`: this variant is **reserved but
+ * unreachable** in both the Rust and TypeScript implementations.
+ * `interpolate()` in `interpolate.ts` never actually returns / throws an
+ * interpolation failure today — the Lagrange-basis math always succeeds
+ * for any well-formed input. The variant is kept for forward
+ * compatibility (e.g. should a future revision add input validation that
+ * could reject pathological cases) and to keep the TS error type a 1:1
+ * mirror of Rust's `Error` enum.
  */
 declare enum ShamirErrorType {
   SecretTooLong = "SecretTooLong",
   TooManyShares = "TooManyShares",
+  /**
+   * Reserved / unreachable in both Rust and TS today. See enum doc above.
+   */
   InterpolationFailure = "InterpolationFailure",
   ChecksumFailure = "ChecksumFailure",
   SecretTooShort = "SecretTooShort",
   SecretNotEvenLen = "SecretNotEvenLen",
   InvalidThreshold = "InvalidThreshold",
-  SharesUnequalLength = "SharesUnequalLength",
+  SharesUnequalLength = "SharesUnequalLength"
 }
 /**
  * Error class for Shamir secret sharing operations.
@@ -22,6 +43,14 @@ declare class ShamirError extends Error {
   constructor(type: ShamirErrorType, message?: string);
   private static defaultMessage;
 }
+/**
+ * Mirrors Rust's `Result<T, Error>` for API parity.
+ *
+ * The TypeScript port surfaces failures by throwing `ShamirError`
+ * instances rather than returning a sum type, so this alias is a no-op
+ * (`ShamirResult<T>` ≡ `T`). It is kept so signatures published in
+ * `@bcts/shamir` remain visually parallel to their Rust counterparts.
+ */
 type ShamirResult<T> = T;
 //#endregion
 //#region src/shamir.d.ts
@@ -83,85 +112,12 @@ declare function splitSecret(threshold: number, shareCount: number, secret: Uint
  */
 declare function recoverSecret(indexes: number[], shares: Uint8Array[]): Uint8Array;
 //#endregion
-//#region src/hazmat.d.ts
-/**
- * Convert an array of bytes into a bitsliced representation.
- * Takes the first 32 bytes from x and produces 8 u32 values.
- *
- * @param r - Output array of 8 u32 values (bitsliced representation)
- * @param x - Input array of at least 32 bytes
- */
-declare function bitslice(r: Uint32Array, x: Uint8Array): void;
-/**
- * Convert a bitsliced representation back to bytes.
- *
- * @param r - Output array of at least 32 bytes
- * @param x - Input array of 8 u32 values (bitsliced representation)
- */
-declare function unbitslice(r: Uint8Array, x: Uint32Array): void;
-/**
- * Set all 32 positions in a bitsliced array to the same byte value.
- *
- * @param r - Output array of 8 u32 values
- * @param x - Byte value to set in all positions
- */
-declare function bitsliceSetall(r: Uint32Array, x: number): void;
-/**
- * Add (XOR) r with x and store the result in r.
- * In GF(2^8), addition is XOR.
- *
- * @param r - First operand and result
- * @param x - Second operand
- */
-declare function gf256Add(r: Uint32Array, x: Uint32Array): void;
-/**
- * Safely multiply two bitsliced polynomials in GF(2^8) reduced by
- * x^8 + x^4 + x^3 + x + 1. r and a may overlap, but overlapping of r
- * and b will produce an incorrect result! If you need to square a polynomial
- * use gf256Square instead.
- *
- * @param r - Result array (8 u32 values)
- * @param a - First operand (may overlap with r)
- * @param b - Second operand (must NOT overlap with r)
- */
-declare function gf256Mul(r: Uint32Array, a: Uint32Array, b: Uint32Array): void;
-/**
- * Square x in GF(2^8) and write the result to r.
- * r and x may overlap.
- *
- * @param r - Result array (8 u32 values)
- * @param x - Value to square
- */
-declare function gf256Square(r: Uint32Array, x: Uint32Array): void;
-/**
- * Invert x in GF(2^8) and write the result to r.
- *
- * @param r - Result array (8 u32 values)
- * @param x - Value to invert (will be modified)
- */
-declare function gf256Inv(r: Uint32Array, x: Uint32Array): void;
-//#endregion
-//#region src/interpolate.d.ts
+//#region src/index.d.ts
 /**
- * Safely interpolate the polynomial going through
- * the points (x0 [y0_0 y0_1 y0_2 ... y0_31]) , (x1 [y1_0 ...]), ...
- *
- * where
- *   xi points to [x0 x1 ... xn-1 ]
- *   y contains an array of pointers to 32-bit arrays of y values
- *   y contains [y0 y1 y2 ... yn-1]
- *   and each of the yi arrays contain [yi_0 yi_i ... yi_31].
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
  *
- * @param n - Number of points to interpolate
- * @param xi - x coordinates for points (array of length n)
- * @param yl - Length of y coordinate arrays
- * @param yij - Array of n arrays of length yl
- * @param x - Coordinate to interpolate at
- * @returns The interpolated result of length yl
  */
-declare function interpolate(n: number, xi: Uint8Array, yl: number, yij: Uint8Array[], x: number): Uint8Array;
-//#endregion
-//#region src/index.d.ts
 /**
  * The minimum length of a secret.
  */
@@ -175,5 +131,5 @@ declare const MAX_SECRET_LEN = 32;
  */
 declare const MAX_SHARE_COUNT = 16;
 //#endregion
-export { MAX_SECRET_LEN, MAX_SHARE_COUNT, MIN_SECRET_LEN, ShamirError, ShamirErrorType, type ShamirResult, bitslice, bitsliceSetall, gf256Add, gf256Inv, gf256Mul, gf256Square, interpolate, recoverSecret, splitSecret, unbitslice };
+export { MAX_SECRET_LEN, MAX_SHARE_COUNT, MIN_SECRET_LEN, ShamirError, ShamirErrorType, type ShamirResult, recoverSecret, splitSecret };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/error.ts","../src/shamir.ts","../src/hazmat.ts","../src/interpolate.ts","../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAKY,aAAA,eAAA;EAcC,aAAA,GAAY,eAAA;EACR,aAAA,GAAA,eAAA;EAEG,oBAAA,GAAA,sBAAA;EAHa,eAAA,GAAA,iBAAA;EAAK,cAAA,GAAA,gBAAA;EA+B1B,gBAAY,GAAA,kBAAO;;;;ACU/B;;;AAKG,cD9CU,WAAA,SAAoB,KAAA,CC8C9B;EAAU,SAAA,IAAA,ED7CI,eC6CJ;EAkFG,WAAA,CAAA,IAAa,ED7HT,eC6HqC,EAAA,OAAyB,CAAV,EAAA,MAAU;;;KDjGtE,kBAAkB;;;;;AA7C9B;AAcA;;;;;AA+BA;;;;ACUA;;;;;AAuFA;;;;ACvIA;AAyBA;AAyBA;AAsBA;AAoBA;;;;;AA6GgB,iBDzJA,WAAA,CCyJe,SAAgB,EAAA,MAAA,EAAW,UAAA,EAAA,MAAA,EAAA,MAAA,EDtJhD,UCsJgD,EAAA,eAAA,EDrJvC,qBCqJuC,CAAA,EDpJvD,UCoJuD,EAAA;AA+C1D;;;;AC3JA;;;;;;;;AC3FA;AAKA;AAKA;;;;;;;;;;;iBH2HgB,aAAA,4BAAyC,eAAe;;;;;;AD9IxE;AAcA;;;AAAiC,iBEPjB,QAAA,CFOiB,CAAA,EEPL,WFOK,EAAA,CAAA,EEPW,UFOX,CAAA,EAAA,IAAA;;AA+BjC;;;;ACUA;AAGU,iBC1BM,UAAA,CD0BN,CAAA,EC1BoB,UD0BpB,EAAA,CAAA,EC1BmC,WD0BnC,CAAA,EAAA,IAAA;;;;AAoFV;;;iBCrFgB,cAAA,IAAkB;AAlDlC;AAyBA;AAyBA;AAsBA;AAoBA;;;AAA4D,iBApB5C,QAAA,CAoB4C,CAAA,EApBhC,WAoBgC,EAAA,CAAA,EApBhB,WAoBgB,CAAA,EAAA,IAAA;;AA6G5D;AA+CA;;;;AC3JA;;;;AAMa,iBDPG,QAAA,CCOH,CAAA,EDPe,WCOf,EAAA,CAAA,EDP+B,WCO/B,EAAA,CAAA,EDP+C,WCO/C,CAAA,EAAA,IAAA;;;;ACjGb;AAKA;AAKA;;iBF6LgB,WAAA,IAAe,gBAAgB;;;;;;;iBA+C/B,QAAA,IAAY,gBAAgB;;;;;;AF/P5C;AAcA;;;;;AA+BA;;;;ACUA;;;;AAKa,iBEwCG,WAAA,CFxCH,CAAA,EAAA,MAAA,EAAA,EAAA,EE0CP,UF1CO,EAAA,EAAA,EAAA,MAAA,EAAA,GAAA,EE4CN,UF5CM,EAAA,EAAA,CAAA,EAAA,MAAA,CAAA,EE8CV,UF9CU;;;;;;AD5DD,cISC,cAAA,GJTc,EAAA;AAc3B;;;AAAiC,cIApB,cAAA,GJAoB,EAAA;;AA+BjC;;cI1Ba,eAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/error.ts","../src/shamir.ts","../src/index.ts"],"mappings":";;;;;;AAwBA;;;;;;;;;;;;;;AAiBA;;;;aAjBY,eAAA;EACV,aAAA;EACA,aAAA;EAeoC;;;EAXpC,oBAAA;EACA,eAAA;EACA,cAAA;EACA,gBAAA;EACA,gBAAA;EACA,mBAAA;AAAA;;AA6CF;;cAvCa,WAAA,SAAoB,KAAA;EAAA,SACtB,IAAA,EAAM,eAAA;cAEH,IAAA,EAAM,eAAA,EAAiB,OAAA;EAAA,eAMpB,cAAA;AAAA;;ACgBjB;;;;;;;KDcY,YAAA,MAAkB,CAAA;;;;;;;;;;;;;;AAvC9B;;;;;;;;;;;;;;;;;;AAuCA;iBCdgB,WAAA,CACd,SAAA,UACA,UAAA,UACA,MAAA,EAAQ,UAAA,EACR,eAAA,EAAiB,qBAAA,GAChB,UAAA;;;;;;;AALH;;;;;;;;;;;;;;;;;AAuFA;;iBAAgB,aAAA,CAAc,OAAA,YAAmB,MAAA,EAAQ,UAAA,KAAe,UAAA;;;;;;ADjIxE;;;;;cEJa,cAAA;;;;cAKA,cAAA;;;;cAKA,eAAA"}

package/dist/index.iife.js

@@ -1,20 +1,40 @@
-var BCShamir = (function(exports, __bcts_crypto) {
-
-
-//#region src/error.ts
-/**
+var bctsShamir = (function(exports, _bcts_crypto) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region src/error.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* Error types for Shamir secret sharing operations.
+	*
+	* Each variant mirrors a corresponding `Error::*` enum in
+	* `bc-shamir-rust/src/error.rs` with the same trigger conditions and the
+	* same default `Display` strings.
+	*
+	* Note on `InterpolationFailure`: this variant is **reserved but
+	* unreachable** in both the Rust and TypeScript implementations.
+	* `interpolate()` in `interpolate.ts` never actually returns / throws an
+	* interpolation failure today — the Lagrange-basis math always succeeds
+	* for any well-formed input. The variant is kept for forward
+	* compatibility (e.g. should a future revision add input validation that
+	* could reject pathological cases) and to keep the TS error type a 1:1
+	* mirror of Rust's `Error` enum.
 	*/
-	let ShamirErrorType = /* @__PURE__ */ function(ShamirErrorType$1) {
-		ShamirErrorType$1["SecretTooLong"] = "SecretTooLong";
-		ShamirErrorType$1["TooManyShares"] = "TooManyShares";
-		ShamirErrorType$1["InterpolationFailure"] = "InterpolationFailure";
-		ShamirErrorType$1["ChecksumFailure"] = "ChecksumFailure";
-		ShamirErrorType$1["SecretTooShort"] = "SecretTooShort";
-		ShamirErrorType$1["SecretNotEvenLen"] = "SecretNotEvenLen";
-		ShamirErrorType$1["InvalidThreshold"] = "InvalidThreshold";
-		ShamirErrorType$1["SharesUnequalLength"] = "SharesUnequalLength";
-		return ShamirErrorType$1;
+	let ShamirErrorType = /* @__PURE__ */ function(ShamirErrorType) {
+		ShamirErrorType["SecretTooLong"] = "SecretTooLong";
+		ShamirErrorType["TooManyShares"] = "TooManyShares";
+		/**
+		* Reserved / unreachable in both Rust and TS today. See enum doc above.
+		*/
+		ShamirErrorType["InterpolationFailure"] = "InterpolationFailure";
+		ShamirErrorType["ChecksumFailure"] = "ChecksumFailure";
+		ShamirErrorType["SecretTooShort"] = "SecretTooShort";
+		ShamirErrorType["SecretNotEvenLen"] = "SecretNotEvenLen";
+		ShamirErrorType["InvalidThreshold"] = "InvalidThreshold";
+		ShamirErrorType["SharesUnequalLength"] = "SharesUnequalLength";
+		return ShamirErrorType;
 	}({});
 	/**
 	* Error class for Shamir secret sharing operations.
@@ -28,21 +48,33 @@ var BCShamir = (function(exports, __bcts_crypto) {
 		}
 		static defaultMessage(type) {
 			switch (type) {
-				case ShamirErrorType.SecretTooLong: return "secret is too long";
-				case ShamirErrorType.TooManyShares: return "too many shares";
-				case ShamirErrorType.InterpolationFailure: return "interpolation failed";
-				case ShamirErrorType.ChecksumFailure: return "checksum failure";
-				case ShamirErrorType.SecretTooShort: return "secret is too short";
-				case ShamirErrorType.SecretNotEvenLen: return "secret is not of even length";
-				case ShamirErrorType.InvalidThreshold: return "invalid threshold";
-				case ShamirErrorType.SharesUnequalLength: return "shares have unequal length";
+				case "SecretTooLong": return "secret is too long";
+				case "TooManyShares": return "too many shares";
+				case "InterpolationFailure": return "interpolation failed";
+				case "ChecksumFailure": return "checksum failure";
+				case "SecretTooShort": return "secret is too short";
+				case "SecretNotEvenLen": return "secret is not of even length";
+				case "InvalidThreshold": return "invalid threshold";
+				case "SharesUnequalLength": return "shares have unequal length";
 			}
 		}
 	};
-
-//#endregion
-//#region src/hazmat.ts
-/**
+	//#endregion
+	//#region src/hazmat.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
+	* Internal contract guard. Mirrors a Rust `assert!(condition, message)`
+	* panic on the boundary between hazmat helpers — kept as a bare `Error`
+	* so it cannot be confused with a `ShamirError` from the public API.
+	*/
+	function assertContract(condition, message) {
+		if (!condition) throw new Error(message);
+	}
+	/**
 	* Convert an array of bytes into a bitsliced representation.
 	* Takes the first 32 bytes from x and produces 8 u32 values.
 	*
@@ -50,9 +82,9 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	* @param x - Input array of at least 32 bytes
 	*/
 	function bitslice(r, x) {
-		if (x.length < 32) throw new Error("bitslice: input must be at least 32 bytes");
-		if (r.length !== 8) throw new Error("bitslice: output must have 8 elements");
-		(0, __bcts_crypto.memzero)(r);
+		assertContract(x.length >= 32, "bitslice: input must be at least 32 bytes");
+		assertContract(r.length === 8, "bitslice: output must have 8 elements");
+		(0, _bcts_crypto.memzero)(r);
 		for (let arrIdx = 0; arrIdx < 32; arrIdx++) {
 			const cur = x[arrIdx];
 			for (let bitIdx = 0; bitIdx < 8; bitIdx++) r[bitIdx] |= (cur & 1 << bitIdx) >>> bitIdx << arrIdx;
@@ -65,9 +97,9 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	* @param x - Input array of 8 u32 values (bitsliced representation)
 	*/
 	function unbitslice(r, x) {
-		if (r.length < 32) throw new Error("unbitslice: output must be at least 32 bytes");
-		if (x.length !== 8) throw new Error("unbitslice: input must have 8 elements");
-		(0, __bcts_crypto.memzero)(r.subarray(0, 32));
+		assertContract(r.length >= 32, "unbitslice: output must be at least 32 bytes");
+		assertContract(x.length === 8, "unbitslice: input must have 8 elements");
+		(0, _bcts_crypto.memzero)(r.subarray(0, 32));
 		for (let bitIdx = 0; bitIdx < 8; bitIdx++) {
 			const cur = x[bitIdx];
 			for (let arrIdx = 0; arrIdx < 32; arrIdx++) r[arrIdx] |= (cur & 1 << arrIdx) >>> arrIdx << bitIdx;
@@ -80,7 +112,7 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	* @param x - Byte value to set in all positions
 	*/
 	function bitsliceSetall(r, x) {
-		if (r.length !== 8) throw new Error("bitsliceSetall: output must have 8 elements");
+		assertContract(r.length === 8, "bitsliceSetall: output must have 8 elements");
 		for (let idx = 0; idx < 8; idx++) r[idx] = (x >>> idx & 1) === 1 ? 4294967295 : 0;
 	}
 	/**
@@ -91,7 +123,7 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	* @param x - Second operand
 	*/
 	function gf256Add(r, x) {
-		if (r.length !== 8 || x.length !== 8) throw new Error("gf256Add: arrays must have 8 elements");
+		assertContract(r.length === 8 && x.length === 8, "gf256Add: arrays must have 8 elements");
 		for (let i = 0; i < 8; i++) r[i] ^= x[i];
 	}
 	/**
@@ -105,7 +137,7 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	* @param b - Second operand (must NOT overlap with r)
 	*/
 	function gf256Mul(r, a, b) {
-		if (r.length !== 8 || a.length !== 8 || b.length !== 8) throw new Error("gf256Mul: arrays must have 8 elements");
+		assertContract(r.length === 8 && a.length === 8 && b.length === 8, "gf256Mul: arrays must have 8 elements");
 		const a2 = new Uint32Array(a);
 		r[0] = a2[0] & b[0];
 		r[1] = a2[1] & b[0];
@@ -201,7 +233,7 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	* @param x - Value to square
 	*/
 	function gf256Square(r, x) {
-		if (r.length !== 8 || x.length !== 8) throw new Error("gf256Square: arrays must have 8 elements");
+		assertContract(r.length === 8 && x.length === 8, "gf256Square: arrays must have 8 elements");
 		const r14 = x[7];
 		const r12 = x[6];
 		let r10 = x[5];
@@ -237,7 +269,7 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	* @param x - Value to invert (will be modified)
 	*/
 	function gf256Inv(r, x) {
-		if (r.length !== 8 || x.length !== 8) throw new Error("gf256Inv: arrays must have 8 elements");
+		assertContract(r.length === 8 && x.length === 8, "gf256Inv: arrays must have 8 elements");
 		const y = new Uint32Array(8);
 		const z = new Uint32Array(8);
 		gf256Square(y, x);
@@ -252,10 +284,14 @@ var BCShamir = (function(exports, __bcts_crypto) {
 		gf256Mul(r, new Uint32Array(r), z);
 		gf256Mul(r, new Uint32Array(r), y);
 	}
-
-//#endregion
-//#region src/interpolate.ts
-/**
+	//#endregion
+	//#region src/interpolate.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* Calculate the lagrange basis coefficients for the lagrange polynomial
 	* defined by the x coordinates xc at the value x.
 	*
@@ -317,8 +353,8 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	*/
 	function interpolate(n, xi, yl, yij, x) {
 		const y = [];
-		for (let i = 0; i < n; i++) y.push(new Uint8Array(MAX_SECRET_LEN));
-		const values = new Uint8Array(MAX_SECRET_LEN);
+		for (let i = 0; i < n; i++) y.push(new Uint8Array(32));
+		const values = new Uint8Array(32);
 		for (let i = 0; i < n; i++) y[i].set(yij[i].subarray(0, yl), 0);
 		const lagrange = new Uint8Array(n);
 		const ySlice = new Uint32Array(8);
@@ -335,28 +371,32 @@ var BCShamir = (function(exports, __bcts_crypto) {
 		unbitslice(values, resultSlice);
 		const result = new Uint8Array(yl);
 		result.set(values.subarray(0, yl), 0);
-		(0, __bcts_crypto.memzero)(lagrange);
-		(0, __bcts_crypto.memzero)(ySlice);
-		(0, __bcts_crypto.memzero)(resultSlice);
-		(0, __bcts_crypto.memzero)(temp);
-		(0, __bcts_crypto.memzeroVecVecU8)(y);
-		(0, __bcts_crypto.memzero)(values);
+		(0, _bcts_crypto.memzero)(lagrange);
+		(0, _bcts_crypto.memzero)(ySlice);
+		(0, _bcts_crypto.memzero)(resultSlice);
+		(0, _bcts_crypto.memzero)(temp);
+		(0, _bcts_crypto.memzeroVecVecU8)(y);
+		(0, _bcts_crypto.memzero)(values);
 		return result;
 	}
-
-//#endregion
-//#region src/shamir.ts
+	//#endregion
+	//#region src/shamir.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
 	const SECRET_INDEX = 255;
 	const DIGEST_INDEX = 254;
 	function createDigest(randomData, sharedSecret) {
-		return (0, __bcts_crypto.hmacSha256)(randomData, sharedSecret);
+		return (0, _bcts_crypto.hmacSha256)(randomData, sharedSecret);
 	}
 	function validateParameters(threshold, shareCount, secretLength) {
-		if (shareCount > MAX_SHARE_COUNT) throw new ShamirError(ShamirErrorType.TooManyShares);
-		else if (threshold < 1 || threshold > shareCount) throw new ShamirError(ShamirErrorType.InvalidThreshold);
-		else if (secretLength > MAX_SECRET_LEN) throw new ShamirError(ShamirErrorType.SecretTooLong);
-		else if (secretLength < MIN_SECRET_LEN) throw new ShamirError(ShamirErrorType.SecretTooShort);
-		else if ((secretLength & 1) !== 0) throw new ShamirError(ShamirErrorType.SecretNotEvenLen);
+		if (shareCount > 16) throw new ShamirError("TooManyShares");
+		else if (threshold < 1 || threshold > shareCount) throw new ShamirError("InvalidThreshold");
+		else if (secretLength > 32) throw new ShamirError("SecretTooLong");
+		else if (secretLength < 16) throw new ShamirError("SecretTooShort");
+		else if ((secretLength & 1) !== 0) throw new ShamirError("SecretNotEvenLen");
 	}
 	/**
 	* Splits a secret into shares using the Shamir secret sharing algorithm.
@@ -421,9 +461,9 @@ var BCShamir = (function(exports, __bcts_crypto) {
 				const v = interpolate(n, x, secret.length, y, index);
 				result[index].set(v);
 			}
-			(0, __bcts_crypto.memzero)(digest);
-			(0, __bcts_crypto.memzero)(x);
-			(0, __bcts_crypto.memzeroVecVecU8)(y);
+			(0, _bcts_crypto.memzero)(digest);
+			(0, _bcts_crypto.memzero)(x);
+			(0, _bcts_crypto.memzeroVecVecU8)(y);
 			return result;
 		}
 	}
@@ -454,10 +494,10 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	*/
 	function recoverSecret(indexes, shares) {
 		const threshold = shares.length;
-		if (threshold === 0 || indexes.length !== threshold) throw new ShamirError(ShamirErrorType.InvalidThreshold);
+		if (threshold === 0 || indexes.length !== threshold) throw new ShamirError("InvalidThreshold");
 		const shareLength = shares[0].length;
 		validateParameters(threshold, threshold, shareLength);
-		if (!shares.every((share) => share.length === shareLength)) throw new ShamirError(ShamirErrorType.SharesUnequalLength);
+		if (!shares.every((share) => share.length === shareLength)) throw new ShamirError("SharesUnequalLength");
 		if (threshold === 1) return new Uint8Array(shares[0]);
 		else {
 			const indexesU8 = new Uint8Array(indexes);
@@ -466,16 +506,20 @@ var BCShamir = (function(exports, __bcts_crypto) {
 			const verify = createDigest(digest.subarray(4), secret);
 			let valid = true;
 			for (let i = 0; i < 4; i++) valid = valid && digest[i] === verify[i];
-			(0, __bcts_crypto.memzero)(digest);
-			(0, __bcts_crypto.memzero)(verify);
-			if (!valid) throw new ShamirError(ShamirErrorType.ChecksumFailure);
+			(0, _bcts_crypto.memzero)(digest);
+			(0, _bcts_crypto.memzero)(verify);
+			if (!valid) throw new ShamirError("ChecksumFailure");
 			return secret;
 		}
 	}
-
-//#endregion
-//#region src/index.ts
-/**
+	//#endregion
+	//#region src/index.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* The minimum length of a secret.
 	*/
 	const MIN_SECRET_LEN = 16;
@@ -487,23 +531,15 @@ var BCShamir = (function(exports, __bcts_crypto) {
 	* The maximum number of shares that can be generated from a secret.
 	*/
 	const MAX_SHARE_COUNT = 16;
+	//#endregion
+	exports.MAX_SECRET_LEN = MAX_SECRET_LEN;
+	exports.MAX_SHARE_COUNT = MAX_SHARE_COUNT;
+	exports.MIN_SECRET_LEN = MIN_SECRET_LEN;
+	exports.ShamirError = ShamirError;
+	exports.ShamirErrorType = ShamirErrorType;
+	exports.recoverSecret = recoverSecret;
+	exports.splitSecret = splitSecret;
+	return exports;
+})({}, bctsCrypto);
 
-//#endregion
-exports.MAX_SECRET_LEN = MAX_SECRET_LEN;
-exports.MAX_SHARE_COUNT = MAX_SHARE_COUNT;
-exports.MIN_SECRET_LEN = MIN_SECRET_LEN;
-exports.ShamirError = ShamirError;
-exports.ShamirErrorType = ShamirErrorType;
-exports.bitslice = bitslice;
-exports.bitsliceSetall = bitsliceSetall;
-exports.gf256Add = gf256Add;
-exports.gf256Inv = gf256Inv;
-exports.gf256Mul = gf256Mul;
-exports.gf256Square = gf256Square;
-exports.interpolate = interpolate;
-exports.recoverSecret = recoverSecret;
-exports.splitSecret = splitSecret;
-exports.unbitslice = unbitslice;
-return exports;
-})({}, BCCrypto);
 //# sourceMappingURL=index.iife.js.map