@mysten/seal 0.0.0-experimental-20250330082435

package/dist/esm/ibe.d.ts

@@ -0,0 +1,63 @@
+import type { IBEEncryptions } from './bcs.js';
+import { G1Element, G2Element } from './bls12381.js';
+import type { KeyServer } from './key-server.js';
+/**
+ * The domain separation tag for the hash-to-group function.
+ */
+export declare const DST: Uint8Array;
+/**
+ * The domain separation tag for the signing proof of possession.
+ */
+export declare const DST_POP: Uint8Array;
+/**
+ * The interface for the key servers.
+ */
+export declare abstract class IBEServers {
+    objectIds: string[];
+    constructor(objectIds: string[]);
+    /**
+     * The number of key servers.
+     */
+    size(): number;
+    /**
+     * Encrypt a batch of messages for the given identity.
+     *
+     * @param id The identity.
+     * @param msgAndIndices The messages and the corresponding indices of the share being encrypted.
+     * @returns The encrypted messages.
+     */
+    abstract encryptBatched(id: Uint8Array, msgAndIndices: {
+        msg: Uint8Array;
+        index: number;
+    }[], randomnessKey: Uint8Array): typeof IBEEncryptions.$inferType;
+}
+/**
+ * Identity-based encryption based on the Boneh-Franklin IBE scheme.
+ * This object represents a set of key servers that can be used to encrypt messages for a given identity.
+ */
+export declare class BonehFranklinBLS12381Services extends IBEServers {
+    readonly publicKeys: G2Element[];
+    constructor(services: KeyServer[]);
+    encryptBatched(id: Uint8Array, msgAndIndices: {
+        msg: Uint8Array;
+        index: number;
+    }[], randomnessKey: Uint8Array): typeof IBEEncryptions.$inferType;
+    /**
+     * Returns true if the user secret key is valid for the given public key and id.
+     * @param user_secret_key - The user secret key.
+     * @param id - The identity.
+     * @param public_key - The public key.
+     * @returns True if the user secret key is valid for the given public key and id.
+     */
+    static verifyUserSecretKey(userSecretKey: G1Element, id: string, publicKey: G2Element): boolean;
+    /**
+     * Identity-based decryption.
+     *
+     * @param nonce The encryption nonce.
+     * @param sk The user secret key.
+     * @param ciphertext The encrypted message.
+     * @param info An info parameter also included in the KDF.
+     * @returns The decrypted message.
+     */
+    static decrypt(nonce: G2Element, sk: G1Element, ciphertext: Uint8Array, id: Uint8Array, [objectId, index]: [string, number]): Uint8Array;
+}

package/dist/esm/ibe.js

@@ -0,0 +1,84 @@
+import { fromHex } from "@mysten/bcs";
+import { G1Element, G2Element, Scalar } from "./bls12381.js";
+import { kdf } from "./kdf.js";
+import { xor } from "./utils.js";
+const DST = new TextEncoder().encode("SUI-SEAL-IBE-BLS12381-00");
+const DST_POP = new TextEncoder().encode("SUI-SEAL-IBE-BLS12381-POP-00");
+class IBEServers {
+  constructor(objectIds) {
+    this.objectIds = objectIds;
+  }
+  /**
+   * The number of key servers.
+   */
+  size() {
+    return this.objectIds.length;
+  }
+}
+class BonehFranklinBLS12381Services extends IBEServers {
+  constructor(services) {
+    super(services.map((service) => service.objectId));
+    this.publicKeys = services.map((service) => G2Element.fromBytes(service.pk));
+  }
+  encryptBatched(id, msgAndIndices, randomnessKey) {
+    if (this.publicKeys.length === 0 || this.publicKeys.length !== msgAndIndices.length) {
+      throw new Error("Invalid public keys");
+    }
+    const [r, nonce, keys] = encapBatched(this.publicKeys, id);
+    const encryptedShares = msgAndIndices.map(
+      (msgAndIndex, i) => xor(msgAndIndex.msg, kdf(keys[i], nonce, id, this.objectIds[i], msgAndIndex.index))
+    );
+    const encryptedRandomness = xor(randomnessKey, r.toBytes());
+    return {
+      BonehFranklinBLS12381: {
+        nonce: nonce.toBytes(),
+        encryptedShares,
+        encryptedRandomness
+      },
+      $kind: "BonehFranklinBLS12381"
+    };
+  }
+  /**
+   * Returns true if the user secret key is valid for the given public key and id.
+   * @param user_secret_key - The user secret key.
+   * @param id - The identity.
+   * @param public_key - The public key.
+   * @returns True if the user secret key is valid for the given public key and id.
+   */
+  static verifyUserSecretKey(userSecretKey, id, publicKey) {
+    const lhs = userSecretKey.pairing(G2Element.generator()).toBytes();
+    const rhs = G1Element.hashToCurve(fromHex(id)).pairing(publicKey).toBytes();
+    return lhs.length === rhs.length && lhs.every((value, index) => value === rhs[index]);
+  }
+  /**
+   * Identity-based decryption.
+   *
+   * @param nonce The encryption nonce.
+   * @param sk The user secret key.
+   * @param ciphertext The encrypted message.
+   * @param info An info parameter also included in the KDF.
+   * @returns The decrypted message.
+   */
+  static decrypt(nonce, sk, ciphertext, id, [objectId, index]) {
+    return xor(ciphertext, kdf(decap(nonce, sk), nonce, id, objectId, index));
+  }
+}
+function encapBatched(publicKeys, id) {
+  if (publicKeys.length === 0) {
+    throw new Error("No public keys provided");
+  }
+  const r = Scalar.random();
+  const nonce = G2Element.generator().multiply(r);
+  const gid = G1Element.hashToCurve(id).multiply(r);
+  return [r, nonce, publicKeys.map((public_key) => gid.pairing(public_key))];
+}
+function decap(nonce, usk) {
+  return usk.pairing(nonce);
+}
+export {
+  BonehFranklinBLS12381Services,
+  DST,
+  DST_POP,
+  IBEServers
+};
+//# sourceMappingURL=ibe.js.map

