@mysten/seal 0.10.0 → 1.0.0

package/dist/esm/dem.js

@@ -1,165 +0,0 @@
-import { bcs } from "@mysten/bcs";
-import { equalBytes } from "@noble/curves/abstract/utils";
-import { hmac } from "@noble/hashes/hmac";
-import { sha3_256 } from "@noble/hashes/sha3";
-import { DecryptionError, InvalidCiphertextError } from "./error.js";
-import { flatten, xorUnchecked } from "./utils.js";
-const iv = Uint8Array.from([
-  138,
-  55,
-  153,
-  253,
-  198,
-  46,
-  121,
-  219,
-  160,
-  128,
-  89,
-  7,
-  214,
-  156,
-  148,
-  220
-]);
-async function generateAesKey() {
-  const key = await crypto.subtle.generateKey(
-    {
-      name: "AES-GCM",
-      length: 256
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-  return await crypto.subtle.exportKey("raw", key).then((keyData) => new Uint8Array(keyData));
-}
-class AesGcm256 {
-  constructor(msg, aad) {
-    this.plaintext = msg;
-    this.aad = aad;
-  }
-  generateKey() {
-    return generateAesKey();
-  }
-  async encrypt(key) {
-    if (key.length !== 32) {
-      throw new Error("Key must be 32 bytes");
-    }
-    const aesCryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key,
-      "AES-GCM",
-      false,
-      ["encrypt"]
-    );
-    const blob = new Uint8Array(
-      await crypto.subtle.encrypt(
-        {
-          name: "AES-GCM",
-          iv,
-          additionalData: this.aad
-        },
-        aesCryptoKey,
-        this.plaintext
-      )
-    );
-    return {
-      Aes256Gcm: {
-        blob,
-        aad: this.aad ?? []
-      }
-    };
-  }
-  static async decrypt(key, ciphertext) {
-    if (!("Aes256Gcm" in ciphertext)) {
-      throw new InvalidCiphertextError(`Invalid ciphertext ${JSON.stringify(ciphertext)}`);
-    }
-    if (key.length !== 32) {
-      throw new Error("Key must be 32 bytes");
-    }
-    try {
-      const aesCryptoKey = await crypto.subtle.importKey(
-        "raw",
-        key,
-        "AES-GCM",
-        false,
-        ["decrypt"]
-      );
-      return new Uint8Array(
-        await crypto.subtle.decrypt(
-          {
-            name: "AES-GCM",
-            iv,
-            additionalData: new Uint8Array(ciphertext.Aes256Gcm.aad ?? [])
-          },
-          aesCryptoKey,
-          new Uint8Array(ciphertext.Aes256Gcm.blob)
-        )
-      );
-    } catch {
-      throw new DecryptionError(`Decryption failed`);
-    }
-  }
-}
-class Hmac256Ctr {
-  constructor(msg, aad) {
-    this.plaintext = msg;
-    this.aad = aad;
-  }
-  generateKey() {
-    return generateAesKey();
-  }
-  async encrypt(key) {
-    const blob = Hmac256Ctr.encryptInCtrMode(key, this.plaintext);
-    const mac = Hmac256Ctr.computeMac(key, this.aad, blob);
-    return {
-      Hmac256Ctr: {
-        blob,
-        mac,
-        aad: this.aad ?? []
-      }
-    };
-  }
-  static async decrypt(key, ciphertext) {
-    if (!("Hmac256Ctr" in ciphertext)) {
-      throw new InvalidCiphertextError(`Invalid ciphertext ${JSON.stringify(ciphertext)}`);
-    }
-    if (key.length !== 32) {
-      throw new Error("Key must be 32 bytes");
-    }
-    const aad = new Uint8Array(ciphertext.Hmac256Ctr.aad ?? []);
-    const blob = new Uint8Array(ciphertext.Hmac256Ctr.blob);
-    const mac = Hmac256Ctr.computeMac(key, aad, blob);
-    if (!equalBytes(mac, new Uint8Array(ciphertext.Hmac256Ctr.mac))) {
-      throw new DecryptionError(`Invalid MAC ${mac}`);
-    }
-    return Hmac256Ctr.encryptInCtrMode(key, blob);
-  }
-  static computeMac(key, aad, ciphertext) {
-    const macInput = flatten([MacKeyTag, toBytes(aad.length), aad, ciphertext]);
-    const mac = hmac(sha3_256, key, macInput);
-    return mac;
-  }
-  static encryptInCtrMode(key, msg) {
-    const blockSize = 32;
-    const result = new Uint8Array(msg.length);
-    for (let i = 0; i * blockSize < msg.length; i++) {
-      const block = msg.subarray(i * blockSize, (i + 1) * blockSize);
-      const mask = hmac(sha3_256, key, flatten([EncryptionKeyTag, toBytes(i)]));
-      const encryptedBlock = xorUnchecked(block, mask);
-      result.set(encryptedBlock, i * blockSize);
-    }
-    return result;
-  }
-}
-function toBytes(n) {
-  return bcs.u64().serialize(n).toBytes();
-}
-const EncryptionKeyTag = new TextEncoder().encode("HMAC-CTR-ENC");
-const MacKeyTag = new TextEncoder().encode("HMAC-CTR-MAC");
-export {
-  AesGcm256,
-  Hmac256Ctr,
-  iv
-};
-//# sourceMappingURL=dem.js.map

package/dist/esm/dem.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/dem.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bcs } from '@mysten/bcs';\nimport { equalBytes } from '@noble/curves/abstract/utils';\nimport { hmac } from '@noble/hashes/hmac';\nimport { sha3_256 } from '@noble/hashes/sha3';\n\nimport type { Ciphertext } from './bcs.js';\nimport { DecryptionError, InvalidCiphertextError } from './error.js';\nimport { flatten, xorUnchecked } from './utils.js';\n\n// Use a fixed IV for AES. This is okay because the key is unique for each message.\nexport const iv = Uint8Array.from([\n\t138, 55, 153, 253, 198, 46, 121, 219, 160, 128, 89, 7, 214, 156, 148, 220,\n]);\n\nasync function generateAesKey(): Promise<Uint8Array<ArrayBuffer>> {\n\tconst key = await crypto.subtle.generateKey(\n\t\t{\n\t\t\tname: 'AES-GCM',\n\t\t\tlength: 256,\n\t\t},\n\t\ttrue,\n\t\t['encrypt', 'decrypt'],\n\t);\n\treturn await crypto.subtle.exportKey('raw', key).then((keyData) => new Uint8Array(keyData));\n}\n\n/**\n * An interface for supported DEMs.\n */\nexport interface EncryptionInput {\n\tencrypt(key: Uint8Array): Promise<typeof Ciphertext.$inferInput>;\n\tgenerateKey(): Promise<Uint8Array<ArrayBuffer>>;\n}\n\n/**\n * AES-GCM encryption.\n */\nexport class AesGcm256 implements EncryptionInput {\n\treadonly plaintext: Uint8Array<ArrayBuffer>;\n\treadonly aad: Uint8Array<ArrayBuffer>;\n\n\tconstructor(msg: Uint8Array<ArrayBuffer>, aad: Uint8Array<ArrayBuffer>) {\n\t\tthis.plaintext = msg;\n\t\tthis.aad = aad;\n\t}\n\n\tgenerateKey(): Promise<Uint8Array<ArrayBuffer>> {\n\t\t// generate a random key\n\t\treturn generateAesKey();\n\t}\n\n\tasync encrypt(key: Uint8Array): Promise<typeof Ciphertext.$inferInput> {\n\t\tif (key.length !== 32) {\n\t\t\tthrow new Error('Key must be 32 bytes');\n\t\t}\n\t\tconst aesCryptoKey = await crypto.subtle.importKey(\n\t\t\t'raw',\n\t\t\tkey as BufferSource,\n\t\t\t'AES-GCM',\n\t\t\tfalse,\n\t\t\t['encrypt'],\n\t\t);\n\n\t\tconst blob = new Uint8Array(\n\t\t\tawait crypto.subtle.encrypt(\n\t\t\t\t{\n\t\t\t\t\tname: 'AES-GCM',\n\t\t\t\t\tiv,\n\t\t\t\t\tadditionalData: this.aad as BufferSource,\n\t\t\t\t},\n\t\t\t\taesCryptoKey,\n\t\t\t\tthis.plaintext as BufferSource,\n\t\t\t),\n\t\t);\n\n\t\treturn {\n\t\t\tAes256Gcm: {\n\t\t\t\tblob,\n\t\t\t\taad: this.aad ?? [],\n\t\t\t},\n\t\t};\n\t}\n\n\tstatic async decrypt(\n\t\tkey: Uint8Array,\n\t\tciphertext: typeof Ciphertext.$inferInput,\n\t): Promise<Uint8Array> {\n\t\tif (!('Aes256Gcm' in ciphertext)) {\n\t\t\tthrow new InvalidCiphertextError(`Invalid ciphertext ${JSON.stringify(ciphertext)}`);\n\t\t}\n\t\tif (key.length !== 32) {\n\t\t\tthrow new Error('Key must be 32 bytes');\n\t\t}\n\n\t\ttry {\n\t\t\tconst aesCryptoKey = await crypto.subtle.importKey(\n\t\t\t\t'raw',\n\t\t\t\tkey as BufferSource,\n\t\t\t\t'AES-GCM',\n\t\t\t\tfalse,\n\t\t\t\t['decrypt'],\n\t\t\t);\n\t\t\treturn new Uint8Array(\n\t\t\t\tawait crypto.subtle.decrypt(\n\t\t\t\t\t{\n\t\t\t\t\t\tname: 'AES-GCM',\n\t\t\t\t\t\tiv,\n\t\t\t\t\t\tadditionalData: new Uint8Array(ciphertext.Aes256Gcm.aad ?? []),\n\t\t\t\t\t},\n\t\t\t\t\taesCryptoKey,\n\t\t\t\t\tnew Uint8Array(ciphertext.Aes256Gcm.blob),\n\t\t\t\t),\n\t\t\t);\n\t\t} catch {\n\t\t\tthrow new DecryptionError(`Decryption failed`);\n\t\t}\n\t}\n}\n\n/**\n * Authenticated encryption using CTR mode with HMAC-SHA3-256 as a PRF.\n * 1. Derive an encryption key, <i>k<sub>1</sub> = <b>hmac</b>(key, 1)</i>.\n * 2. Chunk the message into blocks of 32 bytes, <i>m = m<sub>1</sub> || ... || m<sub>n</sub></i>.\n * 3. Let the ciphertext be defined by <i>c = c<sub>1</sub> || ... || c<sub>n</sub></i> where <i>c<sub>i</sub> = m<sub>i</sub> \u2295 <b>hmac</b>(k<sub>1</sub>, i)</i>.\n * 4. Compute a MAC over the AAD and the ciphertext, <i>mac = <b>hmac</b>(k<sub>2</sub>, aad || c) where k<sub>2</sub> = <b>hmac</b>(key, 2)</i>.\n * 5. Return <i>mac || aad || c</i>.\n */\nexport class Hmac256Ctr implements EncryptionInput {\n\treadonly plaintext: Uint8Array<ArrayBuffer>;\n\treadonly aad: Uint8Array<ArrayBuffer>;\n\n\tconstructor(msg: Uint8Array<ArrayBuffer>, aad: Uint8Array<ArrayBuffer>) {\n\t\tthis.plaintext = msg;\n\t\tthis.aad = aad;\n\t}\n\n\tgenerateKey(): Promise<Uint8Array<ArrayBuffer>> {\n\t\t// generate a random key\n\t\treturn generateAesKey();\n\t}\n\n\tasync encrypt(key: Uint8Array): Promise<typeof Ciphertext.$inferInput> {\n\t\tconst blob = Hmac256Ctr.encryptInCtrMode(key, this.plaintext);\n\t\tconst mac = Hmac256Ctr.computeMac(key, this.aad, blob);\n\t\treturn {\n\t\t\tHmac256Ctr: {\n\t\t\t\tblob,\n\t\t\t\tmac,\n\t\t\t\taad: this.aad ?? [],\n\t\t\t},\n\t\t};\n\t}\n\n\tstatic async decrypt(\n\t\tkey: Uint8Array,\n\t\tciphertext: typeof Ciphertext.$inferInput,\n\t): Promise<Uint8Array> {\n\t\tif (!('Hmac256Ctr' in ciphertext)) {\n\t\t\tthrow new InvalidCiphertextError(`Invalid ciphertext ${JSON.stringify(ciphertext)}`);\n\t\t}\n\t\tif (key.length !== 32) {\n\t\t\tthrow new Error('Key must be 32 bytes');\n\t\t}\n\t\tconst aad = new Uint8Array(ciphertext.Hmac256Ctr.aad ?? []);\n\t\tconst blob = new Uint8Array(ciphertext.Hmac256Ctr.blob);\n\t\tconst mac = Hmac256Ctr.computeMac(key, aad, blob);\n\t\tif (!equalBytes(mac, new Uint8Array(ciphertext.Hmac256Ctr.mac))) {\n\t\t\tthrow new DecryptionError(`Invalid MAC ${mac}`);\n\t\t}\n\t\treturn Hmac256Ctr.encryptInCtrMode(key, blob);\n\t}\n\n\tprivate static computeMac(key: Uint8Array, aad: Uint8Array, ciphertext: Uint8Array): Uint8Array {\n\t\tconst macInput = flatten([MacKeyTag, toBytes(aad.length), aad, ciphertext]);\n\t\tconst mac = hmac(sha3_256, key, macInput);\n\t\treturn mac;\n\t}\n\n\tprivate static encryptInCtrMode(key: Uint8Array, msg: Uint8Array): Uint8Array {\n\t\tconst blockSize = 32;\n\t\tconst result = new Uint8Array(msg.length);\n\t\tfor (let i = 0; i * blockSize < msg.length; i++) {\n\t\t\tconst block = msg.subarray(i * blockSize, (i + 1) * blockSize);\n\t\t\tconst mask = hmac(sha3_256, key, flatten([EncryptionKeyTag, toBytes(i)]));\n\t\t\tconst encryptedBlock = xorUnchecked(block, mask);\n\t\t\tresult.set(encryptedBlock, i * blockSize);\n\t\t}\n\t\treturn result;\n\t}\n}\n\n/**\n * Convert a u64 to bytes using little-endian representation.\n */\nfunction toBytes(n: number): Uint8Array {\n\treturn bcs.u64().serialize(n).toBytes();\n}\n\nconst EncryptionKeyTag = new TextEncoder().encode('HMAC-CTR-ENC');\nconst MacKeyTag = new TextEncoder().encode('HMAC-CTR-MAC');\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/esm/elgamal.d.ts

