@mysten/seal 0.0.0-experimental-20250330082435

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# @mysten/seal
+
+## 0.0.0-experimental-20250330082435
+
+### Patch Changes
+
+- d2ef9ef: Update encryption format, and export errors
+
+## 0.3.0
+
+### Minor Changes
+
+- ecc8b7e: New interfaces
+
+## 0.2.0
+
+### Minor Changes
+
+- 0886b3e: export KeyServer type
+
+## 0.1.0
+
+### Minor Changes
+
+- 8ca8df3: First publish
+
+### Patch Changes
+
+- Updated dependencies [95b1ea5]
+  - @mysten/bcs@1.4.0
+  - @mysten/sui@1.21.2

package/README.md

@@ -0,0 +1,4 @@
+# `@mysten/seal`
+
+**Warning**: This is a DEVELOPER PREVIEW of Seal. It is EXPERIMENTAL and has NO GUARANTEES of uptime
+or correctness. USE AT YOUR OWN RISK.

package/dist/cjs/bcs.d.ts

@@ -0,0 +1,132 @@
+export declare const IBEEncryptions: import("@mysten/bcs").BcsType<{
+    BonehFranklinBLS12381: {
+        nonce: Uint8Array<ArrayBufferLike>;
+        encryptedShares: Uint8Array<ArrayBufferLike>[];
+        encryptedRandomness: Uint8Array<ArrayBufferLike>;
+    };
+    $kind: "BonehFranklinBLS12381";
+}, {
+    BonehFranklinBLS12381: {
+        nonce: Iterable<number>;
+        encryptedShares: Iterable<Iterable<number>> & {
+            length: number;
+        };
+        encryptedRandomness: Iterable<number>;
+    };
+}>;
+export declare const Ciphertext: import("@mysten/bcs").BcsType<import("@mysten/bcs").EnumOutputShapeWithKeys<{
+    Aes256Gcm: {
+        blob: number[];
+        aad: number[] | null;
+    };
+    Hmac256Ctr: {
+        blob: number[];
+        aad: number[] | null;
+        mac: Uint8Array<ArrayBufferLike>;
+    };
+    Plain: {};
+}, "Aes256Gcm" | "Hmac256Ctr" | "Plain">, import("@mysten/bcs").EnumInputShape<{
+    Aes256Gcm: {
+        blob: Iterable<number> & {
+            length: number;
+        };
+        aad: (Iterable<number> & {
+            length: number;
+        }) | null | undefined;
+    };
+    Hmac256Ctr: {
+        blob: Iterable<number> & {
+            length: number;
+        };
+        aad: (Iterable<number> & {
+            length: number;
+        }) | null | undefined;
+        mac: Iterable<number>;
+    };
+    Plain: {};
+}>>;
+/**
+ * The encrypted object format. Should be aligned with the Rust implementation.
+ */
+export declare const EncryptedObject: import("@mysten/bcs").BcsType<{
+    version: number;
+    packageId: string;
+    id: string;
+    services: [string, number][];
+    threshold: number;
+    encryptedShares: {
+        BonehFranklinBLS12381: {
+            nonce: Uint8Array<ArrayBufferLike>;
+            encryptedShares: Uint8Array<ArrayBufferLike>[];
+            encryptedRandomness: Uint8Array<ArrayBufferLike>;
+        };
+        $kind: "BonehFranklinBLS12381";
+    };
+    ciphertext: import("@mysten/bcs").EnumOutputShapeWithKeys<{
+        Aes256Gcm: {
+            blob: number[];
+            aad: number[] | null;
+        };
+        Hmac256Ctr: {
+            blob: number[];
+            aad: number[] | null;
+            mac: Uint8Array<ArrayBufferLike>;
+        };
+        Plain: {};
+    }, "Aes256Gcm" | "Hmac256Ctr" | "Plain">;
+}, {
+    version: number;
+    packageId: string | Uint8Array<ArrayBufferLike>;
+    id: string;
+    services: Iterable<readonly [string | Uint8Array<ArrayBufferLike>, number]> & {
+        length: number;
+    };
+    threshold: number;
+    encryptedShares: {
+        BonehFranklinBLS12381: {
+            nonce: Iterable<number>;
+            encryptedShares: Iterable<Iterable<number>> & {
+                length: number;
+            };
+            encryptedRandomness: Iterable<number>;
+        };
+    };
+    ciphertext: import("@mysten/bcs").EnumInputShape<{
+        Aes256Gcm: {
+            blob: Iterable<number> & {
+                length: number;
+            };
+            aad: (Iterable<number> & {
+                length: number;
+            }) | null | undefined;
+        };
+        Hmac256Ctr: {
+            blob: Iterable<number> & {
+                length: number;
+            };
+            aad: (Iterable<number> & {
+                length: number;
+            }) | null | undefined;
+            mac: Iterable<number>;
+        };
+        Plain: {};
+    }>;
+}>;
+/**
+ * The Move struct for the KeyServer object.
+ */
+export declare const KeyServerMove: import("@mysten/bcs").BcsType<{
+    id: string;
+    name: string;
+    url: string;
+    keyType: number;
+    pk: number[];
+}, {
+    id: string | Uint8Array<ArrayBufferLike>;
+    name: string;
+    url: string;
+    keyType: number;
+    pk: Iterable<number> & {
+        length: number;
+    };
+}>;