package/dist/esm/ibe.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ibe.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 type { GTElement } from './bls12381.js';\nimport { G1Element, G2Element, Scalar } from './bls12381.js';\nimport { kdf } from './kdf.js';\nimport type { KeyServer } from './key-server.js';\nimport { xor } from './utils.js';\n\n/**\n * The domain separation tag for the hash-to-group function.\n */\nexport const DST: Uint8Array = new TextEncoder().encode('SUI-SEAL-IBE-BLS12381-00');\n\n/**\n * The domain separation tag for the signing proof of possession.\n */\nexport const DST_POP: Uint8Array = new TextEncoder().encode('SUI-SEAL-IBE-BLS12381-POP-00');\n\n/**\n * The interface for the key servers.\n */\nexport abstract class IBEServers {\n\tobjectIds: string[];\n\n\tconstructor(objectIds: string[]) {\n\t\tthis.objectIds = objectIds;\n\t}\n\n\t/**\n\t * The number of key servers.\n\t */\n\tsize(): number {\n\t\treturn this.objectIds.length;\n\t}\n\n\t/**\n\t * Encrypt a batch of messages for the given identity.\n\t *\n\t * @param id The identity.\n\t * @param msgAndIndices The messages and the corresponding indices of the share being encrypted.\n\t * @returns The encrypted messages.\n\t */\n\tabstract encryptBatched(\n\t\tid: Uint8Array,\n\t\tmsgAndIndices: { msg: Uint8Array; index: number }[],\n\t\trandomnessKey: Uint8Array,\n\t): typeof IBEEncryptions.$inferType;\n}\n\n/**\n * Identity-based encryption based on the Boneh-Franklin IBE scheme.\n * This object represents a set of key servers that can be used to encrypt messages for a given identity.\n */\nexport class BonehFranklinBLS12381Services extends IBEServers {\n\treadonly publicKeys: G2Element[];\n\n\tconstructor(services: KeyServer[]) {\n\t\tsuper(services.map((service) => service.objectId));\n\t\tthis.publicKeys = services.map((service) => G2Element.fromBytes(service.pk));\n\t}\n\n\tencryptBatched(\n\t\tid: Uint8Array,\n\t\tmsgAndIndices: { msg: Uint8Array; index: number }[],\n\t\trandomnessKey: Uint8Array,\n\t): typeof IBEEncryptions.$inferType {\n\t\tif (this.publicKeys.length === 0 || this.publicKeys.length !== msgAndIndices.length) {\n\t\t\tthrow new Error('Invalid public keys');\n\t\t}\n\t\tconst [r, nonce, keys] = encapBatched(this.publicKeys, id);\n\t\tconst encryptedShares = msgAndIndices.map((msgAndIndex, i) =>\n\t\t\txor(msgAndIndex.msg, kdf(keys[i], nonce, id, this.objectIds[i], msgAndIndex.index)),\n\t\t);\n\t\tconst encryptedRandomness = xor(randomnessKey, r.toBytes());\n\n\t\treturn {\n\t\t\tBonehFranklinBLS12381: {\n\t\t\t\tnonce: nonce.toBytes(),\n\t\t\t\tencryptedShares,\n\t\t\t\tencryptedRandomness,\n\t\t\t},\n\t\t\t$kind: 'BonehFranklinBLS12381',\n\t\t};\n\t}\n\n\t/**\n\t * Returns true if the user secret key is valid for the given public key and id.\n\t * @param user_secret_key - The user secret key.\n\t * @param id - The identity.\n\t * @param public_key - The public key.\n\t * @returns True if the user secret key is valid for the given public key and id.\n\t */\n\tstatic verifyUserSecretKey(userSecretKey: G1Element, id: string, publicKey: G2Element): boolean {\n\t\tconst lhs = userSecretKey.pairing(G2Element.generator()).toBytes();\n\t\tconst rhs = G1Element.hashToCurve(fromHex(id)).pairing(publicKey).toBytes();\n\t\treturn lhs.length === rhs.length && lhs.every((value, index) => value === rhs[index]);\n\t}\n\n\t/**\n\t * Identity-based decryption.\n\t *\n\t * @param nonce The encryption nonce.\n\t * @param sk The user secret key.\n\t * @param ciphertext The encrypted message.\n\t * @param info An info parameter also included in the KDF.\n\t * @returns The decrypted message.\n\t */\n\tstatic decrypt(\n\t\tnonce: G2Element,\n\t\tsk: G1Element,\n\t\tciphertext: Uint8Array,\n\t\tid: Uint8Array,\n\t\t[objectId, index]: [string, number],\n\t): Uint8Array {\n\t\treturn xor(ciphertext, kdf(decap(nonce, sk), nonce, id, objectId, index));\n\t}\n}\n\n/**\n * Batched identity-based key-encapsulation mechanism: encapsulate multiple keys for given identity using different key servers.\n *\n * @param publicKeys Public keys for a set of key servers.\n * @param id The identity used to encapsulate the keys.\n * @returns A common nonce of the keys and a list of keys, 32 bytes each.\n */\nfunction encapBatched(publicKeys: G2Element[], id: Uint8Array): [Scalar, G2Element, GTElement[]] {\n\tif (publicKeys.length === 0) {\n\t\tthrow new Error('No public keys provided');\n\t}\n\tconst r = Scalar.random();\n\tconst nonce = G2Element.generator().multiply(r);\n\tconst gid = G1Element.hashToCurve(id).multiply(r);\n\treturn [r, nonce, publicKeys.map((public_key) => gid.pairing(public_key))];\n}\n\n/**\n * Decapsulate a key using a user secret key and the nonce.\n *\n * @param usk The user secret key.\n * @param nonce The nonce.\n * @returns The encapsulated key.\n */\nfunction decap(nonce: G2Element, usk: G1Element): GTElement {\n\treturn usk.pairing(nonce);\n}\n"],
+  "mappings": "AAGA,SAAS,eAAe;AAIxB,SAAS,WAAW,WAAW,cAAc;AAC7C,SAAS,WAAW;AAEpB,SAAS,WAAW;AAKb,MAAM,MAAkB,IAAI,YAAY,EAAE,OAAO,0BAA0B;AAK3E,MAAM,UAAsB,IAAI,YAAY,EAAE,OAAO,8BAA8B;AAKnF,MAAe,WAAW;AAAA,EAGhC,YAAY,WAAqB;AAChC,SAAK,YAAY;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKA,OAAe;AACd,WAAO,KAAK,UAAU;AAAA,EACvB;AAcD;AAMO,MAAM,sCAAsC,WAAW;AAAA,EAG7D,YAAY,UAAuB;AAClC,UAAM,SAAS,IAAI,CAAC,YAAY,QAAQ,QAAQ,CAAC;AACjD,SAAK,aAAa,SAAS,IAAI,CAAC,YAAY,UAAU,UAAU,QAAQ,EAAE,CAAC;AAAA,EAC5E;AAAA,EAEA,eACC,IACA,eACA,eACmC;AACnC,QAAI,KAAK,WAAW,WAAW,KAAK,KAAK,WAAW,WAAW,cAAc,QAAQ;AACpF,YAAM,IAAI,MAAM,qBAAqB;AAAA,IACtC;AACA,UAAM,CAAC,GAAG,OAAO,IAAI,IAAI,aAAa,KAAK,YAAY,EAAE;AACzD,UAAM,kBAAkB,cAAc;AAAA,MAAI,CAAC,aAAa,MACvD,IAAI,YAAY,KAAK,IAAI,KAAK,CAAC,GAAG,OAAO,IAAI,KAAK,UAAU,CAAC,GAAG,YAAY,KAAK,CAAC;AAAA,IACnF;AACA,UAAM,sBAAsB,IAAI,eAAe,EAAE,QAAQ,CAAC;AAE1D,WAAO;AAAA,MACN,uBAAuB;AAAA,QACtB,OAAO,MAAM,QAAQ;AAAA,QACrB;AAAA,QACA;AAAA,MACD;AAAA,MACA,OAAO;AAAA,IACR;AAAA,EACD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAO,oBAAoB,eAA0B,IAAY,WAA+B;AAC/F,UAAM,MAAM,cAAc,QAAQ,UAAU,UAAU,CAAC,EAAE,QAAQ;AACjE,UAAM,MAAM,UAAU,YAAY,QAAQ,EAAE,CAAC,EAAE,QAAQ,SAAS,EAAE,QAAQ;AAC1E,WAAO,IAAI,WAAW,IAAI,UAAU,IAAI,MAAM,CAAC,OAAO,UAAU,UAAU,IAAI,KAAK,CAAC;AAAA,EACrF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAO,QACN,OACA,IACA,YACA,IACA,CAAC,UAAU,KAAK,GACH;AACb,WAAO,IAAI,YAAY,IAAI,MAAM,OAAO,EAAE,GAAG,OAAO,IAAI,UAAU,KAAK,CAAC;AAAA,EACzE;AACD;AASA,SAAS,aAAa,YAAyB,IAAkD;AAChG,MAAI,WAAW,WAAW,GAAG;AAC5B,UAAM,IAAI,MAAM,yBAAyB;AAAA,EAC1C;AACA,QAAM,IAAI,OAAO,OAAO;AACxB,QAAM,QAAQ,UAAU,UAAU,EAAE,SAAS,CAAC;AAC9C,QAAM,MAAM,UAAU,YAAY,EAAE,EAAE,SAAS,CAAC;AAChD,SAAO,CAAC,GAAG,OAAO,WAAW,IAAI,CAAC,eAAe,IAAI,QAAQ,UAAU,CAAC,CAAC;AAC1E;AASA,SAAS,MAAM,OAAkB,KAA2B;AAC3D,SAAO,IAAI,QAAQ,KAAK;AACzB;",
+  "names": []
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export { getAllowlistedKeyServers } from './key-server.js';
+export { SealClient, type SealClientOptions } from './client.js';
+export { SessionKey } from './session-key.js';
+export * from './error.js';

