tkms 0.11.0-rc3 → 0.11.0-rc5

package/kms_lib.d.ts

@@ -39,12 +39,13 @@ export function cryptobox_decrypt(ct: CryptoBoxCt, my_sk: PrivateEncKey, their_p
  * It can be set to null if `verify` is false.
  * Otherwise the caller needs to give the following JS object.
  * Note that `client_address` and `eip712_verifying_contract` follow EIP-55.
+ * The signature field is not needed.
  * ```
  * {
- *   signature: '15a4f9a8eb61459cfba7d103d8f911fb04ce91ecf841b34c49c0d56a70b896d20cbc31986188f91efc3842b7df215cee8acb40178daedb8b63d0ba5d199bce121c',
+ *   signature: undefined,
  *   client_address: '0x17853A630aAe15AED549B2B874de08B73C0F59c5',
  *   enc_key: '2000000000000000df2fcacb774f03187f3802a27259f45c06d33cefa68d9c53426b15ad531aa822',
- *   ciphertext_handle: '0748b542afe2353c86cb707e3d21044b0be1fd18efc7cbaa6a415af055bfb358',
+ *   ciphertext_handles: [ '0748b542afe2353c86cb707e3d21044b0be1fd18efc7cbaa6a415af055bfb358' ]
  *   eip712_verifying_contract: '0x66f9664f97F2b50F62D13eA064982f936dE76657'
  * }
  * ```
@@ -113,7 +114,7 @@ export function process_reencryption_resp_from_js(client: Client, request: any,
  */
 export function process_reencryption_resp(client: Client, request: ParsedReencryptionRequest | undefined, eip712_domain: Eip712DomainMsg | undefined, agg_resp: (ReencryptionResponse)[], enc_pk: PublicEncKey, enc_sk: PrivateEncKey, verify: boolean): (TypedPlaintext)[];
 /**
- * The plaintext types that can be encrypted in a fhevm ciphertext.
+ * The plaintext types that can be encrypted in a HTTPZ ciphertext.
  */
 export enum FheType {
   Ebool = 0,
@@ -188,17 +189,20 @@ export class PublicSigKey {
 export class ReencryptionRequest {
   private constructor();
   free(): void;
-  payload?: ReencryptionRequestPayload;
-  domain?: Eip712DomainMsg;
   /**
-   * The ID that identifies this request.
+   * The 32 Byte / 256 Bit ID of the user decryption request, without `0x` prefix.
    * Future queries for the result must use this request ID.
    */
   request_id?: RequestId;
-}
-export class ReencryptionRequestPayload {
-  private constructor();
-  free(): void;
+  /**
+   * The list of ciphertexts to reencrypt.
+   */
+  typed_ciphertexts: (TypedCiphertext)[];
+  /**
+   * The 32 Byte / 256 Bit key id to use for decryption. This is the request_id used for key
+   * generation
+   */
+  key_id?: RequestId;
   /**
    * The client's (blockchain wallet) address,
    * encoded using EIP-55.
@@ -210,22 +214,24 @@ export class ReencryptionRequestPayload {
    * Montgomery point.
    */
   enc_key: Uint8Array;
-  /**
-   * The key id to use for decryption. Will be the request_id used during key
-   * generation
-   */
-  key_id?: RequestId;
-  /**
-   * The list of ciphertexts to reencrypt.
-   */
-  typed_ciphertexts: (TypedCiphertext)[];
+  domain?: Eip712DomainMsg;
 }
 export class ReencryptionResponse {
   private constructor();
   free(): void;
   signature: Uint8Array;
   /**
-   * Signature of the serialization of \[ReencryptionResponsePayload\].
+   * This is the external signature created from the Eip712 domain
+   * on the structure, where reencryptedShare is bincode::serialize(&payload)
+   * struct UserDecryptResponseVerification {
+   *      bytes publicKey;
+   *      uint256\[\] ctHandles;
+   *      bytes reencryptedShare;
+   * }
+   */
+  external_signature: Uint8Array;
+  /**
+   * The actual \[ReencryptionResponsePayload\].
    */
   payload?: ReencryptionResponsePayload;
 }
@@ -233,18 +239,22 @@ export class ReencryptionResponsePayload {
   private constructor();
   free(): void;
   /**
-   * The server's signature verification key.
-   * Encoded using SEC1.
+   * The server's signature verification key, Encoded using SEC1.
    * Needed to validate the response, but MUST also be linked to a list of
    * trusted keys.
    */
   verification_key: Uint8Array;
   /**
-   * The concatenation of two digests:
-   * (eip712_signing_hash(pk, domain) || ciphertext digest).
    * This is needed to ensure the response corresponds to the request.
+   * It is the digest of UserDecryptionLinker hashed using EIP712
+   * under the given domain in the request.
    */
   digest: Uint8Array;
+  /**
+   * The resulting signcrypted ciphertexts, each ciphertext
+   * must be decrypted and then reconstructed with the other shares
+   * to produce the final plaintext.
+   */
   signcrypted_ciphertexts: (TypedSigncryptedCiphertext)[];
   /**
    * The ID of the MPC party doing the reencryption. Used for polynomial
@@ -255,20 +265,10 @@ export class ReencryptionResponsePayload {
    * The degree of the sharing scheme used.
    */
   degree: number;
-  /**
-   * This is the external signature created from the Eip712 domain
-   * on the structure, where reencryptedShare is bincode::serialize(&signcrypted_ciphertexts)
-   * struct UserDecryptionResult {
-   *        bytes publicKey;
-   *        uint256\[\] handles;
-   *        bytes reencryptedShare;
-   * }
-   */
-  external_signature: Uint8Array;
 }
 /**
- * Simple response to return an ID, to be used to retrieve the computed result
- * later on.
+ * Simple response to return a 32 Byte / 256 Bit ID, to be used to retrieve the computed result
+ * later on. This string does NOT contain a `0x` prefix.
  */
 export class RequestId {
   private constructor();
@@ -279,7 +279,7 @@ export class TypedCiphertext {
   private constructor();
   free(): void;
   /**
-   * The actual ciphertext to decrypt, taken directly from the fhevm.
+   * The actual ciphertext to decrypt, taken directly from HTTPZ.
    */
   ciphertext: Uint8Array;
   /**
@@ -290,6 +290,11 @@ export class TypedCiphertext {
    * The external handle of the ciphertext (the handle used in the copro).
    */
   external_handle: Uint8Array;
+  /**
+   * The ciphertext format, see CiphertextFormat documentation for details.
+   * CiphertextFormat::default() is used if unspecified.
+   */
+  ciphertext_format: number;
 }
 /**
  * The typed plaintext type, which is the result of decryption.
@@ -331,6 +336,10 @@ export interface InitOutput {
   readonly __wbg_client_free: (a: number, b: number) => void;
   readonly __wbg_ciphertexthandle_free: (a: number, b: number) => void;
   readonly __wbg_parsedreencryptionrequest_free: (a: number, b: number) => void;
+  readonly __wbg_publicenckey_free: (a: number, b: number) => void;
+  readonly __wbg_privateenckey_free: (a: number, b: number) => void;
+  readonly __wbg_publicsigkey_free: (a: number, b: number) => void;
+  readonly __wbg_privatesigkey_free: (a: number, b: number) => void;
   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];
@@ -350,23 +359,15 @@ export interface InitOutput {
   readonly cryptobox_decrypt: (a: number, b: number, c: number) => [number, number];
   readonly process_reencryption_resp_from_js: (a: number, b: any, c: any, d: any, e: number, f: number, g: number) => [number, number, number, number];
   readonly process_reencryption_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;
-  readonly __wbg_privateenckey_free: (a: number, b: number) => void;
-  readonly __wbg_publicsigkey_free: (a: number, b: number) => void;
-  readonly __wbg_privatesigkey_free: (a: number, b: number) => void;
   readonly __wbg_requestid_free: (a: number, b: number) => void;
   readonly __wbg_typedciphertext_free: (a: number, b: number) => void;
   readonly __wbg_get_typedciphertext_fhe_type: (a: number) => number;
   readonly __wbg_set_typedciphertext_fhe_type: (a: number, b: number) => void;
+  readonly __wbg_get_typedciphertext_ciphertext_format: (a: number) => number;
+  readonly __wbg_set_typedciphertext_ciphertext_format: (a: number, b: number) => void;
   readonly __wbg_typedplaintext_free: (a: number, b: number) => void;
   readonly __wbg_get_typedplaintext_fhe_type: (a: number) => number;
   readonly __wbg_set_typedplaintext_fhe_type: (a: number, b: number) => void;
-  readonly __wbg_reencryptionrequestpayload_free: (a: number, b: number) => void;
-  readonly __wbg_get_reencryptionrequestpayload_enc_key: (a: number) => [number, number];
-  readonly __wbg_get_reencryptionrequestpayload_key_id: (a: number) => number;
-  readonly __wbg_set_reencryptionrequestpayload_key_id: (a: number, b: number) => void;
-  readonly __wbg_get_reencryptionrequestpayload_typed_ciphertexts: (a: number) => [number, number];
-  readonly __wbg_set_reencryptionrequestpayload_typed_ciphertexts: (a: number, b: number, c: number) => void;
   readonly __wbg_eip712domainmsg_free: (a: number, b: number) => void;
   readonly __wbg_get_eip712domainmsg_name: (a: number) => [number, number];
   readonly __wbg_set_eip712domainmsg_name: (a: number, b: number, c: number) => void;
@@ -379,14 +380,17 @@ export interface InitOutput {
   readonly __wbg_get_eip712domainmsg_salt: (a: number) => [number, number];
   readonly __wbg_set_eip712domainmsg_salt: (a: number, b: number, c: number) => void;
   readonly __wbg_reencryptionrequest_free: (a: number, b: number) => void;
-  readonly __wbg_get_reencryptionrequest_payload: (a: number) => number;
-  readonly __wbg_set_reencryptionrequest_payload: (a: number, b: number) => void;
-  readonly __wbg_get_reencryptionrequest_domain: (a: number) => number;
-  readonly __wbg_set_reencryptionrequest_domain: (a: number, b: number) => void;
   readonly __wbg_get_reencryptionrequest_request_id: (a: number) => number;
   readonly __wbg_set_reencryptionrequest_request_id: (a: number, b: number) => void;
+  readonly __wbg_get_reencryptionrequest_typed_ciphertexts: (a: number) => [number, number];
+  readonly __wbg_set_reencryptionrequest_typed_ciphertexts: (a: number, b: number, c: number) => void;
+  readonly __wbg_get_reencryptionrequest_key_id: (a: number) => number;
+  readonly __wbg_set_reencryptionrequest_key_id: (a: number, b: number) => void;
+  readonly __wbg_get_reencryptionrequest_domain: (a: number) => number;
+  readonly __wbg_set_reencryptionrequest_domain: (a: number, b: number) => void;
   readonly __wbg_reencryptionresponse_free: (a: number, b: number) => void;
   readonly __wbg_get_reencryptionresponse_signature: (a: number) => [number, number];
+  readonly __wbg_get_reencryptionresponse_external_signature: (a: number) => [number, number];
   readonly __wbg_get_reencryptionresponse_payload: (a: number) => number;
   readonly __wbg_set_reencryptionresponse_payload: (a: number, b: number) => void;
   readonly __wbg_reencryptionresponsepayload_free: (a: number, b: number) => void;
@@ -396,26 +400,26 @@ export interface InitOutput {
   readonly __wbg_set_reencryptionresponsepayload_party_id: (a: number, b: number) => void;
   readonly __wbg_get_reencryptionresponsepayload_degree: (a: number) => number;
   readonly __wbg_set_reencryptionresponsepayload_degree: (a: number, b: number) => void;
-  readonly __wbg_get_reencryptionresponsepayload_external_signature: (a: number) => [number, number];
   readonly __wbg_typedsigncryptedciphertext_free: (a: number, b: number) => void;
   readonly __wbg_get_typedsigncryptedciphertext_fhe_type: (a: number) => number;
   readonly __wbg_set_typedciphertext_ciphertext: (a: number, b: number, c: number) => void;
   readonly __wbg_set_typedplaintext_bytes: (a: number, b: number, c: number) => void;
   readonly __wbg_set_requestid_request_id: (a: number, b: number, c: number) => void;
   readonly __wbg_set_typedciphertext_external_handle: (a: number, b: number, c: number) => void;
-  readonly __wbg_set_reencryptionrequestpayload_client_address: (a: number, b: number, c: number) => void;
-  readonly __wbg_set_reencryptionrequestpayload_enc_key: (a: number, b: number, c: number) => void;
+  readonly __wbg_set_reencryptionrequest_client_address: (a: number, b: number, c: number) => void;
+  readonly __wbg_set_reencryptionrequest_enc_key: (a: number, b: number, c: number) => void;
   readonly __wbg_set_reencryptionresponse_signature: (a: number, b: number, c: number) => void;
+  readonly __wbg_set_reencryptionresponse_external_signature: (a: number, b: number, c: number) => void;
   readonly __wbg_set_reencryptionresponsepayload_verification_key: (a: number, b: number, c: number) => void;
   readonly __wbg_set_reencryptionresponsepayload_digest: (a: number, b: number, c: number) => void;
-  readonly __wbg_set_reencryptionresponsepayload_external_signature: (a: number, b: number, c: number) => void;
   readonly __wbg_set_typedsigncryptedciphertext_signcrypted_ciphertext: (a: number, b: number, c: number) => void;
   readonly __wbg_set_typedsigncryptedciphertext_external_handle: (a: number, b: number, c: number) => void;
   readonly __wbg_get_requestid_request_id: (a: number) => [number, number];
-  readonly __wbg_get_reencryptionrequestpayload_client_address: (a: number) => [number, number];
+  readonly __wbg_get_reencryptionrequest_client_address: (a: number) => [number, number];
   readonly __wbg_get_typedplaintext_bytes: (a: number) => [number, number];
-  readonly __wbg_get_typedciphertext_external_handle: (a: number) => [number, number];
+  readonly __wbg_get_reencryptionrequest_enc_key: (a: number) => [number, number];
   readonly __wbg_get_typedciphertext_ciphertext: (a: number) => [number, number];
+  readonly __wbg_get_typedciphertext_external_handle: (a: number) => [number, number];
   readonly __wbg_get_reencryptionresponsepayload_verification_key: (a: number) => [number, number];
   readonly __wbg_get_reencryptionresponsepayload_digest: (a: number) => [number, number];
   readonly __wbg_get_typedsigncryptedciphertext_signcrypted_ciphertext: (a: number) => [number, number];

package/kms_lib.js

@@ -451,12 +451,13 @@ export function cryptobox_decrypt(ct, my_sk, their_pk) {
  * It can be set to null if `verify` is false.
  * Otherwise the caller needs to give the following JS object.
  * Note that `client_address` and `eip712_verifying_contract` follow EIP-55.
+ * The signature field is not needed.
  * ```
  * {
- *   signature: '15a4f9a8eb61459cfba7d103d8f911fb04ce91ecf841b34c49c0d56a70b896d20cbc31986188f91efc3842b7df215cee8acb40178daedb8b63d0ba5d199bce121c',
+ *   signature: undefined,
  *   client_address: '0x17853A630aAe15AED549B2B874de08B73C0F59c5',
  *   enc_key: '2000000000000000df2fcacb774f03187f3802a27259f45c06d33cefa68d9c53426b15ad531aa822',
- *   ciphertext_handle: '0748b542afe2353c86cb707e3d21044b0be1fd18efc7cbaa6a415af055bfb358',
+ *   ciphertext_handles: [ '0748b542afe2353c86cb707e3d21044b0be1fd18efc7cbaa6a415af055bfb358' ]
  *   eip712_verifying_contract: '0x66f9664f97F2b50F62D13eA064982f936dE76657'
  * }
  * ```
@@ -577,7 +578,7 @@ export function process_reencryption_resp(client, request, eip712_domain, agg_re
 }
 
 /**
- * The plaintext types that can be encrypted in a fhevm ciphertext.
+ * The plaintext types that can be encrypted in a HTTPZ ciphertext.
  * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11}
  */
 export const FheType = Object.freeze({
@@ -958,89 +959,67 @@ export class ReencryptionRequest {
         wasm.__wbg_reencryptionrequest_free(ptr, 0);
     }
     /**
-     * @returns {ReencryptionRequestPayload | undefined}
+     * The 32 Byte / 256 Bit ID of the user decryption request, without `0x` prefix.
+     * Future queries for the result must use this request ID.
+     * @returns {RequestId | undefined}
      */
-    get payload() {
-        const ret = wasm.__wbg_get_reencryptionrequest_payload(this.__wbg_ptr);
-        return ret === 0 ? undefined : ReencryptionRequestPayload.__wrap(ret);
+    get request_id() {
+        const ret = wasm.__wbg_get_reencryptionrequest_request_id(this.__wbg_ptr);
+        return ret === 0 ? undefined : RequestId.__wrap(ret);
     }
     /**
-     * @param {ReencryptionRequestPayload | undefined} [arg0]
+     * The 32 Byte / 256 Bit ID of the user decryption request, without `0x` prefix.
+     * Future queries for the result must use this request ID.
+     * @param {RequestId | undefined} [arg0]
      */
-    set payload(arg0) {
+    set request_id(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
-            _assertClass(arg0, ReencryptionRequestPayload);
+            _assertClass(arg0, RequestId);
             ptr0 = arg0.__destroy_into_raw();
         }
-        wasm.__wbg_set_reencryptionrequest_payload(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_reencryptionrequest_request_id(this.__wbg_ptr, ptr0);
     }
     /**
-     * @returns {Eip712DomainMsg | undefined}
+     * The list of ciphertexts to reencrypt.
+     * @returns {(TypedCiphertext)[]}
      */
-    get domain() {
-        const ret = wasm.__wbg_get_reencryptionrequest_domain(this.__wbg_ptr);
-        return ret === 0 ? undefined : Eip712DomainMsg.__wrap(ret);
+    get typed_ciphertexts() {
+        const ret = wasm.__wbg_get_reencryptionrequest_typed_ciphertexts(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     * @param {Eip712DomainMsg | undefined} [arg0]
+     * The list of ciphertexts to reencrypt.
+     * @param {(TypedCiphertext)[]} arg0
      */
-    set domain(arg0) {
-        let ptr0 = 0;
-        if (!isLikeNone(arg0)) {
-            _assertClass(arg0, Eip712DomainMsg);
-            ptr0 = arg0.__destroy_into_raw();
-        }
-        wasm.__wbg_set_reencryptionrequest_domain(this.__wbg_ptr, ptr0);
+    set typed_ciphertexts(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_reencryptionrequest_typed_ciphertexts(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * The ID that identifies this request.
-     * Future queries for the result must use this request ID.
+     * The 32 Byte / 256 Bit key id to use for decryption. This is the request_id used for key
+     * generation
      * @returns {RequestId | undefined}
      */
-    get request_id() {
-        const ret = wasm.__wbg_get_reencryptionrequest_request_id(this.__wbg_ptr);
+    get key_id() {
+        const ret = wasm.__wbg_get_reencryptionrequest_key_id(this.__wbg_ptr);
         return ret === 0 ? undefined : RequestId.__wrap(ret);
     }
     /**
-     * The ID that identifies this request.
-     * Future queries for the result must use this request ID.
+     * The 32 Byte / 256 Bit key id to use for decryption. This is the request_id used for key
+     * generation
      * @param {RequestId | undefined} [arg0]
      */
-    set request_id(arg0) {
+    set key_id(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
             _assertClass(arg0, RequestId);
             ptr0 = arg0.__destroy_into_raw();
         }
-        wasm.__wbg_set_reencryptionrequest_request_id(this.__wbg_ptr, ptr0);
-    }
-}
-
-const ReencryptionRequestPayloadFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_reencryptionrequestpayload_free(ptr >>> 0, 1));
-
-export class ReencryptionRequestPayload {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ReencryptionRequestPayload.prototype);
-        obj.__wbg_ptr = ptr;
-        ReencryptionRequestPayloadFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ReencryptionRequestPayloadFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_reencryptionrequestpayload_free(ptr, 0);
+        wasm.__wbg_set_reencryptionrequest_key_id(this.__wbg_ptr, ptr0);
     }
     /**
      * The client's (blockchain wallet) address,
@@ -1051,7 +1030,7 @@ export class ReencryptionRequestPayload {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.__wbg_get_reencryptionrequestpayload_client_address(this.__wbg_ptr);
+            const ret = wasm.__wbg_get_reencryptionrequest_client_address(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1067,7 +1046,7 @@ export class ReencryptionRequestPayload {
     set client_address(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_eip712domainmsg_name(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_eip712domainmsg_version(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * Encoding of the user's public encryption key for this request.
@@ -1076,7 +1055,7 @@ export class ReencryptionRequestPayload {
      * @returns {Uint8Array}
      */
     get enc_key() {
-        const ret = wasm.__wbg_get_reencryptionrequestpayload_enc_key(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_reencryptionrequest_enc_key(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -1090,48 +1069,25 @@ export class ReencryptionRequestPayload {
     set enc_key(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_eip712domainmsg_version(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_eip712domainmsg_chain_id(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * The key id to use for decryption. Will be the request_id used during key
-     * generation
-     * @returns {RequestId | undefined}
+     * @returns {Eip712DomainMsg | undefined}
      */
-    get key_id() {
-        const ret = wasm.__wbg_get_reencryptionrequestpayload_key_id(this.__wbg_ptr);
-        return ret === 0 ? undefined : RequestId.__wrap(ret);
+    get domain() {
+        const ret = wasm.__wbg_get_reencryptionrequest_domain(this.__wbg_ptr);
+        return ret === 0 ? undefined : Eip712DomainMsg.__wrap(ret);
     }
     /**
-     * The key id to use for decryption. Will be the request_id used during key
-     * generation
-     * @param {RequestId | undefined} [arg0]
+     * @param {Eip712DomainMsg | undefined} [arg0]
      */
-    set key_id(arg0) {
+    set domain(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
-            _assertClass(arg0, RequestId);
+            _assertClass(arg0, Eip712DomainMsg);
             ptr0 = arg0.__destroy_into_raw();
         }
-        wasm.__wbg_set_reencryptionrequestpayload_key_id(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * The list of ciphertexts to reencrypt.
-     * @returns {(TypedCiphertext)[]}
-     */
-    get typed_ciphertexts() {
-        const ret = wasm.__wbg_get_reencryptionrequestpayload_typed_ciphertexts(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * The list of ciphertexts to reencrypt.
-     * @param {(TypedCiphertext)[]} arg0
-     */
-    set typed_ciphertexts(arg0) {
-        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_reencryptionrequestpayload_typed_ciphertexts(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_reencryptionrequest_domain(this.__wbg_ptr, ptr0);
     }
 }
 
@@ -1177,7 +1133,38 @@ export class ReencryptionResponse {
         wasm.__wbg_set_eip712domainmsg_name(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Signature of the serialization of \[ReencryptionResponsePayload\].
+     * This is the external signature created from the Eip712 domain
+     * on the structure, where reencryptedShare is bincode::serialize(&payload)
+     * struct UserDecryptResponseVerification {
+     *      bytes publicKey;
+     *      uint256\[\] ctHandles;
+     *      bytes reencryptedShare;
+     * }
+     * @returns {Uint8Array}
+     */
+    get external_signature() {
+        const ret = wasm.__wbg_get_reencryptionresponse_external_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * This is the external signature created from the Eip712 domain
+     * on the structure, where reencryptedShare is bincode::serialize(&payload)
+     * struct UserDecryptResponseVerification {
+     *      bytes publicKey;
+     *      uint256\[\] ctHandles;
+     *      bytes reencryptedShare;
+     * }
+     * @param {Uint8Array} arg0
+     */
+    set external_signature(arg0) {
+        const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_eip712domainmsg_version(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * The actual \[ReencryptionResponsePayload\].
      * @returns {ReencryptionResponsePayload | undefined}
      */
     get payload() {
@@ -1185,7 +1172,7 @@ export class ReencryptionResponse {
         return ret === 0 ? undefined : ReencryptionResponsePayload.__wrap(ret);
     }
     /**
-     * Signature of the serialization of \[ReencryptionResponsePayload\].
+     * The actual \[ReencryptionResponsePayload\].
      * @param {ReencryptionResponsePayload | undefined} [arg0]
      */
     set payload(arg0) {
@@ -1224,8 +1211,7 @@ export class ReencryptionResponsePayload {
         wasm.__wbg_reencryptionresponsepayload_free(ptr, 0);
     }
     /**
-     * The server's signature verification key.
-     * Encoded using SEC1.
+     * The server's signature verification key, Encoded using SEC1.
      * Needed to validate the response, but MUST also be linked to a list of
      * trusted keys.
      * @returns {Uint8Array}
@@ -1237,8 +1223,7 @@ export class ReencryptionResponsePayload {
         return v1;
     }
     /**
-     * The server's signature verification key.
-     * Encoded using SEC1.
+     * The server's signature verification key, Encoded using SEC1.
      * Needed to validate the response, but MUST also be linked to a list of
      * trusted keys.
      * @param {Uint8Array} arg0
@@ -1249,9 +1234,9 @@ export class ReencryptionResponsePayload {
         wasm.__wbg_set_eip712domainmsg_name(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * The concatenation of two digests:
-     * (eip712_signing_hash(pk, domain) || ciphertext digest).
      * This is needed to ensure the response corresponds to the request.
+     * It is the digest of UserDecryptionLinker hashed using EIP712
+     * under the given domain in the request.
      * @returns {Uint8Array}
      */
     get digest() {
@@ -1261,9 +1246,9 @@ export class ReencryptionResponsePayload {
         return v1;
     }
     /**
-     * The concatenation of two digests:
-     * (eip712_signing_hash(pk, domain) || ciphertext digest).
      * This is needed to ensure the response corresponds to the request.
+     * It is the digest of UserDecryptionLinker hashed using EIP712
+     * under the given domain in the request.
      * @param {Uint8Array} arg0
      */
     set digest(arg0) {
@@ -1272,6 +1257,9 @@ export class ReencryptionResponsePayload {
         wasm.__wbg_set_eip712domainmsg_version(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * The resulting signcrypted ciphertexts, each ciphertext
+     * must be decrypted and then reconstructed with the other shares
+     * to produce the final plaintext.
      * @returns {(TypedSigncryptedCiphertext)[]}
      */
     get signcrypted_ciphertexts() {
@@ -1281,6 +1269,9 @@ export class ReencryptionResponsePayload {
         return v1;
     }
     /**
+     * The resulting signcrypted ciphertexts, each ciphertext
+     * must be decrypted and then reconstructed with the other shares
+     * to produce the final plaintext.
      * @param {(TypedSigncryptedCiphertext)[]} arg0
      */
     set signcrypted_ciphertexts(arg0) {
@@ -1320,45 +1311,14 @@ export class ReencryptionResponsePayload {
     set degree(arg0) {
         wasm.__wbg_set_reencryptionresponsepayload_degree(this.__wbg_ptr, arg0);
     }
-    /**
-     * This is the external signature created from the Eip712 domain
-     * on the structure, where reencryptedShare is bincode::serialize(&signcrypted_ciphertexts)
-     * struct UserDecryptionResult {
-     *        bytes publicKey;
-     *        uint256\[\] handles;
-     *        bytes reencryptedShare;
-     * }
-     * @returns {Uint8Array}
-     */
-    get external_signature() {
-        const ret = wasm.__wbg_get_reencryptionresponsepayload_external_signature(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * This is the external signature created from the Eip712 domain
-     * on the structure, where reencryptedShare is bincode::serialize(&signcrypted_ciphertexts)
-     * struct UserDecryptionResult {
-     *        bytes publicKey;
-     *        uint256\[\] handles;
-     *        bytes reencryptedShare;
-     * }
-     * @param {Uint8Array} arg0
-     */
-    set external_signature(arg0) {
-        const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_eip712domainmsg_verifying_contract(this.__wbg_ptr, ptr0, len0);
-    }
 }
 
 const RequestIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_requestid_free(ptr >>> 0, 1));
 /**
- * Simple response to return an ID, to be used to retrieve the computed result
- * later on.
+ * Simple response to return a 32 Byte / 256 Bit ID, to be used to retrieve the computed result
+ * later on. This string does NOT contain a `0x` prefix.
  */
 export class RequestId {
 
@@ -1439,7 +1399,7 @@ export class TypedCiphertext {
         wasm.__wbg_typedciphertext_free(ptr, 0);
     }
     /**
-     * The actual ciphertext to decrypt, taken directly from the fhevm.
+     * The actual ciphertext to decrypt, taken directly from HTTPZ.
      * @returns {Uint8Array}
      */
     get ciphertext() {
@@ -1449,7 +1409,7 @@ export class TypedCiphertext {
         return v1;
     }
     /**
-     * The actual ciphertext to decrypt, taken directly from the fhevm.
+     * The actual ciphertext to decrypt, taken directly from HTTPZ.
      * @param {Uint8Array} arg0
      */
     set ciphertext(arg0) {
@@ -1491,6 +1451,23 @@ export class TypedCiphertext {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_eip712domainmsg_version(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * The ciphertext format, see CiphertextFormat documentation for details.
+     * CiphertextFormat::default() is used if unspecified.
+     * @returns {number}
+     */
+    get ciphertext_format() {
+        const ret = wasm.__wbg_get_typedciphertext_ciphertext_format(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The ciphertext format, see CiphertextFormat documentation for details.
+     * CiphertextFormat::default() is used if unspecified.
+     * @param {number} arg0
+     */
+    set ciphertext_format(arg0) {
+        wasm.__wbg_set_typedciphertext_ciphertext_format(this.__wbg_ptr, arg0);
+    }
 }
 
 const TypedPlaintextFinalization = (typeof FinalizationRegistry === 'undefined')

package/package.json

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

package/LICENSE

@@ -1,28 +0,0 @@
-BSD 3-Clause Clear License
-
-Copyright © 2024 ZAMA.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-3. Neither the name of ZAMA nor the names of its contributors may be used to endorse
-or promote products derived from this software without specific prior written permission.
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE.
-THIS SOFTWARE IS PROVIDED BY THE ZAMA AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-ZAMA OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
-OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.