tkms 0.11.0-rc14 → 0.11.0-rc17

package/kms_lib.d.ts

@@ -1,14 +1,21 @@
 /* tslint:disable */
 /* eslint-disable */
+export function ml_kem_pke_ct_pk_len(): number;
+export function ml_kem_pke_sk_len(): number;
 export function public_sig_key_to_u8vec(pk: PublicSigKey): Uint8Array;
 export function u8vec_to_public_sig_key(v: Uint8Array): PublicSigKey;
 export function private_sig_key_to_u8vec(sk: PrivateSigKey): Uint8Array;
 export function u8vec_to_private_sig_key(v: Uint8Array): PrivateSigKey;
+/**
+ * Create a new [ServerIdAddr] structure that holds an ID and an address
+ * which must be a valid EIP-55 address, notably prefixed with "0x".
+ */
+export function new_server_id_addr(id: number, addr: string): ServerIdAddr;
 /**
  * Instantiate a new client.
  *
- * * `server_addrs` - a list of KMS server EIP-55 addresses,
- * must be prefixed with "0x".
+ * * `server_addrs` - a list of KMS server ID with EIP-55 addresses,
+ * the elements in the list can be created using [new_server_id_addr].
  *
  * * `client_address_hex` - the client (wallet) address in hex,
  * must be prefixed with "0x".
@@ -16,18 +23,18 @@ export function u8vec_to_private_sig_key(v: Uint8Array): PrivateSigKey;
  * * `fhe_parameter` - the parameter choice, which can be either `"test"` or `"default"`.
  * The "default" parameter choice is selected if no matching string is found.
  */
-export function new_client(server_addrs: string[], client_address_hex: string, fhe_parameter: string): Client;
-export function get_server_addrs(client: Client): string[];
+export function new_client(server_addrs: ServerIdAddr[], client_address_hex: string, fhe_parameter: string): Client;
+export function get_server_addrs(client: Client): ServerIdAddr[];
 export function get_client_secret_key(client: Client): PrivateSigKey | undefined;
 export function get_client_address(client: Client): string;