package/dist/esm/index.js

@@ -0,0 +1,10 @@
+import { getAllowlistedKeyServers } from "./key-server.js";
+import { SealClient } from "./client.js";
+import { SessionKey } from "./session-key.js";
+export * from "./error.js";
+export {
+  SealClient,
+  SessionKey,
+  getAllowlistedKeyServers
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport { getAllowlistedKeyServers } from './key-server.js';\nexport { SealClient, type SealClientOptions } from './client.js';\nexport { SessionKey } from './session-key.js';\nexport * from './error.js';\n"],
+  "mappings": "AAGA,SAAS,gCAAgC;AACzC,SAAS,kBAA0C;AACnD,SAAS,kBAAkB;AAC3B,cAAc;",
+  "names": []
+}

package/dist/esm/kdf.d.ts

@@ -0,0 +1,14 @@
+import type { G2Element, GTElement } from './bls12381.js';
+/**
+ * The default key derivation function.
+ *
+ * @param element The GTElement to derive the key from.
+ * @param info Optional context and application specific information.
+ * @returns The derived key.
+ */
+export declare function kdf(element: GTElement, nonce: G2Element, id: Uint8Array, objectId: string, index: number): Uint8Array;
+export declare enum KeyPurpose {
+    EncryptedRandomness = 0,
+    DEM = 1
+}
+export declare function deriveKey(purpose: KeyPurpose, baseKey: Uint8Array): Uint8Array;

package/dist/esm/kdf.js

@@ -0,0 +1,44 @@
+import { fromHex } from "@mysten/bcs";
+import { hkdf } from "@noble/hashes/hkdf";
+import { hmac } from "@noble/hashes/hmac";
+import { sha3_256 } from "@noble/hashes/sha3";
+import { G1Element } from "./bls12381.js";
+function kdf(element, nonce, id, objectId, index) {
+  const GT_ELEMENT_BYTE_LENGTH = 576;
+  const PERMUTATION = [0, 2, 4, 1, 3, 5];
+  const COEFFICIENT_SIZE = GT_ELEMENT_BYTE_LENGTH / PERMUTATION.length;
+  const bytes = element.toBytes();
+  let permutedBytes = new Uint8Array(GT_ELEMENT_BYTE_LENGTH);
+  PERMUTATION.forEach((pi, i) => {
+    permutedBytes.set(
+      bytes.slice(i * COEFFICIENT_SIZE, (i + 1) * COEFFICIENT_SIZE),
+      pi * COEFFICIENT_SIZE
+    );
+  });
+  const inputBytes = new Uint8Array([
+    ...permutedBytes,
+    ...nonce.toBytes(),
+    ...G1Element.hashToCurve(id).toBytes()
+  ]);
+  const info = new Uint8Array([...fromHex(objectId), index]);
+  return hkdf(sha3_256, inputBytes, "", info, 32);
+}
+var KeyPurpose = /* @__PURE__ */ ((KeyPurpose2) => {
+  KeyPurpose2[KeyPurpose2["EncryptedRandomness"] = 0] = "EncryptedRandomness";
+  KeyPurpose2[KeyPurpose2["DEM"] = 1] = "DEM";
+  return KeyPurpose2;
+})(KeyPurpose || {});
+function deriveKey(purpose, baseKey) {
+  switch (purpose) {
+    case 0 /* EncryptedRandomness */:
+      return hmac(sha3_256, baseKey, new Uint8Array([0]));
+    case 1 /* DEM */:
+      return hmac(sha3_256, baseKey, new Uint8Array([1]));
+  }
+}
+export {
+  KeyPurpose,
+  deriveKey,
+  kdf
+};
+//# sourceMappingURL=kdf.js.map

