@mysten/seal 0.4.11 → 0.4.13

package/dist/cjs/shamir.js

@@ -0,0 +1,766 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var shamir_exports = {};
+__export(shamir_exports, {
+  GF256: () => GF256,
+  Polynomial: () => Polynomial,
+  combine: () => combine,
+  interpolate: () => interpolate,
+  split: () => split
+});
+module.exports = __toCommonJS(shamir_exports);
+var import_utils = require("./utils.js");
+const GF256_SIZE = 256;
+class GF256 {
+  constructor(value) {
+    if (value < 0 || value >= GF256_SIZE) {
+      throw new Error(`Invalid value ${value} for GF256`);
+    }
+    this.value = value;
+  }
+  log() {
+    if (this.value === 0) {
+      throw new Error("Invalid value");
+    }
+    return LOG[this.value - 1];
+  }
+  static exp(x) {
+    return new GF256(EXP[x % (GF256_SIZE - 1)]);
+  }
+  add(other) {
+    return new GF256(this.value ^ other.value);
+  }
+  sub(other) {
+    return this.add(other);
+  }
+  neg() {
+    return this;
+  }
+  mul(other) {
+    if (this.value === 0 || other.value === 0) {
+      return new GF256(0);
+    }
+    return GF256.exp(this.log() + other.log());
+  }
+  div(other) {
+    return this.mul(GF256.exp(GF256_SIZE - other.log() - 1));
+  }
+  equals(other) {
+    return this.value === other.value;
+  }
+  static zero() {
+    return new GF256(0);
+  }
+  static one() {
+    return new GF256(1);
+  }
+}
+const EXP = [
+  1,
+  3,
+  5,
+  15,
+  17,
+  51,
+  85,
+  255,
+  26,
+  46,
+  114,
+  150,
+  161,
+  248,
+  19,
+  53,
+  95,
+  225,
+  56,
+  72,
+  216,
+  115,
+  149,
+  164,
+  247,
+  2,
+  6,
+  10,
+  30,
+  34,
+  102,
+  170,
+  229,
+  52,
+  92,
+  228,
+  55,
+  89,
+  235,
+  38,
+  106,
+  190,
+  217,
+  112,
+  144,
+  171,
+  230,
+  49,
+  83,
+  245,
+  4,
+  12,
+  20,
+  60,
+  68,
+  204,
+  79,
+  209,
+  104,
+  184,
+  211,
+  110,
+  178,
+  205,
+  76,
+  212,
+  103,
+  169,
+  224,
+  59,
+  77,
+  215,
+  98,
+  166,
+  241,
+  8,
+  24,
+  40,
+  120,
+  136,
+  131,
+  158,
+  185,
+  208,
+  107,
+  189,
+  220,
+  127,
+  129,
+  152,
+  179,
+  206,
+  73,
+  219,
+  118,
+  154,
+  181,
+  196,
+  87,
+  249,
+  16,
+  48,
+  80,
+  240,
+  11,
+  29,
+  39,
+  105,
+  187,
+  214,
+  97,
+  163,
+  254,
+  25,
+  43,
+  125,
+  135,
+  146,
+  173,
+  236,
+  47,
+  113,
+  147,
+  174,
+  233,
+  32,
+  96,
+  160,
+  251,
+  22,
+  58,
+  78,
+  210,
+  109,
+  183,
+  194,
+  93,
+  231,
+  50,
+  86,
+  250,
+  21,
+  63,
+  65,
+  195,
+  94,
+  226,
+  61,
+  71,
+  201,
+  64,
+  192,
+  91,
+  237,
+  44,
+  116,
+  156,
+  191,
+  218,
+  117,
+  159,
+  186,
+  213,
+  100,
+  172,
+  239,
+  42,
+  126,
+  130,
+  157,
+  188,
+  223,
+  122,
+  142,
+  137,
+  128,
+  155,
+  182,
+  193,
+  88,
+  232,
+  35,
+  101,
+  175,
+  234,
+  37,
+  111,
+  177,
+  200,
+  67,
+  197,
+  84,
+  252,
+  31,
+  33,
+  99,
+  165,
+  244,
+  7,
+  9,
+  27,
+  45,
+  119,
+  153,
+  176,
+  203,
+  70,
+  202,
+  69,
+  207,
+  74,
+  222,
+  121,
+  139,
+  134,
+  145,
+  168,
+  227,
+  62,
+  66,
+  198,
+  81,
+  243,
+  14,
+  18,
+  54,
+  90,
+  238,
+  41,
+  123,
+  141,
+  140,
+  143,
+  138,
+  133,
+  148,
+  167,
+  242,
+  13,
+  23,
+  57,
+  75,
+  221,
+  124,
+  132,
+  151,
+  162,
+  253,
+  28,
+  36,
+  108,
+  180,
+  199,
+  82,
+  246
+];
+const LOG = [
+  0,
+  25,
+  1,
+  50,
+  2,
+  26,
+  198,
+  75,
+  199,
+  27,
+  104,
+  51,
+  238,
+  223,
+  3,
+  100,
+  4,
+  224,
+  14,
+  52,
+  141,
+  129,
+  239,
+  76,
+  113,
+  8,
+  200,
+  248,
+  105,
+  28,
+  193,
+  125,
+  194,
+  29,
+  181,
+  249,
+  185,
+  39,
+  106,
+  77,
+  228,
+  166,
+  114,
+  154,
+  201,
+  9,
+  120,
+  101,
+  47,
+  138,
+  5,
+  33,
+  15,
+  225,
+  36,
+  18,
+  240,
+  130,
+  69,
+  53,
+  147,
+  218,
+  142,
+  150,
+  143,
+  219,
+  189,
+  54,
+  208,
+  206,
+  148,
+  19,
+  92,
+  210,
+  241,
+  64,
+  70,
+  131,
+  56,
+  102,
+  221,
+  253,
+  48,
+  191,
+  6,
+  139,
+  98,
+  179,
+  37,
+  226,
+  152,
+  34,
+  136,
+  145,
+  16,
+  126,
+  110,
+  72,
+  195,
+  163,
+  182,
+  30,
+  66,
+  58,
+  107,
+  40,
+  84,
+  250,
+  133,
+  61,
+  186,
+  43,
+  121,
+  10,
+  21,
+  155,
+  159,
+  94,
+  202,
+  78,
+  212,
+  172,
+  229,
+  243,
+  115,
+  167,
+  87,
+  175,
+  88,
+  168,
+  80,
+  244,
+  234,
+  214,
+  116,
+  79,
+  174,
+  233,
+  213,
+  231,
+  230,
+  173,
+  232,
+  44,
+  215,
+  117,
+  122,
+  235,
+  22,
+  11,
+  245,
+  89,
+  203,
+  95,
+  176,
+  156,
+  169,
+  81,
+  160,
+  127,
+  12,
+  246,
+  111,
+  23,
+  196,
+  73,
+  236,
+  216,
+  67,
+  31,
+  45,
+  164,
+  118,
+  123,
+  183,
+  204,
+  187,
+  62,
+  90,
+  251,
+  96,
+  177,
+  134,
+  59,
+  82,
+  161,
+  108,
+  170,
+  85,
+  41,
+  157,
+  151,
+  178,
+  135,
+  144,
+  97,
+  190,
+  220,
+  252,
+  188,
+  149,
+  207,
+  205,
+  55,
+  63,
+  91,
+  209,
+  83,
+  57,
+  132,
+  60,
+  65,
+  162,
+  109,
+  71,
+  20,
+  42,
+  158,
+  93,
+  86,
+  242,
+  211,
+  171,
+  68,
+  17,
+  146,
+  217,
+  35,
+  32,
+  46,
+  137,
+  180,
+  124,
+  184,
+  38,
+  119,
+  153,
+  227,
+  165,
+  103,
+  74,
+  237,
+  222,
+  197,
+  49,
+  254,
+  24,
+  13,
+  99,
+  140,
+  128,
+  192,
+  247,
+  112,
+  7
+];
+class Polynomial {
+  /**
+   * Construct a new Polynomial over [GF256] from the given coefficients.
+   * The first coefficient is the constant term.
+   */
+  constructor(coefficients) {
+    this.coefficients = coefficients.slice();
+    while (this.coefficients.length > 0 && this.coefficients[this.coefficients.length - 1].value === 0) {
+      this.coefficients.pop();
+    }
+  }
+  static fromBytes(bytes) {
+    return new Polynomial(Array.from(bytes, (b) => new GF256(b)));
+  }
+  degree() {
+    if (this.coefficients.length === 0) {
+      return 0;
+    }
+    return this.coefficients.length - 1;
+  }
+  getCoefficient(index) {
+    if (index >= this.coefficients.length) {
+      return GF256.zero();
+    }
+    return this.coefficients[index];
+  }
+  add(other) {
+    const degree = Math.max(this.degree(), other.degree());
+    return new Polynomial(
+      Array.from(
+        { length: degree + 1 },
+        (_, i) => this.getCoefficient(i).add(other.getCoefficient(i))
+      )
+    );
+  }
+  mul(other) {
+    const degree = this.degree() + other.degree();
+    return new Polynomial(
+      Array.from({ length: degree + 1 }, (_, i) => {
+        let sum = GF256.zero();
+        for (let j = 0; j <= i; j++) {
+          if (j <= this.degree() && i - j <= other.degree()) {
+            sum = sum.add(this.coefficients[j].mul(other.coefficients[i - j]));
+          }
+        }
+        return sum;
+      })
+    );
+  }
+  /** The polynomial s * this. */
+  scale(s) {
+    return new Polynomial(this.coefficients.map((c) => c.mul(s)));
+  }
+  div(s) {
+    return this.scale(new GF256(1).div(s));
+  }
+  /** The polynomial x + c. */
+  static monic_linear(c) {
+    return new Polynomial([c, GF256.one()]);
+  }
+  static zero() {
+    return new Polynomial([]);
+  }
+  static one() {
+    return new Polynomial([GF256.one()]);
+  }
+  /** Given a set of coordinates, interpolate a polynomial. */
+  static interpolate(coordinates) {
+    if (coordinates.length < 1) {
+      throw new Error("At least one coefficient is required");
+    }
+    if ((0, import_utils.hasDuplicates)(coordinates.map(({ x }) => x.value))) {
+      throw new Error("Coefficients must have unique x values");
+    }
+    return coordinates.reduce(
+      (sum, { x: x_j, y: y_j }, j) => sum.add(
+        coordinates.filter((_, i) => i !== j).reduce(
+          (product, { x: x_i }) => product.mul(Polynomial.monic_linear(x_i.neg()).div(x_j.sub(x_i))),
+          Polynomial.one()
+        ).scale(y_j)
+      ),
+      Polynomial.zero()
+    );
+  }
+  /** Given a set of coordinates, interpolate a polynomial and evaluate it at x = 0. */
+  static combine(coordinates) {
+    if (coordinates.length < 1) {
+      throw new Error("At least one coefficient is required");
+    }
+    if ((0, import_utils.hasDuplicates)(coordinates.map(({ x }) => x.value))) {
+      throw new Error("Coefficients must have unique x values");
+    }
+    const quotient = coordinates.reduce((sum, { x: x_j, y: y_j }, j) => {
+      const denominator = x_j.mul(
+        coordinates.filter((_, i) => i !== j).reduce((product, { x: x_i }) => product.mul(x_i.sub(x_j)), GF256.one())
+      );
+      return sum.add(y_j.div(denominator));
+    }, GF256.zero());
+    const xProduct = coordinates.reduce((product, { x }) => product.mul(x), GF256.one());
+    return xProduct.mul(quotient);
+  }
+  /** Evaluate the polynomial at x. */
+  evaluate(x) {
+    return this.coefficients.toReversed().reduce((sum, coefficient) => sum.mul(x).add(coefficient), GF256.zero());
+  }
+  equals(other) {
+    if (this.degree() !== other.degree()) {
+      return false;
+    }
+    return this.coefficients.every((c, i) => c.equals(other.coefficients[i]));
+  }
+}
+function toInternalShare(share) {
+  return {
+    index: new GF256(share.index),
+    share: Array.from(share.share, (byte) => new GF256(byte))
+  };
+}
+function toShare(internalShare) {
+  return {
+    index: internalShare.index.value,
+    share: new Uint8Array(internalShare.share.map((byte) => byte.value))
+  };
+}
+function samplePolynomial(constant, degree) {
+  const randomCoefficients = new Uint8Array(degree);
+  crypto.getRandomValues(randomCoefficients);
+  return Polynomial.fromBytes(new Uint8Array([constant.value, ...randomCoefficients]));
+}
+function split(secret, threshold, total) {
+  if (threshold > total || threshold < 1 || total > GF256_SIZE) {
+    throw new Error(`Invalid threshold ${threshold} or total ${total}`);
+  }
+  const polynomials = Array.from(secret, (s) => samplePolynomial(new GF256(s), threshold - 1));
+  return Array.from({ length: total }, (_, i) => {
+    const index = new GF256(i + 1);
+    const share = polynomials.map((p) => p.evaluate(index));
+    return toShare({ index, share });
+  });
+}
+function validateShares(shares) {
+  if (shares.length < 1) {
+    throw new Error("At least one share is required");
+  }
+  if (!(0, import_utils.allEqual)(shares.map(({ share }) => share.length))) {
+    throw new Error("All shares must have the same length");
+  }
+  if ((0, import_utils.hasDuplicates)(shares.map(({ index }) => index))) {
+    throw new Error("Shares must have unique indices");
+  }
+  const internalShares = shares.map(toInternalShare);
+  const length = internalShares[0].share.length;
+  return { internalShares, length };
+}
+function combine(shares) {
+  const { internalShares, length } = validateShares(shares);
+  return new Uint8Array(
+    Array.from(
+      { length },
+      (_, i) => Polynomial.combine(
+        internalShares.map(({ index, share }) => ({
+          x: index,
+          y: share[i]
+        }))
+      ).value
+    )
+  );
+}
+function interpolate(shares) {
+  const { internalShares, length } = validateShares(shares);
+  const polynomials = Array.from(
+    { length },
+    (_, i) => Polynomial.interpolate(internalShares.map(({ index, share }) => ({ x: index, y: share[i] })))
+  );
+  return (x) => {
+    return new Uint8Array(polynomials.map((p) => p.evaluate(new GF256(x)).value));
+  };
+}
+//# sourceMappingURL=shamir.js.map