-export function cryptobox_keygen(): PrivateEncKey;
-export function cryptobox_get_pk(sk: PrivateEncKey): PublicEncKey;
-export function cryptobox_pk_to_u8vec(pk: PublicEncKey): Uint8Array;
-export function cryptobox_sk_to_u8vec(sk: PrivateEncKey): Uint8Array;
-export function u8vec_to_cryptobox_pk(v: Uint8Array): PublicEncKey;
-export function u8vec_to_cryptobox_sk(v: Uint8Array): PrivateEncKey;
-export function cryptobox_encrypt(msg: Uint8Array, their_pk: PublicEncKey, my_sk: PrivateEncKey): CryptoBoxCt;
-export function cryptobox_decrypt(ct: CryptoBoxCt, my_sk: PrivateEncKey, their_pk: PublicEncKey): Uint8Array;
+export function ml_kem_pke_keygen(): PrivateEncKey;
+export function ml_kem_pke_get_pk(sk: PrivateEncKey): PublicEncKey;
+export function ml_kem_pke_pk_to_u8vec(pk: PublicEncKey): Uint8Array;
+export function ml_kem_pke_sk_to_u8vec(sk: PrivateEncKey): Uint8Array;
+export function u8vec_to_ml_kem_pke_pk(v: Uint8Array): PublicEncKey;
+export function u8vec_to_ml_kem_pke_sk(v: Uint8Array): PrivateEncKey;
+export function ml_kem_pke_encrypt(msg: Uint8Array, their_pk: PublicEncKey): CryptoBoxCt;
+export function ml_kem_pke_decrypt(ct: CryptoBoxCt, my_sk: PrivateEncKey): Uint8Array;
 /**
  * Process the user_decryption response from JavaScript objects.
  * The returned result is a byte array representing a plaintext of any length,
@@ -179,6 +186,10 @@ export class RequestId {
   free(): void;
   request_id: string;
 }
+export class ServerIdAddr {
+  private constructor();
+  free(): void;
+}
 export class TypedCiphertext {
   private constructor();
   free(): void;
@@ -284,7 +295,7 @@ export class UserDecryptionResponse {
   signature: Uint8Array;
   /**
    * This is the external signature created from the Eip712 domain
-   * on the structure, where userDecryptedShare is bincode::serialize(&payload)
+   * on the structure, where userDecryptedShare is bc2wrap::serialize(&payload)
    * struct UserDecryptResponseVerification {
    *      bytes publicKey;
    *      uint256\[\] ctHandles;
@@ -340,23 +351,27 @@ export interface InitOutput {
   readonly __wbg_client_free: (a: number, b: number) => void;
   readonly __wbg_ciphertexthandle_free: (a: number, b: number) => void;
   readonly __wbg_parseduserdecryptionrequest_free: (a: number, b: number) => void;
+  readonly ml_kem_pke_ct_pk_len: () => number;
+  readonly ml_kem_pke_sk_len: () => number;
   readonly public_sig_key_to_u8vec: (a: number) => [number, number];
   readonly u8vec_to_public_sig_key: (a: number, b: number) => [number, number, number];
   readonly private_sig_key_to_u8vec: (a: number) => [number, number, number, number];
   readonly u8vec_to_private_sig_key: (a: number, b: number) => [number, number, number];
+  readonly __wbg_serveridaddr_free: (a: number, b: number) => void;
+  readonly new_server_id_addr: (a: number, b: number, c: number) => [number, number, number];
   readonly new_client: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
   readonly get_server_addrs: (a: number) => [number, number];
   readonly get_client_secret_key: (a: number) => number;
   readonly get_client_address: (a: number) => [number, number];
   readonly __wbg_cryptoboxct_free: (a: number, b: number) => void;
-  readonly cryptobox_keygen: () => number;
-  readonly cryptobox_get_pk: (a: number) => number;
-  readonly cryptobox_pk_to_u8vec: (a: number) => [number, number, number, number];
-  readonly cryptobox_sk_to_u8vec: (a: number) => [number, number, number, number];
-  readonly u8vec_to_cryptobox_pk: (a: number, b: number) => [number, number, number];
-  readonly u8vec_to_cryptobox_sk: (a: number, b: number) => [number, number, number];
-  readonly cryptobox_encrypt: (a: number, b: number, c: number, d: number) => number;
-  readonly cryptobox_decrypt: (a: number, b: number, c: number) => [number, number];
+  readonly ml_kem_pke_keygen: () => number;
+  readonly ml_kem_pke_get_pk: (a: number) => number;
+  readonly ml_kem_pke_pk_to_u8vec: (a: number) => [number, number, number, number];
+  readonly ml_kem_pke_sk_to_u8vec: (a: number) => [number, number, number, number];
+  readonly u8vec_to_ml_kem_pke_pk: (a: number, b: number) => [number, number, number];
+  readonly u8vec_to_ml_kem_pke_sk: (a: number, b: number) => [number, number, number];
+  readonly ml_kem_pke_encrypt: (a: number, b: number, c: number) => number;
+  readonly ml_kem_pke_decrypt: (a: number, b: number) => [number, number];
   readonly process_user_decryption_resp_from_js: (a: number, b: any, c: any, d: any, e: number, f: number, g: number) => [number, number, number, number];
   readonly process_user_decryption_resp: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
   readonly __wbg_publicenckey_free: (a: number, b: number) => void;

package/kms_lib.js

@@ -166,6 +166,21 @@ function debugString(val) {
     // TODO we could test for more things here, like `Set`s and `Map`s.
     return className;
 }
+/**
+ * @returns {number}
+ */
+export function ml_kem_pke_ct_pk_len() {
+    const ret = wasm.ml_kem_pke_ct_pk_len();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function ml_kem_pke_sk_len() {
+    const ret = wasm.ml_kem_pke_sk_len();
+    return ret >>> 0;
+}
 
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
@@ -244,6 +259,23 @@ export function u8vec_to_private_sig_key(v) {
     return PrivateSigKey.__wrap(ret[0]);
 }
 
+/**
+ * Create a new [ServerIdAddr] structure that holds an ID and an address
+ * which must be a valid EIP-55 address, notably prefixed with "0x".
+ * @param {number} id
+ * @param {string} addr
+ * @returns {ServerIdAddr}
+ */
+export function new_server_id_addr(id, addr) {
+    const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.new_server_id_addr(id, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ServerIdAddr.__wrap(ret[0]);
+}
+
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {
@@ -256,15 +288,15 @@ function passArrayJsValueToWasm0(array, malloc) {
 /**
  * Instantiate a new client.
  *
- * * `server_addrs` - a list of KMS server EIP-55 addresses,
- * must be prefixed with "0x".
+ * * `server_addrs` - a list of KMS server ID with EIP-55 addresses,
+ * the elements in the list can be created using [new_server_id_addr].
  *
  * * `client_address_hex` - the client (wallet) address in hex,
  * must be prefixed with "0x".
  *
  * * `fhe_parameter` - the parameter choice, which can be either `"test"` or `"default"`.
  * The "default" parameter choice is selected if no matching string is found.
- * @param {string[]} server_addrs
+ * @param {ServerIdAddr[]} server_addrs
  * @param {string} client_address_hex
  * @param {string} fhe_parameter
  * @returns {Client}
@@ -295,7 +327,7 @@ function getArrayJsValueFromWasm0(ptr, len) {
 }
 /**
  * @param {Client} client
- * @returns {string[]}
+ * @returns {ServerIdAddr[]}
  */
 export function get_server_addrs(client) {
     _assertClass(client, Client);
@@ -336,8 +368,8 @@ export function get_client_address(client) {
 /**
  * @returns {PrivateEncKey}
  */
-export function cryptobox_keygen() {
-    const ret = wasm.cryptobox_keygen();
+export function ml_kem_pke_keygen() {
+    const ret = wasm.ml_kem_pke_keygen();
     return PrivateEncKey.__wrap(ret);
 }
 
@@ -345,9 +377,9 @@ export function cryptobox_keygen() {
  * @param {PrivateEncKey} sk
  * @returns {PublicEncKey}
  */
-export function cryptobox_get_pk(sk) {
+export function ml_kem_pke_get_pk(sk) {
     _assertClass(sk, PrivateEncKey);
-    const ret = wasm.cryptobox_get_pk(sk.__wbg_ptr);
+    const ret = wasm.ml_kem_pke_get_pk(sk.__wbg_ptr);
     return PublicEncKey.__wrap(ret);
 }
 
@@ -355,9 +387,9 @@ export function cryptobox_get_pk(sk) {
  * @param {PublicEncKey} pk
  * @returns {Uint8Array}
  */
-export function cryptobox_pk_to_u8vec(pk) {
+export function ml_kem_pke_pk_to_u8vec(pk) {
     _assertClass(pk, PublicEncKey);
-    const ret = wasm.cryptobox_pk_to_u8vec(pk.__wbg_ptr);
+    const ret = wasm.ml_kem_pke_pk_to_u8vec(pk.__wbg_ptr);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
@@ -370,9 +402,9 @@ export function cryptobox_pk_to_u8vec(pk) {
  * @param {PrivateEncKey} sk
  * @returns {Uint8Array}
  */
-export function cryptobox_sk_to_u8vec(sk) {
+export function ml_kem_pke_sk_to_u8vec(sk) {
     _assertClass(sk, PrivateEncKey);
-    const ret = wasm.cryptobox_sk_to_u8vec(sk.__wbg_ptr);
+    const ret = wasm.ml_kem_pke_sk_to_u8vec(sk.__wbg_ptr);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
@@ -385,10 +417,10 @@ export function cryptobox_sk_to_u8vec(sk) {
  * @param {Uint8Array} v
  * @returns {PublicEncKey}
  */
-export function u8vec_to_cryptobox_pk(v) {
+export function u8vec_to_ml_kem_pke_pk(v) {
     const ptr0 = passArray8ToWasm0(v, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.u8vec_to_cryptobox_pk(ptr0, len0);
+    const ret = wasm.u8vec_to_ml_kem_pke_pk(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -399,10 +431,10 @@ export function u8vec_to_cryptobox_pk(v) {
  * @param {Uint8Array} v
  * @returns {PrivateEncKey}
  */
-export function u8vec_to_cryptobox_sk(v) {
+export function u8vec_to_ml_kem_pke_sk(v) {
     const ptr0 = passArray8ToWasm0(v, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.u8vec_to_cryptobox_sk(ptr0, len0);
+    const ret = wasm.u8vec_to_ml_kem_pke_sk(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -412,29 +444,25 @@ export function u8vec_to_cryptobox_sk(v) {
 /**
  * @param {Uint8Array} msg
  * @param {PublicEncKey} their_pk
- * @param {PrivateEncKey} my_sk
  * @returns {CryptoBoxCt}
  */
-export function cryptobox_encrypt(msg, their_pk, my_sk) {
+export function ml_kem_pke_encrypt(msg, their_pk) {
     const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(their_pk, PublicEncKey);
-    _assertClass(my_sk, PrivateEncKey);
-    const ret = wasm.cryptobox_encrypt(ptr0, len0, their_pk.__wbg_ptr, my_sk.__wbg_ptr);
+    const ret = wasm.ml_kem_pke_encrypt(ptr0, len0, their_pk.__wbg_ptr);
     return CryptoBoxCt.__wrap(ret);
 }
 
 /**
  * @param {CryptoBoxCt} ct
  * @param {PrivateEncKey} my_sk
- * @param {PublicEncKey} their_pk
  * @returns {Uint8Array}
  */
-export function cryptobox_decrypt(ct, my_sk, their_pk) {
+export function ml_kem_pke_decrypt(ct, my_sk) {
     _assertClass(ct, CryptoBoxCt);
     _assertClass(my_sk, PrivateEncKey);
-    _assertClass(their_pk, PublicEncKey);
-    const ret = wasm.cryptobox_decrypt(ct.__wbg_ptr, my_sk.__wbg_ptr, their_pk.__wbg_ptr);
+    const ret = wasm.ml_kem_pke_decrypt(ct.__wbg_ptr, my_sk.__wbg_ptr);
     var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v1;
@@ -975,6 +1003,40 @@ export class RequestId {
     }
 }
 
+const ServerIdAddrFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_serveridaddr_free(ptr >>> 0, 1));
+
+export class ServerIdAddr {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ServerIdAddr.prototype);
+        obj.__wbg_ptr = ptr;
+        ServerIdAddrFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof ServerIdAddr)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ServerIdAddrFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_serveridaddr_free(ptr, 0);
+    }
+}
+
 const TypedCiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_typedciphertext_free(ptr >>> 0, 1));
@@ -1445,7 +1507,7 @@ export class UserDecryptionResponse {
     }
     /**
      * This is the external signature created from the Eip712 domain
-     * on the structure, where userDecryptedShare is bincode::serialize(&payload)
+     * on the structure, where userDecryptedShare is bc2wrap::serialize(&payload)
      * struct UserDecryptResponseVerification {
      *      bytes publicKey;
      *      uint256\[\] ctHandles;
@@ -1461,7 +1523,7 @@ export class UserDecryptionResponse {
     }
     /**
      * This is the external signature created from the Eip712 domain
-     * on the structure, where userDecryptedShare is bincode::serialize(&payload)
+     * on the structure, where userDecryptedShare is bc2wrap::serialize(&payload)
      * struct UserDecryptResponseVerification {
      *      bytes publicKey;
      *      uint256\[\] ctHandles;
@@ -1798,6 +1860,14 @@ function __wbg_get_imports() {
         const ret = module.require;
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_serveridaddr_new = function(arg0) {
+        const ret = ServerIdAddr.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_serveridaddr_unwrap = function(arg0) {
+        const ret = ServerIdAddr.__unwrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
         arg0.set(arg1, arg2 >>> 0);
     };

package/package.json

@@ -4,7 +4,7 @@
   "collaborators": [
     "Zama"
   ],
-  "version": "0.11.0-rc14",
+  "version": "0.11.0-rc17",
   "license": "BSD-3-Clause-Clear",
   "files": [
     "kms_lib_bg.wasm",