package/dist/esm/kdf.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kdf.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromHex } from '@mysten/bcs';\nimport { hkdf } from '@noble/hashes/hkdf';\nimport { hmac } from '@noble/hashes/hmac';\nimport { sha3_256 } from '@noble/hashes/sha3';\n\nimport { G1Element } from './bls12381.js';\nimport type { G2Element, GTElement } from './bls12381.js';\n\n/**\n * The default key derivation function.\n *\n * @param element The GTElement to derive the key from.\n * @param info Optional context and application specific information.\n * @returns The derived key.\n */\nexport function kdf(\n\telement: GTElement,\n\tnonce: G2Element,\n\tid: Uint8Array,\n\tobjectId: string,\n\tindex: number,\n): Uint8Array {\n\t// This permutation flips the order of 6 pairs of coefficients of the GT element.\n\t// The permutation may be computed as:\n\t// for i in 0..3 {\n\t//   for j in 0..2 {\n\t//     PERMUTATION[i + j * 3] = i * 2 + j;\n\t//   }\n\t// }\n\tconst GT_ELEMENT_BYTE_LENGTH = 576;\n\tconst PERMUTATION = [0, 2, 4, 1, 3, 5];\n\tconst COEFFICIENT_SIZE = GT_ELEMENT_BYTE_LENGTH / PERMUTATION.length;\n\n\tconst bytes = element.toBytes();\n\tlet permutedBytes = new Uint8Array(GT_ELEMENT_BYTE_LENGTH);\n\tPERMUTATION.forEach((pi, i) => {\n\t\tpermutedBytes.set(\n\t\t\tbytes.slice(i * COEFFICIENT_SIZE, (i + 1) * COEFFICIENT_SIZE),\n\t\t\tpi * COEFFICIENT_SIZE,\n\t\t);\n\t});\n\tconst inputBytes = new Uint8Array([\n\t\t...permutedBytes,\n\t\t...nonce.toBytes(),\n\t\t...G1Element.hashToCurve(id).toBytes(),\n\t]);\n\tconst info = new Uint8Array([...fromHex(objectId), index]);\n\treturn hkdf(sha3_256, inputBytes, '', info, 32);\n}\n\nexport enum KeyPurpose {\n\tEncryptedRandomness,\n\tDEM,\n}\n\nexport function deriveKey(purpose: KeyPurpose, baseKey: Uint8Array): Uint8Array {\n\tswitch (purpose) {\n\t\tcase KeyPurpose.EncryptedRandomness:\n\t\t\treturn hmac(sha3_256, baseKey, new Uint8Array([0]));\n\t\tcase KeyPurpose.DEM:\n\t\t\treturn hmac(sha3_256, baseKey, new Uint8Array([1]));\n\t}\n}\n"],
+  "mappings": "AAGA,SAAS,eAAe;AACxB,SAAS,YAAY;AACrB,SAAS,YAAY;AACrB,SAAS,gBAAgB;AAEzB,SAAS,iBAAiB;AAUnB,SAAS,IACf,SACA,OACA,IACA,UACA,OACa;AAQb,QAAM,yBAAyB;AAC/B,QAAM,cAAc,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AACrC,QAAM,mBAAmB,yBAAyB,YAAY;AAE9D,QAAM,QAAQ,QAAQ,QAAQ;AAC9B,MAAI,gBAAgB,IAAI,WAAW,sBAAsB;AACzD,cAAY,QAAQ,CAAC,IAAI,MAAM;AAC9B,kBAAc;AAAA,MACb,MAAM,MAAM,IAAI,mBAAmB,IAAI,KAAK,gBAAgB;AAAA,MAC5D,KAAK;AAAA,IACN;AAAA,EACD,CAAC;AACD,QAAM,aAAa,IAAI,WAAW;AAAA,IACjC,GAAG;AAAA,IACH,GAAG,MAAM,QAAQ;AAAA,IACjB,GAAG,UAAU,YAAY,EAAE,EAAE,QAAQ;AAAA,EACtC,CAAC;AACD,QAAM,OAAO,IAAI,WAAW,CAAC,GAAG,QAAQ,QAAQ,GAAG,KAAK,CAAC;AACzD,SAAO,KAAK,UAAU,YAAY,IAAI,MAAM,EAAE;AAC/C;AAEO,IAAK,aAAL,kBAAKA,gBAAL;AACN,EAAAA,wBAAA;AACA,EAAAA,wBAAA;AAFW,SAAAA;AAAA,GAAA;AAKL,SAAS,UAAU,SAAqB,SAAiC;AAC/E,UAAQ,SAAS;AAAA,IAChB,KAAK;AACJ,aAAO,KAAK,UAAU,SAAS,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAAA,IACnD,KAAK;AACJ,aAAO,KAAK,UAAU,SAAS,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAAA,EACpD;AACD;",
+  "names": ["KeyPurpose"]
+}

package/dist/esm/key-server.d.ts

@@ -0,0 +1,38 @@
+import type { SuiClient } from '@mysten/sui/client';
+export type KeyServer = {
+    objectId: string;
+    name: string;
+    url: string;
+    keyType: KeyServerType;
+    pk: Uint8Array;
+};
+export declare enum KeyServerType {
+    BonehFranklinBLS12381 = 0
+}
+/**
+ * Returns a static list of Seal key server object ids that the dapp can choose to use.
+ * @param network - The network to use.
+ * @returns The object id's of the key servers.
+ */
+export declare function getAllowlistedKeyServers(network: 'testnet' | 'mainnet'): string[];
+/**
+ * Given a list of key server object IDs, returns a list of SealKeyServer
+ * from onchain state containing name, objectId, URL and pk.
+ *
+ * @param objectIds - The key server object IDs.
+ * @param client - The SuiClient to use.
+ * @returns - An array of SealKeyServer.
+ */
+export declare function retrieveKeyServers({ objectIds, client, }: {
+    objectIds: string[];
+    client: SuiClient;
+}): Promise<KeyServer[]>;
+/**
+ * Given a KeyServer, fetch the proof of possession (PoP) from the URL and verify it
+ * against the pubkey. This should be used only rarely when the dapp uses a dynamic
+ * set of key servers.
+ *
+ * @param server - The KeyServer to verify.
+ * @returns - True if the key server is valid, false otherwise.
+ */
+export declare function verifyKeyServer(server: KeyServer, timeout: number): Promise<boolean>;

package/dist/esm/key-server.js

