@inco/js 0.6.9 → 0.7.0

package/dist/esm/generated/local-node.js

@@ -2,30 +2,50 @@ export const localNodeLightningConfig = {
     "testnet": {
         "executorAddress": "0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd",
         "chainId": 31337,
-        "covalidatorUrl": "http://localhost:50055",
+        "covalidatorUrls": [
+            "http://localhost:50055"
+        ],
+        "signers": [
+            "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+        ],
         "hostChainRpcUrl": "http://localhost:8545",
         "senderPrivateKey": "0x78a25e2a0b5148290cc4d93ae12338dabd6ccd6dd98276514c4168dc4100df7c"
     },
     "devnet": {
         "executorAddress": "0x3473820DcAa71Af8157b93C7f2bf1c676A2A39A6",
         "chainId": 31337,
-        "covalidatorUrl": "http://localhost:50055",
+        "covalidatorUrls": [
+            "http://localhost:50055"
+        ],
+        "signers": [
+            "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+        ],
         "hostChainRpcUrl": "http://localhost:8545",
         "senderPrivateKey": "0x6f2539401f377d76bafd39b580e0f95b9bf7d39dec8fd3ada4abe41ad2ae1e18"
     },
     "alphanet": {
-        "executorAddress": "0x28676Cd3b10b03b2FDF105Ba280425b45a674F2A",
+        "executorAddress": "0xc0d693DeEF0A91CE39208676b6da09B822abd199",
         "chainId": 31337,
-        "covalidatorUrl": "http://localhost:50055",
+        "covalidatorUrls": [
+            "http://localhost:50055"
+        ],
+        "signers": [
+            "0x8E873085348a3406A07907E5d1465B9824bA07cd"
+        ],
         "hostChainRpcUrl": "http://localhost:8545",
-        "senderPrivateKey": "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d"
+        "senderPrivateKey": "0x279c172cf3638a79642daa5f7666c600befde318550d7579cf96280920e318b6"
     },
     "scratch": {
-        "executorAddress": "0x195ec7fDf68fD835b9F78d6eb13E280cC2e25fdD",
+        "executorAddress": "0x230b8fb0201E621Be3612ab7387d164f8AdC863f",
         "chainId": 31337,
-        "covalidatorUrl": "http://localhost:50055",
+        "covalidatorUrls": [
+            "http://localhost:50055"
+        ],
+        "signers": [
+            "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+        ],
         "hostChainRpcUrl": "http://127.0.0.1:8567",
         "senderPrivateKey": "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
     }
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtbm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9nZW5lcmF0ZWQvbG9jYWwtbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBRztJQUN0QyxTQUFTLEVBQUU7UUFDVCxpQkFBaUIsRUFBRSw0Q0FBNEM7UUFDL0QsU0FBUyxFQUFFLEtBQUs7UUFDaEIsZ0JBQWdCLEVBQUUsd0JBQXdCO1FBQzFDLGlCQUFpQixFQUFFLHVCQUF1QjtRQUMxQyxrQkFBa0IsRUFBRSxvRUFBb0U7S0FDekY7SUFDRCxRQUFRLEVBQUU7UUFDUixpQkFBaUIsRUFBRSw0Q0FBNEM7UUFDL0QsU0FBUyxFQUFFLEtBQUs7UUFDaEIsZ0JBQWdCLEVBQUUsd0JBQXdCO1FBQzFDLGlCQUFpQixFQUFFLHVCQUF1QjtRQUMxQyxrQkFBa0IsRUFBRSxvRUFBb0U7S0FDekY7SUFDRCxVQUFVLEVBQUU7UUFDVixpQkFBaUIsRUFBRSw0Q0FBNEM7UUFDL0QsU0FBUyxFQUFFLEtBQUs7UUFDaEIsZ0JBQWdCLEVBQUUsd0JBQXdCO1FBQzFDLGlCQUFpQixFQUFFLHVCQUF1QjtRQUMxQyxrQkFBa0IsRUFBRSxvRUFBb0U7S0FDekY7SUFDRCxTQUFTLEVBQUU7UUFDVCxpQkFBaUIsRUFBRSw0Q0FBNEM7UUFDL0QsU0FBUyxFQUFFLEtBQUs7UUFDaEIsZ0JBQWdCLEVBQUUsd0JBQXdCO1FBQzFDLGlCQUFpQixFQUFFLHVCQUF1QjtRQUMxQyxrQkFBa0IsRUFBRSxvRUFBb0U7S0FDekY7Q0FDTyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtbm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9nZW5lcmF0ZWQvbG9jYWwtbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBRztJQUN0QyxTQUFTLEVBQUU7UUFDVCxpQkFBaUIsRUFBRSw0Q0FBNEM7UUFDL0QsU0FBUyxFQUFFLEtBQUs7UUFDaEIsaUJBQWlCLEVBQUU7WUFDakIsd0JBQXdCO1NBQ3pCO1FBQ0QsU0FBUyxFQUFFO1lBQ1QsNENBQTRDO1NBQzdDO1FBQ0QsaUJBQWlCLEVBQUUsdUJBQXVCO1FBQzFDLGtCQUFrQixFQUFFLG9FQUFvRTtLQUN6RjtJQUNELFFBQVEsRUFBRTtRQUNSLGlCQUFpQixFQUFFLDRDQUE0QztRQUMvRCxTQUFTLEVBQUUsS0FBSztRQUNoQixpQkFBaUIsRUFBRTtZQUNqQix3QkFBd0I7U0FDekI7UUFDRCxTQUFTLEVBQUU7WUFDVCw0Q0FBNEM7U0FDN0M7UUFDRCxpQkFBaUIsRUFBRSx1QkFBdUI7UUFDMUMsa0JBQWtCLEVBQUUsb0VBQW9FO0tBQ3pGO0lBQ0QsVUFBVSxFQUFFO1FBQ1YsaUJBQWlCLEVBQUUsNENBQTRDO1FBQy9ELFNBQVMsRUFBRSxLQUFLO1FBQ2hCLGlCQUFpQixFQUFFO1lBQ2pCLHdCQUF3QjtTQUN6QjtRQUNELFNBQVMsRUFBRTtZQUNULDRDQUE0QztTQUM3QztRQUNELGlCQUFpQixFQUFFLHVCQUF1QjtRQUMxQyxrQkFBa0IsRUFBRSxvRUFBb0U7S0FDekY7SUFDRCxTQUFTLEVBQUU7UUFDVCxpQkFBaUIsRUFBRSw0Q0FBNEM7UUFDL0QsU0FBUyxFQUFFLEtBQUs7UUFDaEIsaUJBQWlCLEVBQUU7WUFDakIsd0JBQXdCO1NBQ3pCO1FBQ0QsU0FBUyxFQUFFO1lBQ1QsNENBQTRDO1NBQzdDO1FBQ0QsaUJBQWlCLEVBQUUsdUJBQXVCO1FBQzFDLGtCQUFrQixFQUFFLG9FQUFvRTtLQUN6RjtDQUNPLENBQUMifQ==

package/dist/esm/kms/client.d.ts

@@ -1,8 +1,12 @@
-import { Client } from '@connectrpc/connect';
-import { SupportedChain } from '../chain.js';
+import { type Client } from '@connectrpc/connect';
+import type { Address } from 'viem';
+import type { SupportedChain } from '../chain.js';
 import { KmsService } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
-export type KmsClient = Client<typeof KmsService>;
-export declare function getKmsClient(kmsConnectRpcEndpointOrClient: string | KmsClient): KmsClient;
+export declare const DEFAULT_COVALIDATOR_SIGNER: Address;
+export type KmsClient = Client<typeof KmsService> & {
+    signerAddress: Address;
+};
+export declare function getKmsClient(kmsConnectRpcEndpointOrClient: string | KmsClient, signerAddress: Address): KmsClient;
 export declare function defaultCovalidatorGrpc(chain: SupportedChain): string;
 export declare function lightningDevnetCovalidatorGrpc(chain: SupportedChain): string;
 export declare function lightningTestnetCovalidatorGrpc(chain: SupportedChain): string;

package/dist/esm/kms/client.js

@@ -1,15 +1,19 @@
 import { createClient } from '@connectrpc/connect';
 import { createConnectTransport } from '@connectrpc/connect-web';
 import { KmsService } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+// anvil zeroth address, while there is only one signer,
+// this does not matter, as we use these addresses for signer ordering
+export const DEFAULT_COVALIDATOR_SIGNER = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
 // Helper function to get a KMS client from a string or a Client instance.
-export function getKmsClient(kmsConnectRpcEndpointOrClient) {
+export function getKmsClient(kmsConnectRpcEndpointOrClient, signerAddress) {
     if (typeof kmsConnectRpcEndpointOrClient === 'string') {
         const transport = createConnectTransport({
             baseUrl: kmsConnectRpcEndpointOrClient,
         });
-        return createClient(KmsService, transport);
+        const client = createClient(KmsService, transport);
+        return Object.assign(client, { signerAddress });
     }
-    return kmsConnectRpcEndpointOrClient;
+    return Object.assign(kmsConnectRpcEndpointOrClient, { signerAddress });
 }
 // Helper function to return the default gRPC endpoint for the covalidator.
 // Currently, this returns the covalidator for the Inco Lightning public testnet.
@@ -32,4 +36,4 @@ function camelToDashCase(str) {
 function getCovalidatorGrpcHelper(chain, network, cluster) {
     return `https://grpc.${camelToDashCase(chain.name)}.${cluster}.${network}.inco.org`;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ttcy9jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFVLFlBQVksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzNELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRWpFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvREFBb0QsQ0FBQztBQUloRiwwRUFBMEU7QUFDMUUsTUFBTSxVQUFVLFlBQVksQ0FDMUIsNkJBQWlEO0lBRWpELElBQUksT0FBTyw2QkFBNkIsS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUN0RCxNQUFNLFNBQVMsR0FBRyxzQkFBc0IsQ0FBQztZQUN2QyxPQUFPLEVBQUUsNkJBQTZCO1NBQ3ZDLENBQUMsQ0FBQztRQUNILE9BQU8sWUFBWSxDQUFDLFVBQVUsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBRUQsT0FBTyw2QkFBNkIsQ0FBQztBQUN2QyxDQUFDO0FBRUQsMkVBQTJFO0FBQzNFLGlGQUFpRjtBQUNqRixNQUFNLFVBQVUsc0JBQXNCLENBQUMsS0FBcUI7SUFDMUQsT0FBTywrQkFBK0IsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUNoRCxDQUFDO0FBRUQsc0ZBQXNGO0FBQ3RGLE1BQU0sVUFBVSw4QkFBOEIsQ0FBQyxLQUFxQjtJQUNsRSxPQUFPLHdCQUF3QixDQUFDLEtBQUssRUFBRSxRQUFRLEVBQUUsV0FBVyxDQUFDLENBQUM7QUFDaEUsQ0FBQztBQUVELHVGQUF1RjtBQUN2RixNQUFNLFVBQVUsK0JBQStCLENBQUMsS0FBcUI7SUFDbkUsT0FBTyx3QkFBd0IsQ0FBQyxLQUFLLEVBQUUsU0FBUyxFQUFFLFdBQVcsQ0FBQyxDQUFDO0FBQ2pFLENBQUM7QUFFRCxrQ0FBa0M7QUFDbEMsU0FBUyxlQUFlLENBQUMsR0FBVztJQUNsQyxPQUFPLEdBQUcsQ0FBQyxPQUFPLENBQUMsaUJBQWlCLEVBQUUsT0FBTyxDQUFDLENBQUMsV0FBVyxFQUFFLENBQUM7QUFDL0QsQ0FBQztBQUVELHNFQUFzRTtBQUN0RSxTQUFTLHdCQUF3QixDQUMvQixLQUFxQixFQUNyQixPQUE2QixFQUM3QixPQUFvQjtJQUVwQixPQUFPLGdCQUFnQixlQUFlLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLE9BQU8sSUFBSSxPQUFPLFdBQVcsQ0FBQztBQUN0RixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ttcy9jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFlLFlBQVksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBR2pFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxvREFBb0QsQ0FBQztBQUVoRix3REFBd0Q7QUFDeEQsc0VBQXNFO0FBQ3RFLE1BQU0sQ0FBQyxNQUFNLDBCQUEwQixHQUNyQyw0Q0FBNEMsQ0FBQztBQUkvQywwRUFBMEU7QUFDMUUsTUFBTSxVQUFVLFlBQVksQ0FDMUIsNkJBQWlELEVBQ2pELGFBQXNCO0lBRXRCLElBQUksT0FBTyw2QkFBNkIsS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUN0RCxNQUFNLFNBQVMsR0FBRyxzQkFBc0IsQ0FBQztZQUN2QyxPQUFPLEVBQUUsNkJBQTZCO1NBQ3ZDLENBQUMsQ0FBQztRQUNILE1BQU0sTUFBTSxHQUFHLFlBQVksQ0FBQyxVQUFVLEVBQUUsU0FBUyxDQUFDLENBQUM7UUFDbkQsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxFQUFFLGFBQWEsRUFBRSxDQUFDLENBQUM7SUFDbEQsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyw2QkFBNkIsRUFBRSxFQUFFLGFBQWEsRUFBRSxDQUFDLENBQUM7QUFDekUsQ0FBQztBQUVELDJFQUEyRTtBQUMzRSxpRkFBaUY7QUFDakYsTUFBTSxVQUFVLHNCQUFzQixDQUFDLEtBQXFCO0lBQzFELE9BQU8sK0JBQStCLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDaEQsQ0FBQztBQUVELHNGQUFzRjtBQUN0RixNQUFNLFVBQVUsOEJBQThCLENBQUMsS0FBcUI7SUFDbEUsT0FBTyx3QkFBd0IsQ0FBQyxLQUFLLEVBQUUsUUFBUSxFQUFFLFdBQVcsQ0FBQyxDQUFDO0FBQ2hFLENBQUM7QUFFRCx1RkFBdUY7QUFDdkYsTUFBTSxVQUFVLCtCQUErQixDQUFDLEtBQXFCO0lBQ25FLE9BQU8sd0JBQXdCLENBQUMsS0FBSyxFQUFFLFNBQVMsRUFBRSxXQUFXLENBQUMsQ0FBQztBQUNqRSxDQUFDO0FBRUQsa0NBQWtDO0FBQ2xDLFNBQVMsZUFBZSxDQUFDLEdBQVc7SUFDbEMsT0FBTyxHQUFHLENBQUMsT0FBTyxDQUFDLGlCQUFpQixFQUFFLE9BQU8sQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO0FBQy9ELENBQUM7QUFFRCxzRUFBc0U7QUFDdEUsU0FBUyx3QkFBd0IsQ0FDL0IsS0FBcUIsRUFDckIsT0FBNkIsRUFDN0IsT0FBb0I7SUFFcEIsT0FBTyxnQkFBZ0IsZUFBZSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxPQUFPLElBQUksT0FBTyxXQUFXLENBQUM7QUFDdEYsQ0FBQyJ9

package/dist/esm/kms/quorumClient.d.ts

@@ -0,0 +1,58 @@
+import type { Address } from 'viem';
+import type { DecryptionAttestation, EncryptedDecryptionAttestation } from '../attesteddecrypt/types.js';
+import type { EciesScheme, SupportedFheType } from '../encryption/encryption.js';
+import type { AttestedComputeRequest, AttestedDecryptRequest, AttestedRevealRequest } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+import type { BackoffConfig } from '../retry.js';
+import { type KmsClient } from './client.js';
+export declare class KmsQuorumClient {
+    private readonly kmss;
+    private readonly threshold;
+    private constructor();
+    private constructor();
+    /**
+     * Creates a KmsQuorumClient from an array of URLs.
+     * Requires signer addresses and threshold to be explicitly provided.
+     *
+     * @param urls - Array of KMS endpoint URLs
+     * @param signers - Array of signer addresses, must match the length of URLs
+     * @param threshold - Number of successful responses required (must be between 1 and urls.length)
+     * @throws {Error} If URLs array is empty, signers length doesn't match URLs length, or threshold is invalid
+     */
+    static fromUrls(urls: string[], signers: Address[], threshold: number): KmsQuorumClient;
+    /**
+     * Creates a KmsQuorumClient from an array of KmsClient instances.
+     * Each KmsClient must have a signerAddress property.
+     *
+     * @param kmsClients - Array of KMS client instances
+     * @param threshold - Number of successful responses required (must be between 1 and kmsClients.length)
+     * @throws {Error} If KMS clients array is empty or threshold is invalid
+     */
+    static fromKmsClients(kmsClients: KmsClient[], threshold: number): KmsQuorumClient;
+    attestedDecrypt(request: AttestedDecryptRequest, backoffConfig?: Partial<BackoffConfig>): Promise<(DecryptionAttestation<EciesScheme, SupportedFheType> | EncryptedDecryptionAttestation<EciesScheme, SupportedFheType>)[]>;
+    attestedCompute(request: AttestedComputeRequest, backoffConfig?: Partial<BackoffConfig>): Promise<DecryptionAttestation<EciesScheme, SupportedFheType>>;
+    attestedReveal(request: AttestedRevealRequest, backoffConfig?: Partial<BackoffConfig>): Promise<(DecryptionAttestation<EciesScheme, SupportedFheType> | EncryptedDecryptionAttestation<EciesScheme, SupportedFheType>)[]>;
+    /**
+     * Generic method to execute a KMS operation across all clients with retry and threshold logic.
+     * Returns results with both the response and signer address.
+     */
+    private executeKmsOperationWithThreshold;
+    /**
+     * Collects signatures from responses and sorts them by signer address (ascending).
+     * This is required by SignatureVerifier.
+     */
+    private collectAndSortSignatures;
+    /**
+     * Builds a plaintext attestation from a DecryptionAttestation proto message.
+     */
+    private buildPlaintextAttestation;
+    private buildAggregatedAttestations;
+    private buildAggregatedComputeAttestation;
+    private verifyResponseConsistency;
+    private verifyComputeResponseConsistency;
+    /**
+     * Verifies that two plaintext byte arrays are identical.
+     */
+    private verifyPlaintextBytesConsistency;
+    private verifyPlaintextConsistency;
+    private verifyCiphertextConsistency;
+}

package/dist/esm/kms/quorumClient.js

@@ -0,0 +1,374 @@
+import { bytesToBigInt, bytesToHex, parseHex, } from '../binary.js';
+import { bigintToPlaintext, encryptionSchemes, } from '../encryption/encryption.js';
+import { getHandleType } from '../handle.js';
+import { retryWithBackoff } from '../retry.js';
+import { getKmsClient } from './client.js';
+import { executeWithThreshold } from './thresholdPromises.js';
+export class KmsQuorumClient {
+    kmss;
+    threshold;
+    // Implementation
+    constructor(attestersOrClients, threshold) {
+        if (attestersOrClients.length === 0) {
+            throw new Error('At least one attester or KMS client is required');
+        }
+        if (threshold < 1 || threshold > attestersOrClients.length) {
+            throw new Error(`Threshold must be between 1 and ${attestersOrClients.length}`);
+        }
+        // Check if first element is a KmsClient (has attestedDecrypt method) or an attester object
+        if (attestersOrClients.length > 0 &&
+            'attestedDecrypt' in attestersOrClients[0]) {
+            // Handle KmsClient[] case
+            const kmsClients = attestersOrClients;
+            this.kmss = kmsClients.map((client) => ({
+                client,
+                signer: client.signerAddress,
+            }));
+        }
+        else {
+            // Handle { url: string; signer: Address }[] case
+            const attesters = attestersOrClients;
+            this.kmss = attesters.map((attester) => {
+                return {
+                    client: getKmsClient(attester.url, attester.signer),
+                    signer: attester.signer,
+                };
+            });
+        }
+        this.threshold = threshold;
+    }
+    /**
+     * Creates a KmsQuorumClient from an array of URLs.
+     * Requires signer addresses and threshold to be explicitly provided.
+     *
+     * @param urls - Array of KMS endpoint URLs
+     * @param signers - Array of signer addresses, must match the length of URLs
+     * @param threshold - Number of successful responses required (must be between 1 and urls.length)
+     * @throws {Error} If URLs array is empty, signers length doesn't match URLs length, or threshold is invalid
+     */
+    static fromUrls(urls, signers, threshold) {
+        if (urls.length === 0) {
+            throw new Error('At least one URL is required');
+        }
+        if (signers.length !== urls.length) {
+            throw new Error(`Signers array length (${signers.length}) must match URLs array length (${urls.length})`);
+        }
+        if (threshold < 1 || threshold > urls.length) {
+            throw new Error(`Threshold must be between 1 and ${urls.length} (number of URLs)`);
+        }
+        const attesters = urls.map((url, index) => {
+            return { url, signer: signers[index] };
+        });
+        return new KmsQuorumClient(attesters, threshold);
+    }
+    /**
+     * Creates a KmsQuorumClient from an array of KmsClient instances.
+     * Each KmsClient must have a signerAddress property.
+     *
+     * @param kmsClients - Array of KMS client instances
+     * @param threshold - Number of successful responses required (must be between 1 and kmsClients.length)
+     * @throws {Error} If KMS clients array is empty or threshold is invalid
+     */
+    static fromKmsClients(kmsClients, threshold) {
+        if (kmsClients.length === 0) {
+            throw new Error('At least one KMS client is required');
+        }
+        if (threshold < 1 || threshold > kmsClients.length) {
+            throw new Error(`Threshold must be between 1 and ${kmsClients.length} (number of KMS clients)`);
+        }
+        return new KmsQuorumClient(kmsClients, threshold);
+    }
+    async attestedDecrypt(request, backoffConfig) {
+        const thresholdResults = await this.executeKmsOperationWithThreshold(async (kms) => {
+            return await kms.client.attestedDecrypt(request);
+        }, backoffConfig);
+        // Extract responses and signers
+        const thresholdResponses = thresholdResults.map((r) => r.response);
+        const signers = thresholdResults.map((r) => r.signer);
+        // Verify that responses are consistent across quorum (plaintext or ciphertext)
+        const reference = this.verifyResponseConsistency(thresholdResponses);
+        return this.buildAggregatedAttestations(reference, thresholdResponses, signers);
+    }
+    async attestedCompute(request, backoffConfig) {
+        const thresholdResults = await this.executeKmsOperationWithThreshold(async (kms) => {
+            return await kms.client.attestedCompute(request);
+        }, backoffConfig);
+        // Extract responses and signers
+        const thresholdResponses = thresholdResults.map((r) => r.response);
+        const signers = thresholdResults.map((r) => r.signer);
+        // Verify that responses are consistent across quorum
+        const reference = this.verifyComputeResponseConsistency(thresholdResponses);
+        return this.buildAggregatedComputeAttestation(reference, thresholdResponses, signers);
+    }
+    async attestedReveal(request, backoffConfig) {
+        const thresholdResults = await this.executeKmsOperationWithThreshold(async (kms) => {
+            return await kms.client.attestedReveal(request);
+        }, backoffConfig);
+        // Extract responses and signers
+        const thresholdResponses = thresholdResults.map((r) => r.response);
+        const signers = thresholdResults.map((r) => r.signer);
+        // Verify that responses are consistent across quorum (plaintext or ciphertext)
+        const reference = this.verifyResponseConsistency(thresholdResponses);
+        return this.buildAggregatedAttestations(reference, thresholdResponses, signers);
+    }
+    /**
+     * Generic method to execute a KMS operation across all clients with retry and threshold logic.
+     * Returns results with both the response and signer address.
+     */
+    async executeKmsOperationWithThreshold(operation, backoffConfig) {
+        // Create promises for all KMS clients, tracking signer addresses
+        // Each client call is wrapped with retry logic
+        const promises = this.kmss.map(async (kms, index) => {
+            try {
+                const response = await retryWithBackoff(async () => {
+                    return await operation(kms);
+                }, backoffConfig);
+                return { response, signer: kms.signer };
+            }
+            catch (error) {
+                throw new Error(`KMS client ${index} failed: ${error}`);
+            }
+        });
+        return await executeWithThreshold(promises, this.threshold);
+    }
+    /**
+     * Collects signatures from responses and sorts them by signer address (ascending).
+     * This is required by SignatureVerifier.
+     */
+    collectAndSortSignatures(signatures, signers) {
+        const signaturesWithSigners = signatures.map((signature, idx) => ({
+            signature,
+            signer: signers[idx],
+        }));
+        // Sort by signer address in ascending order (as required by SignatureVerifier)
+        signaturesWithSigners.sort((a, b) => {
+            const aBigInt = BigInt(a.signer);
+            const bBigInt = BigInt(b.signer);
+            if (aBigInt < bBigInt)
+                return -1;
+            if (aBigInt > bBigInt)
+                return 1;
+            return 0;
+        });
+        // Extract sorted signatures
+        return signaturesWithSigners.map((item) => item.signature);
+    }
+    /**
+     * Builds a plaintext attestation from a DecryptionAttestation proto message.
+     */
+    buildPlaintextAttestation(decryptionAttestation, covalidatorSignatures) {
+        if (!decryptionAttestation.value ||
+            decryptionAttestation.value.case !== 'plaintext') {
+            throw new Error('Expected plaintext attestation');
+        }
+        const plaintextBytes = decryptionAttestation.value.value.value;
+        const handle = decryptionAttestation.handle;
+        const handleType = getHandleType(handle);
+        const bigIntValue = bytesToBigInt(plaintextBytes);
+        const plaintext = bigintToPlaintext(encryptionSchemes.ecies, handleType, bigIntValue);
+        return {
+            handle,
+            plaintext,
+            covalidatorSignatures,
+        };
+    }
+    buildAggregatedAttestations(reference, thresholdResponses, signers) {
+        const attestationCount = reference.decryptionAttestations.length;
+        return new Array(attestationCount).fill(undefined).map((_, i) => {
+            const refAtt = reference.decryptionAttestations[i];
+            if (!refAtt.value) {
+                throw new Error('No value in attestation');
+            }
+            // Collect signatures and sort by signer address
+            const signatures = thresholdResponses.map((resp) => resp.decryptionAttestations[i].signature);
+            const covalidatorSignatures = this.collectAndSortSignatures(signatures, signers);
+            if (refAtt.value.case === 'plaintext') {
+                return this.buildPlaintextAttestation(refAtt, covalidatorSignatures);
+            }
+            else if (refAtt.value.case === 'reencryption') {
+                const reencryption = refAtt.value.value;
+                const ct = reencryption.userCiphertext;
+                const fheType = getHandleType(parseHex(reencryption.handle));
+                return {
+                    handle: refAtt.handle,
+                    encryptedPlaintext: {
+                        ciphertext: {
+                            value: bytesToHex(ct),
+                            scheme: 1, // EciesScheme
+                            type: fheType,
+                        },
+                    },
+                    covalidatorSignatures,
+                };
+            }
+            else {
+                throw new Error(`Unexpected attestation type: ${refAtt.value.case}, expected 'plaintext' or 'reencryption'`);
+            }
+        });
+    }
+    buildAggregatedComputeAttestation(reference, thresholdResponses, signers) {
+        const refAtt = reference.decryptionAttestation;
+        if (!refAtt) {
+            throw new Error('No decryption attestation in reference response');
+        }
+        if (!refAtt.value) {
+            throw new Error('No value in reference attestation');
+        }
+        if (refAtt.value.case !== 'plaintext') {
+            throw new Error(`Unexpected attestation type: ${refAtt.value.case}, expected 'plaintext'`);
+        }
+        // Collect signatures and sort by signer address
+        // We know all responses have decryption attestations from verifyComputeResponseConsistency
+        const signatures = [];
+        for (const resp of thresholdResponses) {
+            const att = resp.decryptionAttestation;
+            if (att) {
+                signatures.push(att.signature);
+            }
+        }
+        const covalidatorSignatures = this.collectAndSortSignatures(signatures, signers);
+        return this.buildPlaintextAttestation(refAtt, covalidatorSignatures);
+    }
+    verifyResponseConsistency(thresholdResponses) {
+        if (thresholdResponses.length === 0) {
+            throw new Error('No responses collected to verify');
+        }
+        const reference = thresholdResponses[0];
+        for (let r = 1; r < thresholdResponses.length; r++) {
+            if (thresholdResponses[r].decryptionAttestations.length !==
+                reference.decryptionAttestations.length) {
+                throw new Error('Inconsistent number of decryption attestations across KMS responses');
+            }
+        }
+        for (let i = 0; i < reference.decryptionAttestations.length; i++) {
+            const refAtt = reference.decryptionAttestations[i];
+            if (!refAtt.value) {
+                throw new Error('No value in reference attestation');
+            }
+            const refCase = refAtt.value.case;
+            // Verify that all responses have the same case (plaintext or reencryption)
+            for (let r = 1; r < thresholdResponses.length; r++) {
+                const att = thresholdResponses[r].decryptionAttestations[i];
+                if (!att.value) {
+                    throw new Error('No value in attestation');
+                }
+                if (att.value.case !== refCase) {
+                    throw new Error(`Inconsistent attestation types: reference has '${refCase}' but response ${r} has '${att.value.case}'`);
+                }
+            }
+            // Verify consistency based on the case
+            if (refCase === 'plaintext') {
+                this.verifyPlaintextConsistency(i, reference, thresholdResponses);
+            }
+            else if (refCase === 'reencryption') {
+                this.verifyCiphertextConsistency(i, reference, thresholdResponses);
+            }
+            else {
+                throw new Error(`Unexpected attestation type: ${refCase}, expected 'plaintext' or 'reencryption'`);
+            }
+        }
+        return reference;
+    }
+    verifyComputeResponseConsistency(thresholdResponses) {
+        if (thresholdResponses.length === 0) {
+            throw new Error('No responses collected to verify');
+        }
+        const reference = thresholdResponses[0];
+        const refAtt = reference.decryptionAttestation;
+        if (!refAtt) {
+            throw new Error('No decryption attestation in reference response');
+        }
+        if (!refAtt.value) {
+            throw new Error('No value in reference attestation');
+        }
+        if (refAtt.value.case !== 'plaintext') {
+            throw new Error(`Unexpected attestation type: ${refAtt.value.case}, expected 'plaintext'`);
+        }
+        // Verify that all responses have a decryption attestation
+        for (let r = 1; r < thresholdResponses.length; r++) {
+            const att = thresholdResponses[r].decryptionAttestation;
+            if (!att) {
+                throw new Error('No decryption attestation in response');
+            }
+            if (!att.value) {
+                throw new Error('No value in attestation');
+            }
+            if (att.value.case !== 'plaintext') {
+                throw new Error('Expected plaintext attestation but received non-plaintext');
+            }
+            // Verify handles match
+            if (att.handle !== refAtt.handle) {
+                throw new Error('Handles differ across KMS responses');
+            }
+            // Verify plaintext values match
+            this.verifyPlaintextBytesConsistency(refAtt.value.value.value, att.value.value.value);
+        }
+        return reference;
+    }
+    /**
+     * Verifies that two plaintext byte arrays are identical.
+     */
+    verifyPlaintextBytesConsistency(refBytes, bytes) {
+        if (refBytes.length !== bytes.length) {
+            throw new Error('Plaintexts differ across KMS responses');
+        }
+        for (let b = 0; b < refBytes.length; b++) {
+            if (refBytes[b] !== bytes[b]) {
+                throw new Error('Plaintexts differ across KMS responses');
+            }
+        }
+    }
+    verifyPlaintextConsistency(index, reference, thresholdResponses) {
+        const refAtt = reference.decryptionAttestations[index];
+        if (refAtt.value?.case !== 'plaintext') {
+            throw new Error('Expected plaintext attestation');
+        }
+        const refBytes = refAtt.value.value.value;
+        for (let r = 1; r < thresholdResponses.length; r++) {
+            const att = thresholdResponses[r].decryptionAttestations[index];
+            if (att.value?.case !== 'plaintext') {
+                throw new Error('Expected plaintext attestation but received non-plaintext');
+            }
+            const bytes = att.value.value.value;
+            this.verifyPlaintextBytesConsistency(refBytes, bytes);
+        }
+    }
+    verifyCiphertextConsistency(index, reference, thresholdResponses) {
+        const refAtt = reference.decryptionAttestations[index];
+        if (refAtt.value?.case !== 'reencryption') {
+            throw new Error('Expected reencryption attestation');
+        }
+        const refReencryption = refAtt.value.value;
+        const refCt = refReencryption.userCiphertext;
+        if (!refCt) {
+            throw new Error('No ciphertext in reference reencryption');
+        }
+        const refFheType = getHandleType(parseHex(refReencryption.handle));
+        for (let r = 1; r < thresholdResponses.length; r++) {
+            const att = thresholdResponses[r].decryptionAttestations[index];
+            if (att.value?.case !== 'reencryption') {
+                throw new Error('Expected reencryption attestation but received non-reencryption');
+            }
+            const reencryption = att.value.value;
+            const ct = reencryption.userCiphertext;
+            if (!ct) {
+                throw new Error('No ciphertext in reencryption');
+            }
+            const fheType = getHandleType(parseHex(reencryption.handle));
+            // Verify FHE type matches
+            if (fheType !== refFheType) {
+                throw new Error('FHE types differ across KMS responses');
+            }
+            // Verify ciphertext bytes match
+            if (refCt.length !== ct.length) {
+                throw new Error('Ciphertexts differ across KMS responses');
+            }
+            for (let b = 0; b < refCt.length; b++) {
+                if (refCt[b] !== ct[b]) {
+                    throw new Error('Ciphertexts differ across KMS responses');
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quorumClient.js","sourceRoot":"","sources":["../../../src/kms/quorumClient.ts"],"names":[],"mappings":"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"}

package/dist/esm/kms/thresholdPromises.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Executes promises and returns results as soon as threshold is reached
+ * @param promises Array of promises to execute
+ * @param threshold Number of successful responses needed
+ * @returns Promise that resolves with threshold number of results
+ */
+export declare function executeWithThreshold<T>(promises: Promise<T>[], threshold: number): Promise<T[]>;

package/dist/esm/kms/thresholdPromises.js

@@ -0,0 +1,49 @@
+/**
+ * Executes promises and returns results as soon as threshold is reached
+ * @param promises Array of promises to execute
+ * @param threshold Number of successful responses needed
+ * @returns Promise that resolves with threshold number of results
+ */
+export async function executeWithThreshold(promises, threshold) {
+    if (threshold < 0) {
+        throw new Error('Threshold cannot be negative');
+    }
+    // If threshold is 0, resolve immediately.
+    if (threshold === 0) {
+        return [];
+    }
+    if (promises.length === 0 && threshold > 0) {
+        throw new Error('Cannot reach positive threshold with no promises');
+    }
+    if (threshold > promises.length) {
+        throw new Error(`Threshold ${threshold} exceeds number of promises ${promises.length}`);
+    }
+    const results = [];
+    let failures = 0;
+    return new Promise((resolve, reject) => {
+        promises.forEach((promise) => {
+            promise
+                .then((response) => {
+                if (results.length < threshold) {
+                    results.push(response);
+                    if (results.length === threshold) {
+                        resolve(results);
+                    }
+                }
+            })
+                .catch((error) => {
+                console.error(`Error executing promise: ${error}`);
+                failures++;
+                // Check if we can still reach the threshold
+                // We need (threshold - results.length) more successes
+                // from (promises.length - results.length - failures) remaining promises
+                const remainingPromises = promises.length - results.length - failures;
+                const neededSuccesses = threshold - results.length;
+                if (remainingPromises < neededSuccesses) {
+                    reject(new Error(`Cannot reach threshold of ${threshold} responses. Failed clients exceed limit.`));
+                }
+            });
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lite/index.d.ts

@@ -7,4 +7,3 @@ export * from './deployments.js';
 export * from './ecies.js';
 export * from './hadu.js';
 export * from './lightning.js';
-export * from './reencrypt.js';