node-tkms 0.9.0-rc3 → 0.9.0-rc30

package/LICENSE

@@ -0,0 +1,28 @@
+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.

package/kms_lib.d.ts

@@ -1,202 +1,203 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
-* @param {PublicSigKey} pk
-* @returns {Uint8Array}
-*/
+ * @param {PublicSigKey} pk
+ * @returns {Uint8Array}
+ */
 export function public_sig_key_to_u8vec(pk: PublicSigKey): Uint8Array;
 /**
-* @param {Uint8Array} v
-* @returns {PublicSigKey}
-*/
+ * @param {Uint8Array} v
+ * @returns {PublicSigKey}
+ */
 export function u8vec_to_public_sig_key(v: Uint8Array): PublicSigKey;
 /**
-* @param {PrivateSigKey} sk
-* @returns {Uint8Array}
-*/
+ * @param {PrivateSigKey} sk
+ * @returns {Uint8Array}
+ */
 export function private_sig_key_to_u8vec(sk: PrivateSigKey): Uint8Array;
 /**
-* @param {Uint8Array} v
-* @returns {PrivateSigKey}
-*/
+ * @param {Uint8Array} v
+ * @returns {PrivateSigKey}
+ */
 export function u8vec_to_private_sig_key(v: Uint8Array): PrivateSigKey;
 /**
-* Instantiate a new client.
-*
-* * `server_pks` - a list of KMS server signature public keys,
-* which can parsed using [u8vec_to_public_sig_key].
-*
-* * `client_address_hex` - the client (wallet) address in hex,
-* must be prefixed with "0x".
-*
-* * `param_choice` - the parameter choice, which can be either `"test"` or `"default"`.
-* The "default" parameter choice is selected if no matching string is found.
-* @param {(PublicSigKey)[]} server_pks
-* @param {string} client_address_hex
-* @param {string} param_choice
-* @returns {Client}
-*/
-export function new_client(server_pks: (PublicSigKey)[], client_address_hex: string, param_choice: string): Client;
-/**
-* @param {Client} client
-* @returns {(PublicSigKey)[]}
-*/
-export function get_server_public_keys(client: Client): (PublicSigKey)[];
-/**
-* @param {Client} client
-* @returns {PrivateSigKey | undefined}
-*/
+ * Instantiate a new client.
+ *
+ * * `server_addrs` - a list of KMS server EIP-55 addresses,
+ * must be prefixed with "0x".
+ *
+ * * `client_address_hex` - the client (wallet) address in hex,
+ * must be prefixed with "0x".
+ *
+ * * `param_choice` - 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 {string} client_address_hex
+ * @param {string} param_choice
+ * @returns {Client}
+ */
+export function new_client(server_addrs: (string)[], client_address_hex: string, param_choice: string): Client;
+/**
+ * @param {Client} client
+ * @returns {(string)[]}
+ */
+export function get_server_addrs(client: Client): (string)[];
+/**
+ * @param {Client} client
+ * @returns {PrivateSigKey | undefined}
+ */
 export function get_client_secret_key(client: Client): PrivateSigKey | undefined;
 /**
-* @param {Client} client
-* @returns {string}
-*/
+ * @param {Client} client
+ * @returns {string}
+ */
 export function get_client_address(client: Client): string;
 /**
-* @returns {PrivateEncKey}
-*/
+ * @returns {PrivateEncKey}
+ */
 export function cryptobox_keygen(): PrivateEncKey;
 /**
-* @param {PrivateEncKey} sk
-* @returns {PublicEncKey}
-*/
+ * @param {PrivateEncKey} sk
+ * @returns {PublicEncKey}
+ */
 export function cryptobox_get_pk(sk: PrivateEncKey): PublicEncKey;
 /**
-* @param {PublicEncKey} pk
-* @returns {Uint8Array}
-*/
+ * @param {PublicEncKey} pk
+ * @returns {Uint8Array}
+ */
 export function cryptobox_pk_to_u8vec(pk: PublicEncKey): Uint8Array;
 /**
-* @param {PrivateEncKey} sk
-* @returns {Uint8Array}
-*/
+ * @param {PrivateEncKey} sk
+ * @returns {Uint8Array}
+ */
 export function cryptobox_sk_to_u8vec(sk: PrivateEncKey): Uint8Array;
 /**
-* @param {Uint8Array} v
-* @returns {PublicEncKey}
-*/
+ * @param {Uint8Array} v
+ * @returns {PublicEncKey}
+ */
 export function u8vec_to_cryptobox_pk(v: Uint8Array): PublicEncKey;
 /**
-* @param {Uint8Array} v
-* @returns {PrivateEncKey}
-*/
+ * @param {Uint8Array} v
+ * @returns {PrivateEncKey}
+ */
 export function u8vec_to_cryptobox_sk(v: Uint8Array): PrivateEncKey;
 /**
-* @param {Uint8Array} msg
-* @param {PublicEncKey} their_pk
-* @param {PrivateEncKey} my_sk
-* @returns {CryptoBoxCt}
-*/
+ * @param {Uint8Array} msg
+ * @param {PublicEncKey} their_pk
+ * @param {PrivateEncKey} my_sk
+ * @returns {CryptoBoxCt}
+ */
 export function cryptobox_encrypt(msg: Uint8Array, their_pk: PublicEncKey, my_sk: PrivateEncKey): CryptoBoxCt;
 /**
-* @param {CryptoBoxCt} ct
-* @param {PrivateEncKey} my_sk
-* @param {PublicEncKey} their_pk
-* @returns {Uint8Array}
-*/
+ * @param {CryptoBoxCt} ct
+ * @param {PrivateEncKey} my_sk
+ * @param {PublicEncKey} their_pk
+ * @returns {Uint8Array}
+ */
 export function cryptobox_decrypt(ct: CryptoBoxCt, my_sk: PrivateEncKey, their_pk: PublicEncKey): Uint8Array;
 /**
-* Process the reencryption response from JavaScript objects.
-* The result is a byte array representing a plaintext of any length.
-*
-* * `client` - client that wants to perform reencryption.
-*
-* * `request` - the initial reencryption request JS object.
-* 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.
-* ```
-* {
-*   signature: '15a4f9a8eb61459cfba7d103d8f911fb04ce91ecf841b34c49c0d56a70b896d20cbc31986188f91efc3842b7df215cee8acb40178daedb8b63d0ba5d199bce121c',
-*   client_address: '0x17853A630aAe15AED549B2B874de08B73C0F59c5',
-*   enc_key: '2000000000000000df2fcacb774f03187f3802a27259f45c06d33cefa68d9c53426b15ad531aa822',
-*   ciphertext_digest: '0748b542afe2353c86cb707e3d21044b0be1fd18efc7cbaa6a415af055bfb358',
-*   eip712_verifying_contract: '0x66f9664f97F2b50F62D13eA064982f936dE76657'
-* }
-* ```
-*
-* * `eip712_domain` - the EIP-712 domain JS object.
-* It can be set to null if `verify` is false.
-* Otherwise the caller needs to give the following JS object.
-* Note that `salt` is optional and `verifying_contract` follows EIP-55,
-* additionally, `chain_id` is an array of u8.
-* ```
-* {
-*   name: 'Authorization token',
-*   version: '1',
-*   chain_id: [
-*     70, 31, 0, 0, 0, 0, 0, 0, 0,
-*      0,  0, 0, 0, 0, 0, 0, 0, 0,
-*      0,  0, 0, 0, 0, 0, 0, 0, 0,
-*      0,  0, 0, 0, 0
-*   ],
-*   verifying_contract: '0x66f9664f97F2b50F62D13eA064982f936dE76657',
-*   salt: []
-* }
-* ```
-*
-* * `agg_resp` - the response JS object from the gateway.
-* It has two fields like so, both are hex encoded byte arrays.
-* ```
-* [
-*   {
-*     signature: '69e7e040cab157aa819015b321c012dccb1545ffefd325b359b492653f0347517e28e66c572cdc299e259024329859ff9fcb0096e1ce072af0b6e1ca1fe25ec6',
-*     payload: '0100000029...'
-*   }
-* ]
-* ```
-*
-* * `enc_pk` - The ephemeral public key.
-*
-* * `enc_sk` - The ephemeral secret key.
-*
-* * `verify` - Whether to perform signature verification for the response.
-* It is insecure if `verify = false`!
-* @param {Client} client
-* @param {any} request
-* @param {any} eip712_domain
-* @param {any} agg_resp
-* @param {PublicEncKey} enc_pk
-* @param {PrivateEncKey} enc_sk
-* @param {boolean} verify
-* @returns {Uint8Array}
-*/
+ * Process the reencryption response from JavaScript objects.
+ * The returned result is a byte array representing a plaintext of any length,
+ * postprocessing is returned to turn it into an integer.
+ *
+ * * `client` - client that wants to perform reencryption.
+ *
+ * * `request` - the initial reencryption request JS object.
+ * 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.
+ * ```
+ * {
+ *   signature: '15a4f9a8eb61459cfba7d103d8f911fb04ce91ecf841b34c49c0d56a70b896d20cbc31986188f91efc3842b7df215cee8acb40178daedb8b63d0ba5d199bce121c',
+ *   client_address: '0x17853A630aAe15AED549B2B874de08B73C0F59c5',
+ *   enc_key: '2000000000000000df2fcacb774f03187f3802a27259f45c06d33cefa68d9c53426b15ad531aa822',
+ *   ciphertext_handle: '0748b542afe2353c86cb707e3d21044b0be1fd18efc7cbaa6a415af055bfb358',
+ *   eip712_verifying_contract: '0x66f9664f97F2b50F62D13eA064982f936dE76657'
+ * }
+ * ```
+ *
+ * * `eip712_domain` - the EIP-712 domain JS object.
+ * It can be set to null if `verify` is false.
+ * Otherwise the caller needs to give the following JS object.
+ * Note that `salt` is optional and `verifying_contract` follows EIP-55,
+ * additionally, `chain_id` is an array of u8.
+ * ```
+ * {
+ *   name: 'Authorization token',
+ *   version: '1',
+ *   chain_id: [
+ *     70, 31, 0, 0, 0, 0, 0, 0, 0,
+ *      0,  0, 0, 0, 0, 0, 0, 0, 0,
+ *      0,  0, 0, 0, 0, 0, 0, 0, 0,
+ *      0,  0, 0, 0, 0
+ *   ],
+ *   verifying_contract: '0x66f9664f97F2b50F62D13eA064982f936dE76657',
+ *   salt: []
+ * }
+ * ```
+ *
+ * * `agg_resp` - the response JS object from the gateway.
+ * It has two fields like so, both are hex encoded byte arrays.
+ * ```
+ * [
+ *   {
+ *     signature: '69e7e040cab157aa819015b321c012dccb1545ffefd325b359b492653f0347517e28e66c572cdc299e259024329859ff9fcb0096e1ce072af0b6e1ca1fe25ec6',
+ *     payload: '0100000029...'
+ *   }
+ * ]
+ * ```
+ *
+ * * `enc_pk` - The ephemeral public key.
+ *
+ * * `enc_sk` - The ephemeral secret key.
+ *
+ * * `verify` - Whether to perform signature verification for the response.
+ * It is insecure if `verify = false`!
+ * @param {Client} client
+ * @param {any} request
+ * @param {any} eip712_domain
+ * @param {any} agg_resp
+ * @param {PublicEncKey} enc_pk
+ * @param {PrivateEncKey} enc_sk
+ * @param {boolean} verify
+ * @returns {Uint8Array}
+ */
 export function process_reencryption_resp_from_js(client: Client, request: any, eip712_domain: any, agg_resp: any, enc_pk: PublicEncKey, enc_sk: PrivateEncKey, verify: boolean): Uint8Array;
 /**
-* Process the reencryption response from Rust objects.
-* Consider using [process_reencryption_resp_from_js]
-* when using the JS API.
-* The result is a byte array representing a plaintext of any length.
-*
-* * `client` - client that wants to perform reencryption.
-*
-* * `request` - the initial reencryption request.
-* Must be given if `verify` is true.
-*
-* * `eip712_domain` - the EIP-712 domain.
-* Must be given if `verify` is true.
-*
-* * `agg_resp` - the vector of reencryption responses.
-*
-* * `enc_pk` - The ephemeral public key.
-*
-* * `enc_sk` - The ephemeral secret key.
-*
-* * `verify` - Whether to perform signature verification for the response.
-* It is insecure if `verify = false`!
-* @param {Client} client
-* @param {ParsedReencryptionRequest | undefined} request
-* @param {Eip712DomainMsg | undefined} eip712_domain
-* @param {(ReencryptionResponse)[]} agg_resp
-* @param {PublicEncKey} enc_pk
-* @param {PrivateEncKey} enc_sk
-* @param {boolean} verify
-* @returns {Uint8Array}
-*/
+ * Process the reencryption response from Rust objects.
+ * Consider using [process_reencryption_resp_from_js]
+ * when using the JS API.
+ * The result is a byte array representing a plaintext of any length.
+ *
+ * * `client` - client that wants to perform reencryption.
+ *
+ * * `request` - the initial reencryption request.
+ * Must be given if `verify` is true.
+ *
+ * * `eip712_domain` - the EIP-712 domain.
+ * Must be given if `verify` is true.
+ *
+ * * `agg_resp` - the vector of reencryption responses.
+ *
+ * * `enc_pk` - The ephemeral public key.
+ *
+ * * `enc_sk` - The ephemeral secret key.
+ *
+ * * `verify` - Whether to perform signature verification for the response.
+ * It is insecure if `verify = false`!
+ * @param {Client} client
+ * @param {ParsedReencryptionRequest | undefined} request
+ * @param {Eip712DomainMsg | undefined} eip712_domain
+ * @param {(ReencryptionResponse)[]} agg_resp
+ * @param {PublicEncKey} enc_pk
+ * @param {PrivateEncKey} enc_sk
+ * @param {boolean} verify
+ * @returns {Uint8Array}
+ */
 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): Uint8Array;
 /**
-* The plaintext types that can be encrypted in a fhevm ciphertext.
-*/
+ * The plaintext types that can be encrypted in a fhevm ciphertext.
+ */
 export enum FheType {
   Ebool = 0,
   Euint4 = 1,
@@ -212,194 +213,154 @@ export enum FheType {
   Euint2048 = 11,
 }
 /**
-* Simple client to interact with the KMS servers. This can be seen as a proof-of-concept
-* and reference code for validating the KMS. The logic supplied by the client will be
-* distributed across the aggregator/proxy and smart contracts.
-*/
+ * Simple client to interact with the KMS servers. This can be seen as a proof-of-concept
+ * and reference code for validating the KMS. The logic supplied by the client will be
+ * distributed across the aggregator/proxy and smart contracts.
+ */
 export class Client {
   free(): void;
 }
-/**
-*/
 export class CryptoBoxCt {
   free(): void;
 }
 /**
-* <https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator>
-* eventually chain_id, verifying_contract and salt will be parsed in to
-* solidity types
-*/
+ * <https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator>
+ * eventually chain_id, verifying_contract and salt will be parsed in to
+ * solidity types
+ */
 export class Eip712DomainMsg {
   free(): void;
-/**
-*/
   chain_id: Uint8Array;
-/**
-*/
   name: string;
-/**
-*/
-  salt: Uint8Array;
-/**
-*/
+  salt?: Uint8Array;
   verifying_contract: string;
-/**
-*/
   version: string;
 }
 /**
-* Validity of this struct is not checked.
-*/
+ * Validity of this struct is not checked.
+ */
 export class ParsedReencryptionRequest {
   free(): void;
 }
-/**
-*/
 export class Plaintext {
   free(): void;
-/**
-*/
   bytes: Uint8Array;
 }
-/**
-*/
 export class PrivateEncKey {
   free(): void;
 }
-/**
-*/
 export class PrivateSigKey {
   free(): void;
 }
-/**
-*/
 export class PublicEncKey {
   free(): void;
 }
-/**
-*/
 export class PublicSigKey {
   free(): void;
 }
-/**
-*/
 export class ReencryptionRequest {
   free(): void;
-/**
-*/
   domain?: Eip712DomainMsg;
-/**
-*/
   payload?: ReencryptionRequestPayload;
 /**
-* The ID that identifies this request.
-* Future queries for the result must use this request ID.
-*/
+ * The ID that identifies this request.
+ * Future queries for the result must use this request ID.
+ */
   request_id?: RequestId;
 /**
-* Signature of the serialization of \[ReencryptionRequestPayload\].
-*/
+ * Signature of the serialization of \[ReencryptionRequestPayload\].
+ */
   signature: Uint8Array;
 }
-/**
-*/
 export class ReencryptionRequestPayload {
   free(): void;
 /**
-* The actual ciphertext to decrypt, taken directly from the fhevm.
-* When creating the payload, this field may be empty,
-* it is the responsibility of the gateway to fetch the
-* ciphertext for the given digest below.
-*/
+ * The actual ciphertext to decrypt, taken directly from the fhevm.
+ * When creating the payload, this field may be empty,
+ * it is the responsibility of the gateway to fetch the
+ * ciphertext for the given digest below.
+ */
   ciphertext?: Uint8Array;
 /**
-* The SHA3 digest of the ciphertext above.
-*/
+ * The SHA3 digest of the ciphertext above.
+ */
   ciphertext_digest: Uint8Array;
 /**
-* The client's (blockchain wallet) address,
-* encoded using EIP-55.
-*/
+ * The client's (blockchain wallet) address,
+ * encoded using EIP-55.
+ */
   client_address: string;
 /**
-* Encoding of the user's public encryption key for this request.
-* Encoding using the default encoding of libsodium, i.e. the 32 bytes of a
-* Montgomery point.
-*/
+ * Encoding of the user's public encryption key for this request.
+ * Encoding using the default encoding of libsodium, i.e. the 32 bytes of a
+ * Montgomery point.
+ */
   enc_key: Uint8Array;
 /**
-* The type of plaintext encrypted.
-*/
+ * The type of plaintext encrypted.
+ */
   fhe_type: number;
 /**
-* The key id to use for decryption. Will be the request_id used during key
-* generation
-*/
+ * The key id to use for decryption. Will be the request_id used during key
+ * generation
+ */
   key_id?: RequestId;
 /**
-* Version of the request format.
-*/
+ * Version of the request format.
+ */
   version: number;
 }
-/**
-*/
 export class ReencryptionResponse {
   free(): void;
 /**
-* Signature of the serialization of \[ReencryptionResponsePayload\].
-*/
+ * Signature of the serialization of \[ReencryptionResponsePayload\].
+ */
   payload?: ReencryptionResponsePayload;
-/**
-*/
   signature: Uint8Array;
 }
-/**
-*/
 export class ReencryptionResponsePayload {
   free(): void;
 /**
-* The degree of the sharing scheme used.
-*/
+ * The degree of the sharing scheme used.
+ */
   degree: number;
 /**
-* The concatenation of two digests:
-* (eip712_signing_hash(pk, domain) || ciphertext digest).
-* This is needed to ensure the response corresponds to the request.
-*/
+ * The concatenation of two digests:
+ * (eip712_signing_hash(pk, domain) || ciphertext digest).
+ * This is needed to ensure the response corresponds to the request.
+ */
   digest: Uint8Array;
 /**
-* The type of plaintext encrypted.
-*/
+ * The type of plaintext encrypted.
+ */
   fhe_type: number;
 /**
-* The ID of the MPC party doing the reencryption. Used for polynomial
-* reconstruction.
-*/
+ * The ID of the MPC party doing the reencryption. Used for polynomial
+ * reconstruction.
+ */
   party_id: number;
 /**
-* The signcrypted payload, using a hybrid encryption approach in
-* sign-then-encrypt.
-*/
+ * The signcrypted payload, using a hybrid encryption approach in
+ * sign-then-encrypt.
+ */
   signcrypted_ciphertext: Uint8Array;
 /**
-* 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.
-*/
+ * 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;
 /**
-* Version of the response format.
-*/
+ * Version of the response format.
+ */
   version: number;
 }
 /**
-* Simple response to return an ID, to be used to retrieve the computed result
-* later on.
-*/
+ * Simple response to return an ID, to be used to retrieve the computed result
+ * later on.
+ */
 export class RequestId {
   free(): void;
-/**
-*/
   request_id: string;
 }