@@ -0,0 +1,86 @@
+import { fromBase64, fromHex } from "@mysten/bcs";
+import { bls12_381 } from "@noble/curves/bls12-381";
+import { KeyServerMove } from "./bcs.js";
+import {
+  InvalidGetObjectError,
+  SealAPIError,
+  UnsupportedFeatureError,
+  UnsupportedNetworkError
+} from "./error.js";
+import { DST_POP } from "./ibe.js";
+import { PACKAGE_VERSION } from "./version.js";
+var KeyServerType = /* @__PURE__ */ ((KeyServerType2) => {
+  KeyServerType2[KeyServerType2["BonehFranklinBLS12381"] = 0] = "BonehFranklinBLS12381";
+  return KeyServerType2;
+})(KeyServerType || {});
+function getAllowlistedKeyServers(network) {
+  if (network === "testnet") {
+    return [
+      "0xb35a7228d8cf224ad1e828c0217c95a5153bafc2906d6f9c178197dce26fbcf8",
+      "0x2d6cde8a9d9a65bde3b0a346566945a63b4bfb70e9a06c41bdb70807e2502b06"
+    ];
+  } else {
+    throw new UnsupportedNetworkError(`Unsupported network ${network}`);
+  }
+}
+async function retrieveKeyServers({
+  objectIds,
+  client
+}) {
+  return await Promise.all(
+    objectIds.map(async (objectId) => {
+      const res = await client.getObject({
+        id: objectId,
+        options: {
+          showBcs: true
+        }
+      });
+      if (!res || res.error || !res.data) {
+        throw new InvalidGetObjectError(`KeyServer ${objectId} not found; ${res.error}`);
+      }
+      if (!res.data.bcs || !("bcsBytes" in res.data.bcs)) {
+        throw new InvalidGetObjectError(
+          `Invalid KeyServer query: ${objectId}, expected object, got package`
+        );
+      }
+      let ks = KeyServerMove.parse(fromBase64(res.data.bcs.bcsBytes));
+      if (ks.keyType !== 0) {
+        throw new UnsupportedFeatureError(`Unsupported key type ${ks.keyType}`);
+      }
+      return {
+        objectId,
+        name: ks.name,
+        url: ks.url,
+        keyType: 0 /* BonehFranklinBLS12381 */,
+        pk: new Uint8Array(ks.pk)
+      };
+    })
+  );
+}
+async function verifyKeyServer(server, timeout) {
+  const requestId = crypto.randomUUID();
+  const response = await fetch(server.url + "/v1/service", {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Request-Id": requestId,
+      "Client-Sdk-Type": "typescript",
+      "Client-Sdk-Version": PACKAGE_VERSION
+    },
+    signal: AbortSignal.timeout(timeout)
+  });
+  await SealAPIError.assertResponse(response, requestId);
+  const serviceResponse = await response.json();
+  if (serviceResponse.service_id !== server.objectId) {
+    return false;
+  }
+  const fullMsg = new Uint8Array([...DST_POP, ...server.pk, ...fromHex(server.objectId)]);
+  return bls12_381.verifyShortSignature(fromBase64(serviceResponse.pop), fullMsg, server.pk);
+}
+export {
+  KeyServerType,
+  getAllowlistedKeyServers,
+  retrieveKeyServers,
+  verifyKeyServer
+};
+//# sourceMappingURL=key-server.js.map