package/dist/cjs/bcs.js

@@ -0,0 +1,67 @@
+"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 bcs_exports = {};
+__export(bcs_exports, {
+  Ciphertext: () => Ciphertext,
+  EncryptedObject: () => EncryptedObject,
+  IBEEncryptions: () => IBEEncryptions,
+  KeyServerMove: () => KeyServerMove
+});
+module.exports = __toCommonJS(bcs_exports);
+var import_bcs = require("@mysten/bcs");
+var import_bcs2 = require("@mysten/sui/bcs");
+const IBEEncryptions = import_bcs2.bcs.enum("IBEEncryptions", {
+  BonehFranklinBLS12381: import_bcs2.bcs.struct("BonehFranklinBLS12381", {
+    nonce: import_bcs2.bcs.bytes(96),
+    encryptedShares: import_bcs2.bcs.vector(import_bcs2.bcs.bytes(32)),
+    encryptedRandomness: import_bcs2.bcs.bytes(32)
+  })
+});
+const Ciphertext = import_bcs2.bcs.enum("Ciphertext", {
+  Aes256Gcm: import_bcs2.bcs.struct("Aes256Gcm", {
+    blob: import_bcs2.bcs.vector(import_bcs2.bcs.U8),
+    aad: import_bcs2.bcs.option(import_bcs2.bcs.vector(import_bcs2.bcs.U8))
+  }),
+  Hmac256Ctr: import_bcs2.bcs.struct("Hmac256Ctr", {
+    blob: import_bcs2.bcs.vector(import_bcs2.bcs.U8),
+    aad: import_bcs2.bcs.option(import_bcs2.bcs.vector(import_bcs2.bcs.U8)),
+    mac: import_bcs2.bcs.bytes(32)
+  }),
+  Plain: import_bcs2.bcs.struct("Plain", {})
+});
+const EncryptedObject = import_bcs2.bcs.struct("EncryptedObject", {
+  version: import_bcs2.bcs.U8,
+  packageId: import_bcs2.bcs.Address,
+  id: import_bcs2.bcs.vector(import_bcs2.bcs.U8).transform({
+    output: (val) => (0, import_bcs.toHex)(new Uint8Array(val)),
+    input: (val) => (0, import_bcs.fromHex)(val)
+  }),
+  services: import_bcs2.bcs.vector(import_bcs2.bcs.tuple([import_bcs2.bcs.Address, import_bcs2.bcs.U8])),
+  threshold: import_bcs2.bcs.U8,
+  encryptedShares: IBEEncryptions,
+  ciphertext: Ciphertext
+});
+const KeyServerMove = import_bcs2.bcs.struct("KeyServer", {
+  id: import_bcs2.bcs.Address,
+  name: import_bcs2.bcs.string(),
+  url: import_bcs2.bcs.string(),
+  keyType: import_bcs2.bcs.u8(),
+  pk: import_bcs2.bcs.vector(import_bcs2.bcs.u8())
+});
+//# sourceMappingURL=bcs.js.map