@@ -1,13 +0,0 @@
-/**
- * Decrypt a ciphertext with a given secret key. The secret key must be a 32-byte scalar.
- * The ciphertext is a pair of G1Elements (48 bytes).
- *
- * Throws an error if the secret key is not a valid scalar or if the ciphertext elements are not valid G1 points.
- */
-export declare function elgamalDecrypt(sk: Uint8Array, [c0, c1]: [Uint8Array, Uint8Array]): Uint8Array;
-/** Generate a random secret key. */
-export declare function generateSecretKey(): Uint8Array<ArrayBuffer>;
-/** Derive the BLS public key for a given secret key. */
-export declare function toPublicKey(sk: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
-/** Derive the BLS verification key for a given secret key. */
-export declare function toVerificationKey(sk: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;

package/dist/esm/elgamal.js

@@ -1,26 +0,0 @@
-import { G1Element, G2Element, Scalar } from "./bls12381.js";
-function elgamalDecrypt(sk, [c0, c1]) {
-  return decrypt(Scalar.fromBytes(sk), [
-    G1Element.fromBytes(c0),
-    G1Element.fromBytes(c1)
-  ]).toBytes();
-}
-function decrypt(sk, [c0, c1]) {
-  return c1.subtract(c0.multiply(sk));
-}
-function generateSecretKey() {
-  return Scalar.random().toBytes();
-}
-function toPublicKey(sk) {
-  return G1Element.generator().multiply(Scalar.fromBytes(sk)).toBytes();
-}
-function toVerificationKey(sk) {
-  return G2Element.generator().multiply(Scalar.fromBytes(sk)).toBytes();
-}
-export {
-  elgamalDecrypt,
-  generateSecretKey,
-  toPublicKey,
-  toVerificationKey
-};
-//# sourceMappingURL=elgamal.js.map

package/dist/esm/elgamal.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/elgamal.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { G1Element, G2Element, Scalar } from './bls12381.js';\n\n/**\n * Decrypt a ciphertext with a given secret key. The secret key must be a 32-byte scalar.\n * The ciphertext is a pair of G1Elements (48 bytes).\n *\n * Throws an error if the secret key is not a valid scalar or if the ciphertext elements are not valid G1 points.\n */\nexport function elgamalDecrypt(sk: Uint8Array, [c0, c1]: [Uint8Array, Uint8Array]): Uint8Array {\n\treturn decrypt(Scalar.fromBytes(sk), [\n\t\tG1Element.fromBytes(c0),\n\t\tG1Element.fromBytes(c1),\n\t]).toBytes();\n}\n\n/**\n * Decrypt a ciphertext with a given secret key. The secret key must be a 32-byte scalar.\n * The ciphertext is a pair of G1Elements (48 bytes).\n */\nfunction decrypt(sk: Scalar, [c0, c1]: [G1Element, G1Element]): G1Element {\n\treturn c1.subtract(c0.multiply(sk));\n}\n\n/** Generate a random secret key. */\nexport function generateSecretKey(): Uint8Array<ArrayBuffer> {\n\treturn Scalar.random().toBytes() as Uint8Array<ArrayBuffer>;\n}\n\n/** Derive the BLS public key for a given secret key. */\nexport function toPublicKey(sk: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer> {\n\treturn G1Element.generator().multiply(Scalar.fromBytes(sk)).toBytes();\n}\n\n/** Derive the BLS verification key for a given secret key. */\nexport function toVerificationKey(sk: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer> {\n\treturn G2Element.generator().multiply(Scalar.fromBytes(sk)).toBytes();\n}\n"],
-  "mappings": "AAGA,SAAS,WAAW,WAAW,cAAc;AAQtC,SAAS,eAAe,IAAgB,CAAC,IAAI,EAAE,GAAyC;AAC9F,SAAO,QAAQ,OAAO,UAAU,EAAE,GAAG;AAAA,IACpC,UAAU,UAAU,EAAE;AAAA,IACtB,UAAU,UAAU,EAAE;AAAA,EACvB,CAAC,EAAE,QAAQ;AACZ;AAMA,SAAS,QAAQ,IAAY,CAAC,IAAI,EAAE,GAAsC;AACzE,SAAO,GAAG,SAAS,GAAG,SAAS,EAAE,CAAC;AACnC;AAGO,SAAS,oBAA6C;AAC5D,SAAO,OAAO,OAAO,EAAE,QAAQ;AAChC;AAGO,SAAS,YAAY,IAAsD;AACjF,SAAO,UAAU,UAAU,EAAE,SAAS,OAAO,UAAU,EAAE,CAAC,EAAE,QAAQ;AACrE;AAGO,SAAS,kBAAkB,IAAsD;AACvF,SAAO,UAAU,UAAU,EAAE,SAAS,OAAO,UAAU,EAAE,CAAC,EAAE,QAAQ;AACrE;",
-  "names": []
-}

package/dist/esm/encrypt.d.ts

@@ -1,32 +0,0 @@
-import type { EncryptionInput } from './dem.js';
-import type { KeyServer } from './key-server.js';
-/**
- * Given full ID and what key servers to use, return the encrypted message under the identity and return the bcs bytes of the encrypted object.
- *
- * @param keyServers - A list of KeyServers (same server can be used multiple times)
- * @param kemType - The type of KEM to use.
- * @param packageId - packageId
- * @param id - id
- * @param encryptionInput - Input to the encryption. Should be one of the EncryptionInput types, AesGcmEncryptionInput or Hmac256CtrEncryptionInput.
- * @param threshold - The threshold for the TSS encryption.
- * @returns The bcs bytes of the encrypted object containing all metadata and the 256-bit symmetric key that was used to encrypt the object.
- * Since the key can be used to decrypt, it should not be shared but can be used eg. for backup.
- */
-export declare function encrypt({ keyServers, kemType, threshold, packageId, id, encryptionInput, }: {
-    keyServers: KeyServer[];
-    kemType: KemType;
-    threshold: number;
-    packageId: string;
-    id: string;
-    encryptionInput: EncryptionInput;
-}): Promise<{
-    encryptedObject: Uint8Array<ArrayBuffer>;
-    key: Uint8Array<ArrayBuffer>;
-}>;
-export declare enum KemType {
-    BonehFranklinBLS12381DemCCA = 0
-}
-export declare enum DemType {
-    AesGcm256 = 0,
-    Hmac256Ctr = 1
-}

package/dist/esm/encrypt.js

@@ -1,84 +0,0 @@
-import { fromHex } from "@mysten/bcs";
-import { EncryptedObject } from "./bcs.js";
-import { UserError } from "./error.js";
-import { BonehFranklinBLS12381Services } from "./ibe.js";
-import { deriveKey, KeyPurpose } from "./kdf.js";
-import { createFullId, MAX_U8 } from "./utils.js";
-import { split } from "./shamir.js";
-async function encrypt({
-  keyServers,
-  kemType,
-  threshold,
-  packageId,
-  id,
-  encryptionInput
-}) {
-  if (threshold <= 0 || threshold >= MAX_U8 || keyServers.length < threshold || keyServers.length >= MAX_U8) {
-    throw new UserError(
-      `Invalid key servers or threshold ${threshold} for ${keyServers.length} key servers for package ${packageId}`
-    );
-  }
-  const baseKey = await encryptionInput.generateKey();
-  const shares = split(baseKey, threshold, keyServers.length);
-  const fullId = createFullId(packageId, id);
-  const encryptedShares = encryptBatched(
-    keyServers,
-    kemType,
-    fromHex(fullId),
-    shares,
-    baseKey,
-    threshold
-  );
-  const demKey = deriveKey(
-    KeyPurpose.DEM,
-    baseKey,
-    encryptedShares.BonehFranklinBLS12381.encryptedShares,
-    threshold,
-    keyServers.map(({ objectId }) => objectId)
-  );
-  const ciphertext = await encryptionInput.encrypt(demKey);
-  const services = keyServers.map(({ objectId }, i) => [
-    objectId,
-    shares[i].index
-  ]);
-  return {
-    encryptedObject: EncryptedObject.serialize({
-      version: 0,
-      packageId,
-      id,
-      services,
-      threshold,
-      encryptedShares,
-      ciphertext
-    }).toBytes(),
-    key: new Uint8Array(demKey)
-  };
-}
-var KemType = /* @__PURE__ */ ((KemType2) => {
-  KemType2[KemType2["BonehFranklinBLS12381DemCCA"] = 0] = "BonehFranklinBLS12381DemCCA";
-  return KemType2;
-})(KemType || {});
-var DemType = /* @__PURE__ */ ((DemType2) => {
-  DemType2[DemType2["AesGcm256"] = 0] = "AesGcm256";
-  DemType2[DemType2["Hmac256Ctr"] = 1] = "Hmac256Ctr";
-  return DemType2;
-})(DemType || {});
-function encryptBatched(keyServers, kemType, id, shares, baseKey, threshold) {
-  switch (kemType) {
-    case 0 /* BonehFranklinBLS12381DemCCA */:
-      return new BonehFranklinBLS12381Services(keyServers).encryptBatched(
-        id,
-        shares,
-        baseKey,
-        threshold
-      );
-    default:
-      throw new Error(`Invalid KEM type ${kemType}`);
-  }
-}
-export {
-  DemType,
-  KemType,
-  encrypt
-};
-//# sourceMappingURL=encrypt.js.map

package/dist/esm/encrypt.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/encrypt.ts"],
-  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromHex } from '@mysten/bcs';\n\nimport type { IBEEncryptions } from './bcs.js';\nimport { EncryptedObject } from './bcs.js';\nimport type { EncryptionInput } from './dem.js';\nimport { UserError } from './error.js';\nimport { BonehFranklinBLS12381Services } from './ibe.js';\nimport { deriveKey, KeyPurpose } from './kdf.js';\nimport type { KeyServer } from './key-server.js';\nimport { createFullId, MAX_U8 } from './utils.js';\nimport type { Share } from './shamir.js';\nimport { split } from './shamir.js';\n\n/**\n * Given full ID and what key servers to use, return the encrypted message under the identity and return the bcs bytes of the encrypted object.\n *\n * @param keyServers - A list of KeyServers (same server can be used multiple times)\n * @param kemType - The type of KEM to use.\n * @param packageId - packageId\n * @param id - id\n * @param encryptionInput - Input to the encryption. Should be one of the EncryptionInput types, AesGcmEncryptionInput or Hmac256CtrEncryptionInput.\n * @param threshold - The threshold for the TSS encryption.\n * @returns The bcs bytes of the encrypted object containing all metadata and the 256-bit symmetric key that was used to encrypt the object.\n * Since the key can be used to decrypt, it should not be shared but can be used eg. for backup.\n */\nexport async function encrypt({\n\tkeyServers,\n\tkemType,\n\tthreshold,\n\tpackageId,\n\tid,\n\tencryptionInput,\n}: {\n\tkeyServers: KeyServer[];\n\tkemType: KemType;\n\tthreshold: number;\n\tpackageId: string;\n\tid: string;\n\tencryptionInput: EncryptionInput;\n}): Promise<{\n\tencryptedObject: Uint8Array<ArrayBuffer>;\n\tkey: Uint8Array<ArrayBuffer>;\n}> {\n\t// Check inputs\n\tif (\n\t\tthreshold <= 0 ||\n\t\tthreshold >= MAX_U8 ||\n\t\tkeyServers.length < threshold ||\n\t\tkeyServers.length >= MAX_U8\n\t) {\n\t\tthrow new UserError(\n\t\t\t`Invalid key servers or threshold ${threshold} for ${keyServers.length} key servers for package ${packageId}`,\n\t\t);\n\t}\n\n\t// Generate a random base key.\n\tconst baseKey = await encryptionInput.generateKey();\n\n\t// Split the key into shares and encrypt each share with the public keys of the key servers.\n\tconst shares = split(baseKey, threshold, keyServers.length);\n\n\t// Encrypt the shares with the public keys of the key servers.\n\tconst fullId = createFullId(packageId, id);\n\tconst encryptedShares = encryptBatched(\n\t\tkeyServers,\n\t\tkemType,\n\t\tfromHex(fullId),\n\t\tshares,\n\t\tbaseKey,\n\t\tthreshold,\n\t);\n\n\t// Encrypt the object with the derived DEM key.\n\tconst demKey = deriveKey(\n\t\tKeyPurpose.DEM,\n\t\tbaseKey,\n\t\tencryptedShares.BonehFranklinBLS12381.encryptedShares,\n\t\tthreshold,\n\t\tkeyServers.map(({ objectId }) => objectId),\n\t);\n\tconst ciphertext = await encryptionInput.encrypt(demKey);\n\n\t// Services and indices of their shares are stored as a tuple\n\tconst services: [string, number][] = keyServers.map(({ objectId }, i) => [\n\t\tobjectId,\n\t\tshares[i].index,\n\t]);\n\n\treturn {\n\t\tencryptedObject: EncryptedObject.serialize({\n\t\t\tversion: 0,\n\t\t\tpackageId,\n\t\t\tid,\n\t\t\tservices,\n\t\t\tthreshold,\n\t\t\tencryptedShares,\n\t\t\tciphertext,\n\t\t}).toBytes(),\n\t\tkey: new Uint8Array(demKey),\n\t};\n}\n\nexport enum KemType {\n\tBonehFranklinBLS12381DemCCA = 0,\n}\n\nexport enum DemType {\n\tAesGcm256 = 0,\n\tHmac256Ctr = 1,\n}\n\nfunction encryptBatched(\n\tkeyServers: KeyServer[],\n\tkemType: KemType,\n\tid: Uint8Array,\n\tshares: Share[],\n\tbaseKey: Uint8Array,\n\tthreshold: number,\n): typeof IBEEncryptions.$inferType {\n\tswitch (kemType) {\n\t\tcase KemType.BonehFranklinBLS12381DemCCA:\n\t\t\treturn new BonehFranklinBLS12381Services(keyServers).encryptBatched(\n\t\t\t\tid,\n\t\t\t\tshares,\n\t\t\t\tbaseKey,\n\t\t\t\tthreshold,\n\t\t\t);\n\t\tdefault:\n\t\t\tthrow new Error(`Invalid KEM type ${kemType}`);\n\t}\n}\n"],
-  "mappings": "AAGA,SAAS,eAAe;AAGxB,SAAS,uBAAuB;AAEhC,SAAS,iBAAiB;AAC1B,SAAS,qCAAqC;AAC9C,SAAS,WAAW,kBAAkB;AAEtC,SAAS,cAAc,cAAc;AAErC,SAAS,aAAa;AActB,eAAsB,QAAQ;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD,GAUG;AAEF,MACC,aAAa,KACb,aAAa,UACb,WAAW,SAAS,aACpB,WAAW,UAAU,QACpB;AACD,UAAM,IAAI;AAAA,MACT,oCAAoC,SAAS,QAAQ,WAAW,MAAM,4BAA4B,SAAS;AAAA,IAC5G;AAAA,EACD;AAGA,QAAM,UAAU,MAAM,gBAAgB,YAAY;AAGlD,QAAM,SAAS,MAAM,SAAS,WAAW,WAAW,MAAM;AAG1D,QAAM,SAAS,aAAa,WAAW,EAAE;AACzC,QAAM,kBAAkB;AAAA,IACvB;AAAA,IACA;AAAA,IACA,QAAQ,MAAM;AAAA,IACd;AAAA,IACA;AAAA,IACA;AAAA,EACD;AAGA,QAAM,SAAS;AAAA,IACd,WAAW;AAAA,IACX;AAAA,IACA,gBAAgB,sBAAsB;AAAA,IACtC;AAAA,IACA,WAAW,IAAI,CAAC,EAAE,SAAS,MAAM,QAAQ;AAAA,EAC1C;AACA,QAAM,aAAa,MAAM,gBAAgB,QAAQ,MAAM;AAGvD,QAAM,WAA+B,WAAW,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM;AAAA,IACxE;AAAA,IACA,OAAO,CAAC,EAAE;AAAA,EACX,CAAC;AAED,SAAO;AAAA,IACN,iBAAiB,gBAAgB,UAAU;AAAA,MAC1C,SAAS;AAAA,MACT;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACD,CAAC,EAAE,QAAQ;AAAA,IACX,KAAK,IAAI,WAAW,MAAM;AAAA,EAC3B;AACD;AAEO,IAAK,UAAL,kBAAKA,aAAL;AACN,EAAAA,kBAAA,iCAA8B,KAA9B;AADW,SAAAA;AAAA,GAAA;AAIL,IAAK,UAAL,kBAAKC,aAAL;AACN,EAAAA,kBAAA,eAAY,KAAZ;AACA,EAAAA,kBAAA,gBAAa,KAAb;AAFW,SAAAA;AAAA,GAAA;AAKZ,SAAS,eACR,YACA,SACA,IACA,QACA,SACA,WACmC;AACnC,UAAQ,SAAS;AAAA,IAChB,KAAK;AACJ,aAAO,IAAI,8BAA8B,UAAU,EAAE;AAAA,QACpD;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACD;AAAA,IACD;AACC,YAAM,IAAI,MAAM,oBAAoB,OAAO,EAAE;AAAA,EAC/C;AACD;",
-  "names": ["KemType", "DemType"]
-}

package/dist/esm/error.d.ts

@@ -1,86 +0,0 @@
-export declare class SealError extends Error {
-}
-export declare class UserError extends SealError {
-}
-export declare class SealAPIError extends SealError {
-    #private;
-    requestId?: string | undefined;
-    status?: number | undefined;
-    constructor(message: string, requestId?: string | undefined, status?: number | undefined);
-    static assertResponse(response: Response, requestId: string): Promise<void>;
-}
-export declare class InvalidPTBError extends SealAPIError {
-    constructor(requestId?: string, message?: string);
-}
-export declare class InvalidPackageError extends SealAPIError {
-    constructor(requestId?: string);
-}
-export declare class InvalidParameterError extends SealAPIError {
-    constructor(requestId?: string);
-}
-export declare class InvalidUserSignatureError extends SealAPIError {
-    constructor(requestId?: string);
-}
-export declare class InvalidSessionKeySignatureError extends SealAPIError {
-    constructor(requestId?: string);
-}
-export declare class InvalidMVRNameError extends SealAPIError {
-    constructor(requestId?: string);
-}
-/** Server error indicating that the requested key server object id is invalid */
-export declare class InvalidKeyServerObjectIdError extends SealAPIError {
-    constructor(requestId?: string);
-}
-/** Server error indicating that the requested package id is not supported (i.e., key server is running in Permissioned mode) */
-export declare class UnsupportedPackageIdError extends SealAPIError {
-    constructor(requestId?: string);
-}
-export declare class InvalidSDKVersionError extends SealAPIError {
-    constructor(requestId?: string);
-}
-export declare class InvalidSDKTypeError extends SealAPIError {
-    constructor(requestId?: string);
-}
-export declare class DeprecatedSDKVersionError extends SealAPIError {
-    constructor(requestId?: string);
-}
-/** Server error indicating that the user does not have access to one or more of the requested keys */
-export declare class NoAccessError extends SealAPIError {
-    constructor(requestId?: string);
-}
-/** Server error indicating that the session key has expired */
-export declare class ExpiredSessionKeyError extends SealAPIError {
-    constructor(requestId?: string);
-}
-/** Internal server error, caller should retry */
-export declare class InternalError extends SealAPIError {
-    constructor(requestId?: string);
-}
-/** General server errors that are not specific to the Seal API (e.g., 404 "Not Found") */
-export declare class GeneralError extends SealAPIError {
-}
-export declare class InvalidPersonalMessageSignatureError extends UserError {
-}
-export declare class InvalidGetObjectError extends UserError {
-}
-export declare class UnsupportedFeatureError extends UserError {
-}
-export declare class UnsupportedNetworkError extends UserError {
-}
-export declare class InvalidKeyServerError extends UserError {
-}
-export declare class InvalidKeyServerVersionError extends UserError {
-}
-export declare class InvalidCiphertextError extends UserError {
-}
-export declare class InvalidThresholdError extends UserError {
-}
-export declare class InconsistentKeyServersError extends UserError {
-}
-export declare class DecryptionError extends UserError {
-}
-export declare class InvalidClientOptionsError extends UserError {
-}
-export declare class TooManyFailedFetchKeyRequestsError extends UserError {
-}
-export declare function toMajorityError(errors: Error[]): Error;

package/dist/esm/error.js

@@ -1,219 +0,0 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _SealAPIError_static, generate_fn;
-class SealError extends Error {
-}
-class UserError extends SealError {
-}
-const _SealAPIError = class _SealAPIError extends SealError {
-  constructor(message, requestId, status) {
-    super(message);
-    this.requestId = requestId;
-    this.status = status;
-  }
-  static async assertResponse(response, requestId) {
-    var _a;
-    if (response.ok) {
-      return;
-    }
-    let errorInstance;
-    try {
-      const text = await response.text();
-      const error = JSON.parse(text)["error"];
-      const message = JSON.parse(text)["message"];
-      errorInstance = __privateMethod(_a = _SealAPIError, _SealAPIError_static, generate_fn).call(_a, error, message, requestId);
-    } catch {
-      errorInstance = new GeneralError(response.statusText, requestId, response.status);
-    }
-    throw errorInstance;
-  }
-};
-_SealAPIError_static = new WeakSet();
-generate_fn = function(error, message, requestId, status) {
-  switch (error) {
-    case "InvalidPTB":
-      return new InvalidPTBError(requestId, message);
-    case "InvalidPackage":
-      return new InvalidPackageError(requestId);
-    case "NoAccess":
-      return new NoAccessError(requestId);
-    case "InvalidSignature":
-      return new InvalidUserSignatureError(requestId);
-    case "InvalidSessionSignature":
-      return new InvalidSessionKeySignatureError(requestId);
-    case "InvalidCertificate":
-      return new ExpiredSessionKeyError(requestId);
-    case "InvalidSDKVersion":
-      return new InvalidSDKVersionError(requestId);
-    case "InvalidSDKType":
-      return new InvalidSDKTypeError(requestId);
-    case "DeprecatedSDKVersion":
-      return new DeprecatedSDKVersionError(requestId);
-    case "InvalidParameter":
-      return new InvalidParameterError(requestId);
-    case "InvalidMVRName":
-      return new InvalidMVRNameError(requestId);
-    case "InvalidServiceId":
-      return new InvalidKeyServerObjectIdError(requestId);
-    case "UnsupportedPackageId":
-      return new UnsupportedPackageIdError(requestId);
-    case "Failure":
-      return new InternalError(requestId);
-    default:
-      return new GeneralError(message, requestId, status);
-  }
-};
-__privateAdd(_SealAPIError, _SealAPIError_static);
-let SealAPIError = _SealAPIError;
-class InvalidPTBError extends SealAPIError {
-  constructor(requestId, message) {
-    super("PTB does not conform to the expected format " + message, requestId);
-  }
-}
-class InvalidPackageError extends SealAPIError {
-  constructor(requestId) {
-    super("Package ID used in PTB is invalid", requestId);
-  }
-}
-class InvalidParameterError extends SealAPIError {
-  constructor(requestId) {
-    super(
-      "PTB contains an invalid parameter, possibly a newly created object that the FN has not yet seen",
-      requestId
-    );
-  }
-}
-class InvalidUserSignatureError extends SealAPIError {
-  constructor(requestId) {
-    super("User signature on the session key is invalid", requestId);
-  }
-}
-class InvalidSessionKeySignatureError extends SealAPIError {
-  constructor(requestId) {
-    super("Session key signature is invalid", requestId);
-  }
-}
-class InvalidMVRNameError extends SealAPIError {
-  constructor(requestId) {
-    super("MVR name is invalid or not consistent with the first version of the package", requestId);
-  }
-}
-class InvalidKeyServerObjectIdError extends SealAPIError {
-  constructor(requestId) {
-    super("Key server object ID is invalid", requestId);
-  }
-}
-class UnsupportedPackageIdError extends SealAPIError {
-  constructor(requestId) {
-    super("Requested package is not supported", requestId);
-  }
-}
-class InvalidSDKVersionError extends SealAPIError {
-  constructor(requestId) {
-    super("SDK version is invalid", requestId);
-  }
-}
-class InvalidSDKTypeError extends SealAPIError {
-  constructor(requestId) {
-    super("SDK type is invalid", requestId);
-  }
-}
-class DeprecatedSDKVersionError extends SealAPIError {
-  constructor(requestId) {
-    super("SDK version is deprecated", requestId);
-  }
-}
-class NoAccessError extends SealAPIError {
-  constructor(requestId) {
-    super("User does not have access to one or more of the requested keys", requestId);
-  }
-}
-class ExpiredSessionKeyError extends SealAPIError {
-  constructor(requestId) {
-    super("Session key has expired", requestId);
-  }
-}
-class InternalError extends SealAPIError {
-  constructor(requestId) {
-    super("Internal server error, caller should retry", requestId);
-  }
-}
-class GeneralError extends SealAPIError {
-}
-class InvalidPersonalMessageSignatureError extends UserError {
-}
-class InvalidGetObjectError extends UserError {
-}
-class UnsupportedFeatureError extends UserError {
-}
-class UnsupportedNetworkError extends UserError {
-}
-class InvalidKeyServerError extends UserError {
-}
-class InvalidKeyServerVersionError extends UserError {
-}
-class InvalidCiphertextError extends UserError {
-}
-class InvalidThresholdError extends UserError {
-}
-class InconsistentKeyServersError extends UserError {
-}
-class DecryptionError extends UserError {
-}
-class InvalidClientOptionsError extends UserError {
-}
-class TooManyFailedFetchKeyRequestsError extends UserError {
-}
-function toMajorityError(errors) {
-  let maxCount = 0;
-  let majorityError = errors[0];
-  const counts = /* @__PURE__ */ new Map();
-  for (const error of errors) {
-    const errorName = error.constructor.name;
-    const newCount = (counts.get(errorName) || 0) + 1;
-    counts.set(errorName, newCount);
-    if (newCount > maxCount) {
-      maxCount = newCount;
-      majorityError = error;
-    }
-  }
-  return majorityError;
-}
-export {
-  DecryptionError,
-  DeprecatedSDKVersionError,
-  ExpiredSessionKeyError,
-  GeneralError,
-  InconsistentKeyServersError,
-  InternalError,
-  InvalidCiphertextError,
-  InvalidClientOptionsError,
-  InvalidGetObjectError,
-  InvalidKeyServerError,
-  InvalidKeyServerObjectIdError,
-  InvalidKeyServerVersionError,
-  InvalidMVRNameError,
-  InvalidPTBError,
-  InvalidPackageError,
-  InvalidParameterError,
-  InvalidPersonalMessageSignatureError,
-  InvalidSDKTypeError,
-  InvalidSDKVersionError,
-  InvalidSessionKeySignatureError,
-  InvalidThresholdError,
-  InvalidUserSignatureError,
-  NoAccessError,
-  SealAPIError,
-  SealError,
-  TooManyFailedFetchKeyRequestsError,
-  UnsupportedFeatureError,
-  UnsupportedNetworkError,
-  UnsupportedPackageIdError,
-  UserError,
-  toMajorityError
-};
-//# sourceMappingURL=error.js.map