package/dist/esm/key-server.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/key-server.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\nimport { fromBase64, fromHex } from '@mysten/bcs';\nimport type { SuiClient } from '@mysten/sui/client';\nimport { bls12_381 } from '@noble/curves/bls12-381';\n\nimport { KeyServerMove } from './bcs.js';\nimport {\n\tInvalidGetObjectError,\n\tSealAPIError,\n\tUnsupportedFeatureError,\n\tUnsupportedNetworkError,\n} from './error.js';\nimport { DST_POP } from './ibe.js';\nimport { PACKAGE_VERSION } from './version.js';\n\nexport type KeyServer = {\n\tobjectId: string;\n\tname: string;\n\turl: string;\n\tkeyType: KeyServerType;\n\tpk: Uint8Array;\n};\n\nexport enum KeyServerType {\n\tBonehFranklinBLS12381 = 0,\n}\n\n/**\n * Returns a static list of Seal key server object ids that the dapp can choose to use.\n * @param network - The network to use.\n * @returns The object id's of the key servers.\n */\nexport function getAllowlistedKeyServers(network: 'testnet' | 'mainnet'): string[] {\n\tif (network === 'testnet') {\n\t\treturn [\n\t\t\t'0xb35a7228d8cf224ad1e828c0217c95a5153bafc2906d6f9c178197dce26fbcf8',\n\t\t\t'0x2d6cde8a9d9a65bde3b0a346566945a63b4bfb70e9a06c41bdb70807e2502b06',\n\t\t];\n\t} else {\n\t\tthrow new UnsupportedNetworkError(`Unsupported network ${network}`);\n\t}\n}\n\n/**\n * Given a list of key server object IDs, returns a list of SealKeyServer\n * from onchain state containing name, objectId, URL and pk.\n *\n * @param objectIds - The key server object IDs.\n * @param client - The SuiClient to use.\n * @returns - An array of SealKeyServer.\n */\nexport async function retrieveKeyServers({\n\tobjectIds,\n\tclient,\n}: {\n\tobjectIds: string[];\n\tclient: SuiClient;\n}): Promise<KeyServer[]> {\n\t// todo: do not fetch the same object ID if this is fetched before.\n\treturn await Promise.all(\n\t\tobjectIds.map(async (objectId) => {\n\t\t\tconst res = await client.getObject({\n\t\t\t\tid: objectId,\n\t\t\t\toptions: {\n\t\t\t\t\tshowBcs: true,\n\t\t\t\t},\n\t\t\t});\n\t\t\tif (!res || res.error || !res.data) {\n\t\t\t\tthrow new InvalidGetObjectError(`KeyServer ${objectId} not found; ${res.error}`);\n\t\t\t}\n\n\t\t\tif (!res.data.bcs || !('bcsBytes' in res.data.bcs)) {\n\t\t\t\tthrow new InvalidGetObjectError(\n\t\t\t\t\t`Invalid KeyServer query: ${objectId}, expected object, got package`,\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tlet ks = KeyServerMove.parse(fromBase64(res.data.bcs!.bcsBytes));\n\t\t\tif (ks.keyType !== 0) {\n\t\t\t\tthrow new UnsupportedFeatureError(`Unsupported key type ${ks.keyType}`);\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tobjectId,\n\t\t\t\tname: ks.name,\n\t\t\t\turl: ks.url,\n\t\t\t\tkeyType: KeyServerType.BonehFranklinBLS12381,\n\t\t\t\tpk: new Uint8Array(ks.pk),\n\t\t\t};\n\t\t}),\n\t);\n}\n\n/**\n * Given a KeyServer, fetch the proof of possession (PoP) from the URL and verify it\n * against the pubkey. This should be used only rarely when the dapp uses a dynamic\n * set of key servers.\n *\n * @param server - The KeyServer to verify.\n * @returns - True if the key server is valid, false otherwise.\n */\nexport async function verifyKeyServer(server: KeyServer, timeout: number): Promise<boolean> {\n\tconst requestId = crypto.randomUUID();\n\tconst response = await fetch(server.url! + '/v1/service', {\n\t\tmethod: 'GET',\n\t\theaders: {\n\t\t\t'Content-Type': 'application/json',\n\t\t\t'Request-Id': requestId,\n\t\t\t'Client-Sdk-Type': 'typescript',\n\t\t\t'Client-Sdk-Version': PACKAGE_VERSION,\n\t\t},\n\t\tsignal: AbortSignal.timeout(timeout),\n\t});\n\n\tawait SealAPIError.assertResponse(response, requestId);\n\tconst serviceResponse = await response.json();\n\n\tif (serviceResponse.service_id !== server.objectId) {\n\t\treturn false;\n\t}\n\tconst fullMsg = new Uint8Array([...DST_POP, ...server.pk, ...fromHex(server.objectId)]);\n\treturn bls12_381.verifyShortSignature(fromBase64(serviceResponse.pop), fullMsg, server.pk);\n}\n"],
+  "mappings": "AAEA,SAAS,YAAY,eAAe;AAEpC,SAAS,iBAAiB;AAE1B,SAAS,qBAAqB;AAC9B;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACM;AACP,SAAS,eAAe;AACxB,SAAS,uBAAuB;AAUzB,IAAK,gBAAL,kBAAKA,mBAAL;AACN,EAAAA,8BAAA,2BAAwB,KAAxB;AADW,SAAAA;AAAA,GAAA;AASL,SAAS,yBAAyB,SAA0C;AAClF,MAAI,YAAY,WAAW;AAC1B,WAAO;AAAA,MACN;AAAA,MACA;AAAA,IACD;AAAA,EACD,OAAO;AACN,UAAM,IAAI,wBAAwB,uBAAuB,OAAO,EAAE;AAAA,EACnE;AACD;AAUA,eAAsB,mBAAmB;AAAA,EACxC;AAAA,EACA;AACD,GAGyB;AAExB,SAAO,MAAM,QAAQ;AAAA,IACpB,UAAU,IAAI,OAAO,aAAa;AACjC,YAAM,MAAM,MAAM,OAAO,UAAU;AAAA,QAClC,IAAI;AAAA,QACJ,SAAS;AAAA,UACR,SAAS;AAAA,QACV;AAAA,MACD,CAAC;AACD,UAAI,CAAC,OAAO,IAAI,SAAS,CAAC,IAAI,MAAM;AACnC,cAAM,IAAI,sBAAsB,aAAa,QAAQ,eAAe,IAAI,KAAK,EAAE;AAAA,MAChF;AAEA,UAAI,CAAC,IAAI,KAAK,OAAO,EAAE,cAAc,IAAI,KAAK,MAAM;AACnD,cAAM,IAAI;AAAA,UACT,4BAA4B,QAAQ;AAAA,QACrC;AAAA,MACD;AAEA,UAAI,KAAK,cAAc,MAAM,WAAW,IAAI,KAAK,IAAK,QAAQ,CAAC;AAC/D,UAAI,GAAG,YAAY,GAAG;AACrB,cAAM,IAAI,wBAAwB,wBAAwB,GAAG,OAAO,EAAE;AAAA,MACvE;AAEA,aAAO;AAAA,QACN;AAAA,QACA,MAAM,GAAG;AAAA,QACT,KAAK,GAAG;AAAA,QACR,SAAS;AAAA,QACT,IAAI,IAAI,WAAW,GAAG,EAAE;AAAA,MACzB;AAAA,IACD,CAAC;AAAA,EACF;AACD;AAUA,eAAsB,gBAAgB,QAAmB,SAAmC;AAC3F,QAAM,YAAY,OAAO,WAAW;AACpC,QAAM,WAAW,MAAM,MAAM,OAAO,MAAO,eAAe;AAAA,IACzD,QAAQ;AAAA,IACR,SAAS;AAAA,MACR,gBAAgB;AAAA,MAChB,cAAc;AAAA,MACd,mBAAmB;AAAA,MACnB,sBAAsB;AAAA,IACvB;AAAA,IACA,QAAQ,YAAY,QAAQ,OAAO;AAAA,EACpC,CAAC;AAED,QAAM,aAAa,eAAe,UAAU,SAAS;AACrD,QAAM,kBAAkB,MAAM,SAAS,KAAK;AAE5C,MAAI,gBAAgB,eAAe,OAAO,UAAU;AACnD,WAAO;AAAA,EACR;AACA,QAAM,UAAU,IAAI,WAAW,CAAC,GAAG,SAAS,GAAG,OAAO,IAAI,GAAG,QAAQ,OAAO,QAAQ,CAAC,CAAC;AACtF,SAAO,UAAU,qBAAqB,WAAW,gBAAgB,GAAG,GAAG,SAAS,OAAO,EAAE;AAC1F;",
+  "names": ["KeyServerType"]
+}

package/dist/esm/keys.d.ts

@@ -0,0 +1,17 @@
+import type { Certificate } from './session-key.js';
+/**
+ * Helper function to request all keys from URL with requestSig, txBytes, ephemeral pubkey.
+ * Then decrypt the Seal key with ephemeral secret key. Returns a list decryption keys with
+ * their full IDs.
+ *
+ * @param url - The URL of the key server.
+ * @param requestSig - The Base64 string of request signature.
+ * @param txBytes - The transaction bytes.
+ * @param encKey - The ephemeral secret key.
+ * @param certificate - The certificate.
+ * @returns - A list of full ID and the decrypted key.
+ */
+export declare function fetchKeysForAllIds(url: string, requestSig: string, txBytes: Uint8Array, encKey: Uint8Array, certificate: Certificate, timeout: number, signal?: AbortSignal): Promise<{
+    fullId: string;
+    key: Uint8Array;
+}[]>;

package/dist/esm/keys.js