package/dist/cjs/bcs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/bcs.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromHex, toHex } from '@mysten/bcs';\nimport { bcs } from '@mysten/sui/bcs';\n\nexport const IBEEncryptions = bcs.enum('IBEEncryptions', {\n\tBonehFranklinBLS12381: bcs.struct('BonehFranklinBLS12381', {\n\t\tnonce: bcs.bytes(96),\n\t\tencryptedShares: bcs.vector(bcs.bytes(32)),\n\t\tencryptedRandomness: bcs.bytes(32),\n\t}),\n});\n\nexport const Ciphertext = bcs.enum('Ciphertext', {\n\tAes256Gcm: bcs.struct('Aes256Gcm', {\n\t\tblob: bcs.vector(bcs.U8),\n\t\taad: bcs.option(bcs.vector(bcs.U8)),\n\t}),\n\tHmac256Ctr: bcs.struct('Hmac256Ctr', {\n\t\tblob: bcs.vector(bcs.U8),\n\t\taad: bcs.option(bcs.vector(bcs.U8)),\n\t\tmac: bcs.bytes(32),\n\t}),\n\tPlain: bcs.struct('Plain', {}),\n});\n\n/**\n * The encrypted object format. Should be aligned with the Rust implementation.\n */\nexport const EncryptedObject = bcs.struct('EncryptedObject', {\n\tversion: bcs.U8,\n\tpackageId: bcs.Address,\n\tid: bcs.vector(bcs.U8).transform({\n\t\toutput: (val) => toHex(new Uint8Array(val)),\n\t\tinput: (val: string) => fromHex(val),\n\t}),\n\tservices: bcs.vector(bcs.tuple([bcs.Address, bcs.U8])),\n\tthreshold: bcs.U8,\n\tencryptedShares: IBEEncryptions,\n\tciphertext: Ciphertext,\n});\n\n/**\n * The Move struct for the KeyServer object.\n */\nexport const KeyServerMove = bcs.struct('KeyServer', {\n\tid: bcs.Address,\n\tname: bcs.string(),\n\turl: bcs.string(),\n\tkeyType: bcs.u8(),\n\tpk: bcs.vector(bcs.u8()),\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,iBAA+B;AAC/B,IAAAA,cAAoB;AAEb,MAAM,iBAAiB,gBAAI,KAAK,kBAAkB;AAAA,EACxD,uBAAuB,gBAAI,OAAO,yBAAyB;AAAA,IAC1D,OAAO,gBAAI,MAAM,EAAE;AAAA,IACnB,iBAAiB,gBAAI,OAAO,gBAAI,MAAM,EAAE,CAAC;AAAA,IACzC,qBAAqB,gBAAI,MAAM,EAAE;AAAA,EAClC,CAAC;AACF,CAAC;AAEM,MAAM,aAAa,gBAAI,KAAK,cAAc;AAAA,EAChD,WAAW,gBAAI,OAAO,aAAa;AAAA,IAClC,MAAM,gBAAI,OAAO,gBAAI,EAAE;AAAA,IACvB,KAAK,gBAAI,OAAO,gBAAI,OAAO,gBAAI,EAAE,CAAC;AAAA,EACnC,CAAC;AAAA,EACD,YAAY,gBAAI,OAAO,cAAc;AAAA,IACpC,MAAM,gBAAI,OAAO,gBAAI,EAAE;AAAA,IACvB,KAAK,gBAAI,OAAO,gBAAI,OAAO,gBAAI,EAAE,CAAC;AAAA,IAClC,KAAK,gBAAI,MAAM,EAAE;AAAA,EAClB,CAAC;AAAA,EACD,OAAO,gBAAI,OAAO,SAAS,CAAC,CAAC;AAC9B,CAAC;AAKM,MAAM,kBAAkB,gBAAI,OAAO,mBAAmB;AAAA,EAC5D,SAAS,gBAAI;AAAA,EACb,WAAW,gBAAI;AAAA,EACf,IAAI,gBAAI,OAAO,gBAAI,EAAE,EAAE,UAAU;AAAA,IAChC,QAAQ,CAAC,YAAQ,kBAAM,IAAI,WAAW,GAAG,CAAC;AAAA,IAC1C,OAAO,CAAC,YAAgB,oBAAQ,GAAG;AAAA,EACpC,CAAC;AAAA,EACD,UAAU,gBAAI,OAAO,gBAAI,MAAM,CAAC,gBAAI,SAAS,gBAAI,EAAE,CAAC,CAAC;AAAA,EACrD,WAAW,gBAAI;AAAA,EACf,iBAAiB;AAAA,EACjB,YAAY;AACb,CAAC;AAKM,MAAM,gBAAgB,gBAAI,OAAO,aAAa;AAAA,EACpD,IAAI,gBAAI;AAAA,EACR,MAAM,gBAAI,OAAO;AAAA,EACjB,KAAK,gBAAI,OAAO;AAAA,EAChB,SAAS,gBAAI,GAAG;AAAA,EAChB,IAAI,gBAAI,OAAO,gBAAI,GAAG,CAAC;AACxB,CAAC;",
+  "names": ["import_bcs"]
+}

package/dist/cjs/bls12381.d.ts

@@ -0,0 +1,37 @@
+import type { Fp2, Fp12 } from '@noble/curves/abstract/tower';
+import type { ProjPointType } from '@noble/curves/abstract/weierstrass';
+export declare class G1Element {
+    point: ProjPointType<bigint>;
+    constructor(point: ProjPointType<bigint>);
+    static generator(): G1Element;
+    static fromBytes(bytes: Uint8Array): G1Element;
+    toBytes(): Uint8Array;
+    multiply(scalar: Scalar): G1Element;
+    add(other: G1Element): G1Element;
+    subtract(other: G1Element): G1Element;
+    static hashToCurve(data: Uint8Array): G1Element;
+    pairing(other: G2Element): GTElement;
+}
+export declare class G2Element {
+    point: ProjPointType<Fp2>;
+    constructor(point: ProjPointType<Fp2>);
+    static generator(): G2Element;
+    static fromBytes(bytes: Uint8Array): G2Element;
+    toBytes(): Uint8Array;
+    multiply(scalar: Scalar): G2Element;
+    add(other: G2Element): G2Element;
+    hashToCurve(data: Uint8Array): G2Element;
+}
+export declare class GTElement {
+    element: Fp12;
+    constructor(element: Fp12);
+    toBytes(): Uint8Array;
+}
+export declare class Scalar {
+    scalar: bigint;
+    constructor(scalar: bigint);
+    static random(): Scalar;
+    toBytes(): Uint8Array;
+    static fromBytes(bytes: Uint8Array): Scalar;
+    static fromNumber(num: number): Scalar;
+}

package/dist/cjs/bls12381.js

@@ -0,0 +1,110 @@
+"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 bls12381_exports = {};
+__export(bls12381_exports, {
+  G1Element: () => G1Element,
+  G2Element: () => G2Element,
+  GTElement: () => GTElement,
+  Scalar: () => Scalar
+});
+module.exports = __toCommonJS(bls12381_exports);
+var import_bcs = require("@mysten/bcs");
+var import_bls12_381 = require("@noble/curves/bls12-381");
+class G1Element {
+  constructor(point) {
+    this.point = point;
+  }
+  static generator() {
+    return new G1Element(import_bls12_381.bls12_381.G1.ProjectivePoint.BASE);
+  }
+  static fromBytes(bytes) {
+    return new G1Element(import_bls12_381.bls12_381.G1.ProjectivePoint.fromHex((0, import_bcs.toHex)(bytes)));
+  }
+  toBytes() {
+    return this.point.toRawBytes();
+  }
+  multiply(scalar) {
+    return new G1Element(this.point.multiply(scalar.scalar));
+  }
+  add(other) {
+    return new G1Element(this.point.add(other.point));
+  }
+  subtract(other) {
+    return new G1Element(this.point.subtract(other.point));
+  }
+  static hashToCurve(data) {
+    return new G1Element(
+      import_bls12_381.bls12_381.G1.ProjectivePoint.fromAffine(import_bls12_381.bls12_381.G1.hashToCurve(data).toAffine())
+    );
+  }
+  pairing(other) {
+    return new GTElement(import_bls12_381.bls12_381.pairing(this.point, other.point));
+  }
+}
+class G2Element {
+  constructor(point) {
+    this.point = point;
+  }
+  static generator() {
+    return new G2Element(import_bls12_381.bls12_381.G2.ProjectivePoint.BASE);
+  }
+  static fromBytes(bytes) {
+    return new G2Element(import_bls12_381.bls12_381.G2.ProjectivePoint.fromHex((0, import_bcs.toHex)(bytes)));
+  }
+  toBytes() {
+    return this.point.toRawBytes();
+  }
+  multiply(scalar) {
+    return new G2Element(this.point.multiply(scalar.scalar));
+  }
+  add(other) {
+    return new G2Element(this.point.add(other.point));
+  }
+  hashToCurve(data) {
+    return new G2Element(
+      import_bls12_381.bls12_381.G2.ProjectivePoint.fromAffine(import_bls12_381.bls12_381.G2.hashToCurve(data).toAffine())
+    );
+  }
+}
+class GTElement {
+  constructor(element) {
+    this.element = element;
+  }
+  toBytes() {
+    return import_bls12_381.bls12_381.fields.Fp12.toBytes(this.element);
+  }
+}
+class Scalar {
+  constructor(scalar) {
+    this.scalar = scalar;
+  }
+  static random() {
+    return Scalar.fromBytes(import_bls12_381.bls12_381.utils.randomPrivateKey());
+  }
+  toBytes() {
+    return new Uint8Array(import_bls12_381.bls12_381.fields.Fr.toBytes(this.scalar));
+  }
+  static fromBytes(bytes) {
+    return new Scalar(import_bls12_381.bls12_381.fields.Fr.fromBytes(bytes));
+  }
+  static fromNumber(num) {
+    return new Scalar(BigInt(num));
+  }
+}
+//# sourceMappingURL=bls12381.js.map

package/dist/cjs/bls12381.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/bls12381.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { toHex } from '@mysten/bcs';\nimport type { Fp2, Fp12 } from '@noble/curves/abstract/tower';\nimport type { ProjPointType } from '@noble/curves/abstract/weierstrass';\nimport { bls12_381 } from '@noble/curves/bls12-381';\n\nexport class G1Element {\n\tpoint: ProjPointType<bigint>;\n\n\tconstructor(point: ProjPointType<bigint>) {\n\t\tthis.point = point;\n\t}\n\n\tstatic generator(): G1Element {\n\t\treturn new G1Element(bls12_381.G1.ProjectivePoint.BASE);\n\t}\n\n\tstatic fromBytes(bytes: Uint8Array): G1Element {\n\t\treturn new G1Element(bls12_381.G1.ProjectivePoint.fromHex(toHex(bytes)));\n\t}\n\n\ttoBytes(): Uint8Array {\n\t\treturn this.point.toRawBytes();\n\t}\n\n\tmultiply(scalar: Scalar): G1Element {\n\t\treturn new G1Element(this.point.multiply(scalar.scalar));\n\t}\n\n\tadd(other: G1Element): G1Element {\n\t\treturn new G1Element(this.point.add(other.point));\n\t}\n\n\tsubtract(other: G1Element): G1Element {\n\t\treturn new G1Element(this.point.subtract(other.point));\n\t}\n\n\tstatic hashToCurve(data: Uint8Array): G1Element {\n\t\treturn new G1Element(\n\t\t\tbls12_381.G1.ProjectivePoint.fromAffine(bls12_381.G1.hashToCurve(data).toAffine()),\n\t\t);\n\t}\n\n\tpairing(other: G2Element): GTElement {\n\t\treturn new GTElement(bls12_381.pairing(this.point, other.point));\n\t}\n}\n\nexport class G2Element {\n\tpoint: ProjPointType<Fp2>;\n\n\tconstructor(point: ProjPointType<Fp2>) {\n\t\tthis.point = point;\n\t}\n\n\tstatic generator(): G2Element {\n\t\treturn new G2Element(bls12_381.G2.ProjectivePoint.BASE);\n\t}\n\n\tstatic fromBytes(bytes: Uint8Array): G2Element {\n\t\treturn new G2Element(bls12_381.G2.ProjectivePoint.fromHex(toHex(bytes)));\n\t}\n\n\ttoBytes(): Uint8Array {\n\t\treturn this.point.toRawBytes();\n\t}\n\n\tmultiply(scalar: Scalar): G2Element {\n\t\treturn new G2Element(this.point.multiply(scalar.scalar));\n\t}\n\n\tadd(other: G2Element): G2Element {\n\t\treturn new G2Element(this.point.add(other.point));\n\t}\n\n\thashToCurve(data: Uint8Array): G2Element {\n\t\treturn new G2Element(\n\t\t\tbls12_381.G2.ProjectivePoint.fromAffine(bls12_381.G2.hashToCurve(data).toAffine()),\n\t\t);\n\t}\n}\n\nexport class GTElement {\n\telement: Fp12;\n\n\tconstructor(element: Fp12) {\n\t\tthis.element = element;\n\t}\n\n\ttoBytes(): Uint8Array {\n\t\treturn bls12_381.fields.Fp12.toBytes(this.element);\n\t}\n}\n\nexport class Scalar {\n\tscalar: bigint;\n\n\tconstructor(scalar: bigint) {\n\t\tthis.scalar = scalar;\n\t}\n\n\tstatic random(): Scalar {\n\t\treturn Scalar.fromBytes(bls12_381.utils.randomPrivateKey());\n\t}\n\n\ttoBytes(): Uint8Array {\n\t\treturn new Uint8Array(bls12_381.fields.Fr.toBytes(this.scalar));\n\t}\n\n\tstatic fromBytes(bytes: Uint8Array): Scalar {\n\t\treturn new Scalar(bls12_381.fields.Fr.fromBytes(bytes));\n\t}\n\n\tstatic fromNumber(num: number): Scalar {\n\t\treturn new Scalar(BigInt(num));\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,iBAAsB;AAGtB,uBAA0B;AAEnB,MAAM,UAAU;AAAA,EAGtB,YAAY,OAA8B;AACzC,SAAK,QAAQ;AAAA,EACd;AAAA,EAEA,OAAO,YAAuB;AAC7B,WAAO,IAAI,UAAU,2BAAU,GAAG,gBAAgB,IAAI;AAAA,EACvD;AAAA,EAEA,OAAO,UAAU,OAA8B;AAC9C,WAAO,IAAI,UAAU,2BAAU,GAAG,gBAAgB,YAAQ,kBAAM,KAAK,CAAC,CAAC;AAAA,EACxE;AAAA,EAEA,UAAsB;AACrB,WAAO,KAAK,MAAM,WAAW;AAAA,EAC9B;AAAA,EAEA,SAAS,QAA2B;AACnC,WAAO,IAAI,UAAU,KAAK,MAAM,SAAS,OAAO,MAAM,CAAC;AAAA,EACxD;AAAA,EAEA,IAAI,OAA6B;AAChC,WAAO,IAAI,UAAU,KAAK,MAAM,IAAI,MAAM,KAAK,CAAC;AAAA,EACjD;AAAA,EAEA,SAAS,OAA6B;AACrC,WAAO,IAAI,UAAU,KAAK,MAAM,SAAS,MAAM,KAAK,CAAC;AAAA,EACtD;AAAA,EAEA,OAAO,YAAY,MAA6B;AAC/C,WAAO,IAAI;AAAA,MACV,2BAAU,GAAG,gBAAgB,WAAW,2BAAU,GAAG,YAAY,IAAI,EAAE,SAAS,CAAC;AAAA,IAClF;AAAA,EACD;AAAA,EAEA,QAAQ,OAA6B;AACpC,WAAO,IAAI,UAAU,2BAAU,QAAQ,KAAK,OAAO,MAAM,KAAK,CAAC;AAAA,EAChE;AACD;AAEO,MAAM,UAAU;AAAA,EAGtB,YAAY,OAA2B;AACtC,SAAK,QAAQ;AAAA,EACd;AAAA,EAEA,OAAO,YAAuB;AAC7B,WAAO,IAAI,UAAU,2BAAU,GAAG,gBAAgB,IAAI;AAAA,EACvD;AAAA,EAEA,OAAO,UAAU,OAA8B;AAC9C,WAAO,IAAI,UAAU,2BAAU,GAAG,gBAAgB,YAAQ,kBAAM,KAAK,CAAC,CAAC;AAAA,EACxE;AAAA,EAEA,UAAsB;AACrB,WAAO,KAAK,MAAM,WAAW;AAAA,EAC9B;AAAA,EAEA,SAAS,QAA2B;AACnC,WAAO,IAAI,UAAU,KAAK,MAAM,SAAS,OAAO,MAAM,CAAC;AAAA,EACxD;AAAA,EAEA,IAAI,OAA6B;AAChC,WAAO,IAAI,UAAU,KAAK,MAAM,IAAI,MAAM,KAAK,CAAC;AAAA,EACjD;AAAA,EAEA,YAAY,MAA6B;AACxC,WAAO,IAAI;AAAA,MACV,2BAAU,GAAG,gBAAgB,WAAW,2BAAU,GAAG,YAAY,IAAI,EAAE,SAAS,CAAC;AAAA,IAClF;AAAA,EACD;AACD;AAEO,MAAM,UAAU;AAAA,EAGtB,YAAY,SAAe;AAC1B,SAAK,UAAU;AAAA,EAChB;AAAA,EAEA,UAAsB;AACrB,WAAO,2BAAU,OAAO,KAAK,QAAQ,KAAK,OAAO;AAAA,EAClD;AACD;AAEO,MAAM,OAAO;AAAA,EAGnB,YAAY,QAAgB;AAC3B,SAAK,SAAS;AAAA,EACf;AAAA,EAEA,OAAO,SAAiB;AACvB,WAAO,OAAO,UAAU,2BAAU,MAAM,iBAAiB,CAAC;AAAA,EAC3D;AAAA,EAEA,UAAsB;AACrB,WAAO,IAAI,WAAW,2BAAU,OAAO,GAAG,QAAQ,KAAK,MAAM,CAAC;AAAA,EAC/D;AAAA,EAEA,OAAO,UAAU,OAA2B;AAC3C,WAAO,IAAI,OAAO,2BAAU,OAAO,GAAG,UAAU,KAAK,CAAC;AAAA,EACvD;AAAA,EAEA,OAAO,WAAW,KAAqB;AACtC,WAAO,IAAI,OAAO,OAAO,GAAG,CAAC;AAAA,EAC9B;AACD;",
+  "names": []
+}

package/dist/cjs/client.d.ts

@@ -0,0 +1,83 @@
+import type { SuiClient } from '@mysten/sui/client';
+import { DemType, KemType } from './encrypt.js';
+import type { KeyServer } from './key-server.js';
+import type { SessionKey } from './session-key.js';
+/**
+ * Configuration options for initializing a SealClient
+ * @property serverObjectIds: Array of object IDs for the key servers to use.
+ * @property verifyKeyServers: Whether to verify the key servers' authenticity.
+ * 	 Should be false if servers are pre-verified (e.g., getAllowlistedKeyServers).
+ * 	 Defaults to true.
+ * @property timeout: Timeout in milliseconds for network requests. Defaults to 10 seconds.
+ */
+export interface SealClientOptions {
+    suiClient: SuiClient;
+    serverObjectIds: string[];
+    verifyKeyServers?: boolean;
+    timeout?: number;
+}
+export declare class SealClient {
+    #private;
+    constructor(options: SealClientOptions);
+    /**
+     * Return an encrypted message under the identity.
+     *
+     * @param kemType - The type of KEM to use.
+     * @param demType - The type of DEM to use.
+     * @param threshold - The threshold for the TSS encryption.
+     * @param packageId - the packageId namespace.
+     * @param id - the identity to use.
+     * @param data - the data to encrypt.
+     * @param aad - optional additional authenticated data.
+     * @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 symmetric key can be used to decrypt, it should not be shared but can be used e.g. for backup.
+     */
+    encrypt({ kemType, demType, threshold, packageId, id, data, aad, }: {
+        kemType?: KemType;
+        demType?: DemType;
+        threshold: number;
+        packageId: string;
+        id: string;
+        data: Uint8Array;
+        aad?: Uint8Array;
+    }): Promise<{
+        encryptedObject: Uint8Array;
+        key: Uint8Array;
+    }>;
+    /**
+     * Decrypt the given encrypted bytes using cached keys.
+     * Calls fetchKeys in case one or more of the required keys is not cached yet.
+     * The function throws an error if the client's key servers are not a subset of
+     * the encrypted object's key servers (including the same weights) or if the
+     * threshold cannot be met.
+     *
+     * @param data - The encrypted bytes to decrypt.
+     * @param sessionKey - The session key to use.
+     * @param txBytes - The transaction bytes to use (that calls seal_approve* functions).
+     * @returns - The decrypted plaintext corresponding to ciphertext.
+     */
+    decrypt({ data, sessionKey, txBytes, }: {
+        data: Uint8Array;
+        sessionKey: SessionKey;
+        txBytes: Uint8Array;
+    }): Promise<Uint8Array<ArrayBufferLike>>;
+    getKeyServers(): Promise<KeyServer[]>;
+    /**
+     * Fetch keys from the key servers and update the cache.
+     *
+     * It is recommended to call this function once for all ids of all encrypted obejcts if
+     * there are multiple, then call decrypt for each object. This avoids calling fetchKey
+     * individually for each decrypt.
+     *
+     * @param ids - The ids of the encrypted objects.
+     * @param txBytes - The transaction bytes to use (that calls seal_approve* functions).
+     * @param sessionKey - The session key to use.
+     * @param threshold - The threshold for the TSS encryptions. The function returns when a threshold of key servers had returned keys for all ids.
+     */
+    fetchKeys({ ids, txBytes, sessionKey, threshold, }: {
+        ids: string[];
+        txBytes: Uint8Array;
+        sessionKey: SessionKey;
+        threshold: number;
+    }): Promise<void>;
+}