@@ -0,0 +1,41 @@
+import { fromBase64, toBase64, toHex } from "@mysten/bcs";
+import { elgamalDecrypt, toPublicKey, toVerificationKey } from "./elgamal.js";
+import { SealAPIError } from "./error.js";
+import { PACKAGE_VERSION } from "./version.js";
+async function fetchKeysForAllIds(url, requestSig, txBytes, encKey, certificate, timeout, signal) {
+  const encKeyPk = toPublicKey(encKey);
+  const encVerificationKey = toVerificationKey(encKey);
+  const body = {
+    ptb: toBase64(txBytes.slice(1)),
+    // removes the byte of the transaction type version
+    enc_key: toBase64(encKeyPk),
+    enc_verification_key: toBase64(encVerificationKey),
+    request_signature: requestSig,
+    // already b64
+    certificate
+  };
+  const timeoutSignal = AbortSignal.timeout(timeout);
+  const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+  const requestId = crypto.randomUUID();
+  const response = await fetch(url + "/v1/fetch_key", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Request-Id": requestId,
+      "Client-Sdk-Type": "typescript",
+      "Client-Sdk-Version": PACKAGE_VERSION
+    },
+    body: JSON.stringify(body),
+    signal: combinedSignal
+  });
+  await SealAPIError.assertResponse(response, requestId);
+  const resp = await response.json();
+  return resp.decryption_keys.map((dk) => ({
+    fullId: toHex(new Uint8Array(dk.id)),
+    key: elgamalDecrypt(encKey, dk.encrypted_key.map(fromBase64))
+  }));
+}
+export {
+  fetchKeysForAllIds
+};
+//# sourceMappingURL=keys.js.map

package/dist/esm/keys.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/keys.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase64, toBase64, toHex } from '@mysten/bcs';\n\nimport { elgamalDecrypt, toPublicKey, toVerificationKey } from './elgamal.js';\nimport { SealAPIError } from './error.js';\nimport type { Certificate } from './session-key.js';\nimport { PACKAGE_VERSION } from './version.js';\n\n/**\n * Helper function to request all keys from URL with requestSig, txBytes, ephemeral pubkey.\n * Then decrypt the Seal key with ephemeral secret key. Returns a list decryption keys with\n * their full IDs.\n *\n * @param url - The URL of the key server.\n * @param requestSig - The Base64 string of request signature.\n * @param txBytes - The transaction bytes.\n * @param encKey - The ephemeral secret key.\n * @param certificate - The certificate.\n * @returns - A list of full ID and the decrypted key.\n */\nexport async function fetchKeysForAllIds(\n\turl: string,\n\trequestSig: string,\n\ttxBytes: Uint8Array,\n\tencKey: Uint8Array,\n\tcertificate: Certificate,\n\ttimeout: number,\n\tsignal?: AbortSignal,\n): Promise<{ fullId: string; key: Uint8Array }[]> {\n\tconst encKeyPk = toPublicKey(encKey);\n\tconst encVerificationKey = toVerificationKey(encKey);\n\tconst body = {\n\t\tptb: toBase64(txBytes.slice(1)), // removes the byte of the transaction type version\n\t\tenc_key: toBase64(encKeyPk),\n\t\tenc_verification_key: toBase64(encVerificationKey),\n\t\trequest_signature: requestSig, // already b64\n\t\tcertificate,\n\t};\n\n\tconst timeoutSignal = AbortSignal.timeout(timeout);\n\tconst combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;\n\n\tconst requestId = crypto.randomUUID();\n\tconst response = await fetch(url + '/v1/fetch_key', {\n\t\tmethod: 'POST',\n\t\theaders: {\n\t\t\t'Content-Type': 'application/json',\n\t\t\t'Request-Id': requestId,\n\t\t\t'Client-Sdk-Type': 'typescript',\n\t\t\t'Client-Sdk-Version': PACKAGE_VERSION,\n\t\t},\n\t\tbody: JSON.stringify(body),\n\t\tsignal: combinedSignal,\n\t});\n\tawait SealAPIError.assertResponse(response, requestId);\n\n\tconst resp = await response.json();\n\treturn resp.decryption_keys.map((dk: { id: Uint8Array; encrypted_key: [string, string] }) => ({\n\t\tfullId: toHex(new Uint8Array(dk.id)),\n\t\tkey: elgamalDecrypt(encKey, dk.encrypted_key.map(fromBase64) as [Uint8Array, Uint8Array]),\n\t}));\n}\n"],
+  "mappings": "AAGA,SAAS,YAAY,UAAU,aAAa;AAE5C,SAAS,gBAAgB,aAAa,yBAAyB;AAC/D,SAAS,oBAAoB;AAE7B,SAAS,uBAAuB;AAchC,eAAsB,mBACrB,KACA,YACA,SACA,QACA,aACA,SACA,QACiD;AACjD,QAAM,WAAW,YAAY,MAAM;AACnC,QAAM,qBAAqB,kBAAkB,MAAM;AACnD,QAAM,OAAO;AAAA,IACZ,KAAK,SAAS,QAAQ,MAAM,CAAC,CAAC;AAAA;AAAA,IAC9B,SAAS,SAAS,QAAQ;AAAA,IAC1B,sBAAsB,SAAS,kBAAkB;AAAA,IACjD,mBAAmB;AAAA;AAAA,IACnB;AAAA,EACD;AAEA,QAAM,gBAAgB,YAAY,QAAQ,OAAO;AACjD,QAAM,iBAAiB,SAAS,YAAY,IAAI,CAAC,QAAQ,aAAa,CAAC,IAAI;AAE3E,QAAM,YAAY,OAAO,WAAW;AACpC,QAAM,WAAW,MAAM,MAAM,MAAM,iBAAiB;AAAA,IACnD,QAAQ;AAAA,IACR,SAAS;AAAA,MACR,gBAAgB;AAAA,MAChB,cAAc;AAAA,MACd,mBAAmB;AAAA,MACnB,sBAAsB;AAAA,IACvB;AAAA,IACA,MAAM,KAAK,UAAU,IAAI;AAAA,IACzB,QAAQ;AAAA,EACT,CAAC;AACD,QAAM,aAAa,eAAe,UAAU,SAAS;AAErD,QAAM,OAAO,MAAM,SAAS,KAAK;AACjC,SAAO,KAAK,gBAAgB,IAAI,CAAC,QAA6D;AAAA,IAC7F,QAAQ,MAAM,IAAI,WAAW,GAAG,EAAE,CAAC;AAAA,IACnC,KAAK,eAAe,QAAQ,GAAG,cAAc,IAAI,UAAU,CAA6B;AAAA,EACzF,EAAE;AACH;",
+  "names": []
+}

package/dist/esm/package.json

@@ -0,0 +1,5 @@
+{
+  "private": true,
+  "type": "module",
+  "sideEffects": false
+}

package/dist/esm/session-key.d.ts

@@ -0,0 +1,42 @@
+import type { Signer } from '@mysten/sui/cryptography';
+export declare const RequestFormat: import("@mysten/bcs").BcsType<{
+    ptb: number[];
+    encKey: number[];
+    encVerificationKey: number[];
+}, {
+    ptb: Iterable<number> & {
+        length: number;
+    };
+    encKey: Iterable<number> & {
+        length: number;
+    };
+    encVerificationKey: Iterable<number> & {
+        length: number;
+    };
+}>;
+export type Certificate = {
+    user: string;
+    session_vk: string;
+    creation_time: number;
+    ttl_min: number;
+    signature: string;
+};
+export declare class SessionKey {
+    #private;
+    constructor({ address, packageId, ttlMin, signer, }: {
+        address: string;
+        packageId: string;
+        ttlMin: number;
+        signer?: Signer;
+    });
+    isExpired(): boolean;
+    getAddress(): string;
+    getPackageId(): string;
+    getPersonalMessage(): Uint8Array;
+    setPersonalMessageSignature(personalMessageSignature: string): Promise<void>;
+    getCertificate(): Promise<Certificate>;
+    createRequestParams(txBytes: Uint8Array): Promise<{
+        decryptionKey: Uint8Array;
+        requestSignature: string;
+    }>;
+}

package/dist/esm/session-key.js

@@ -0,0 +1,124 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+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 __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _address, _packageId, _creationTimeMs, _ttlMin, _sessionKey, _personalMessageSignature, _signer;
+import { toBase64 } from "@mysten/bcs";
+import { bcs } from "@mysten/sui/bcs";
+import { SuiGraphQLClient } from "@mysten/sui/graphql";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { isValidSuiAddress, isValidSuiObjectId } from "@mysten/sui/utils";
+import { verifyPersonalMessageSignature } from "@mysten/sui/verify";
+import { generateSecretKey, toPublicKey, toVerificationKey } from "./elgamal.js";
+import {
+  ExpiredSessionKeyError,
+  InvalidPersonalMessageSignatureError,
+  UserError
+} from "./error.js";
+const RequestFormat = bcs.struct("RequestFormat", {
+  ptb: bcs.vector(bcs.U8),
+  encKey: bcs.vector(bcs.U8),
+  encVerificationKey: bcs.vector(bcs.U8)
+});
+class SessionKey {
+  constructor({
+    address,
+    packageId,
+    ttlMin,
+    signer
+  }) {
+    __privateAdd(this, _address);
+    __privateAdd(this, _packageId);
+    __privateAdd(this, _creationTimeMs);
+    __privateAdd(this, _ttlMin);
+    __privateAdd(this, _sessionKey);
+    __privateAdd(this, _personalMessageSignature);
+    __privateAdd(this, _signer);
+    if (!isValidSuiObjectId(packageId) || !isValidSuiAddress(address)) {
+      throw new UserError(`Invalid package ID ${packageId} or address ${address}`);
+    }
+    if (ttlMin > 10 || ttlMin < 1) {
+      throw new UserError(`Invalid TTL ${ttlMin}, must be between 1 and 10`);
+    }
+    __privateSet(this, _address, address);
+    __privateSet(this, _packageId, packageId);
+    __privateSet(this, _creationTimeMs, Date.now());
+    __privateSet(this, _ttlMin, ttlMin);
+    __privateSet(this, _sessionKey, Ed25519Keypair.generate());
+    __privateSet(this, _signer, signer);
+  }
+  isExpired() {
+    return __privateGet(this, _creationTimeMs) + __privateGet(this, _ttlMin) * 60 * 1e3 - 1e4 < Date.now();
+  }
+  getAddress() {
+    return __privateGet(this, _address);
+  }
+  getPackageId() {
+    return __privateGet(this, _packageId);
+  }
+  getPersonalMessage() {
+    const creationTimeUtc = new Date(__privateGet(this, _creationTimeMs)).toISOString().slice(0, 19).replace("T", " ") + " UTC";
+    const message = `Accessing keys of package ${__privateGet(this, _packageId)} for ${__privateGet(this, _ttlMin)} mins from ${creationTimeUtc}, session key ${toBase64(__privateGet(this, _sessionKey).getPublicKey().toRawBytes())}`;
+    return new TextEncoder().encode(message);
+  }
+  async setPersonalMessageSignature(personalMessageSignature) {
+    try {
+      await verifyPersonalMessageSignature(this.getPersonalMessage(), personalMessageSignature, {
+        address: __privateGet(this, _address),
+        client: new SuiGraphQLClient({
+          url: "https://sui-testnet.mystenlabs.com/graphql"
+        })
+      });
+      __privateSet(this, _personalMessageSignature, personalMessageSignature);
+    } catch (e) {
+      throw new InvalidPersonalMessageSignatureError("Not valid");
+    }
+  }
+  async getCertificate() {
+    if (!__privateGet(this, _personalMessageSignature)) {
+      if (__privateGet(this, _signer)) {
+        const { signature } = await __privateGet(this, _signer).signPersonalMessage(this.getPersonalMessage());
+        __privateSet(this, _personalMessageSignature, signature);
+      } else {
+        throw new InvalidPersonalMessageSignatureError("Personal message signature is not set");
+      }
+    }
+    return {
+      user: __privateGet(this, _address),
+      session_vk: toBase64(__privateGet(this, _sessionKey).getPublicKey().toRawBytes()),
+      creation_time: __privateGet(this, _creationTimeMs),
+      ttl_min: __privateGet(this, _ttlMin),
+      signature: __privateGet(this, _personalMessageSignature)
+    };
+  }
+  async createRequestParams(txBytes) {
+    if (this.isExpired()) {
+      throw new ExpiredSessionKeyError();
+    }
+    const egSk = generateSecretKey();
+    const msgToSign = RequestFormat.serialize({
+      ptb: txBytes.slice(1),
+      encKey: toPublicKey(egSk),
+      encVerificationKey: toVerificationKey(egSk)
+    }).toBytes();
+    return {
+      decryptionKey: egSk,
+      requestSignature: toBase64(await __privateGet(this, _sessionKey).sign(msgToSign))
+    };
+  }
+}
+_address = new WeakMap();
+_packageId = new WeakMap();
+_creationTimeMs = new WeakMap();
+_ttlMin = new WeakMap();
+_sessionKey = new WeakMap();
+_personalMessageSignature = new WeakMap();
+_signer = new WeakMap();
+export {
+  RequestFormat,
+  SessionKey
+};
+//# sourceMappingURL=session-key.js.map