@silencelaboratories/walletprovider-sdk 1.5.0 → 1.7.0

package/README.md

@@ -2,14 +2,23 @@
 
 The client library for Silent Network Wallet Provider Service.
 
+## Table of contents
+
+
 - [Installing](#installing)
 - [Quick start](#quick-start)
 - [Documentation](#documentation)
-- [Features](#features)
-  - [Overview](#overview)
+- [SDK Usage](#sdk-usage)
   - [Authentication](#authentication)
-  - [Keygen](#keygen)
-  - [Signing](#signing)
+  - [Network Without Authentication](#network-without-authentication)
+    - [Keygen](#keygen)
+    - [Signgen](#signgen)
+  - [Network with Authentication](#network-with-authentication)
+    - [Keygen](#keygen-1)
+      - [Authenticate with EOA wallet](#authenticate-with-eoa-wallet)
+      - [Authenticate with Passkey](#authenticate-with-passkey)
+    - [Signing](#signing)
+    - [Key refresh](#key-refresh)
 - [Development](#development)
   - [Build the library](#build-the-library)
   - [End to end tests](#end-to-end-tests)
@@ -23,81 +32,112 @@ npm i @silencelaboratories/walletprovider-sdk
 ```
 
 # Quick start
-
-Check the [demo](./demo/README.md) for a quick start guide.
+We provide simple demo-page what showcases the features of this SDK.
+Check the [demo](https://github.com/silence-laboratories/walletprovider-sdk/tree/main/demo/) for a quick start guide.
 
 # Documentation
 
-For description of classes, interfaces, types, please refer to [documentation](./docs/walletprovider-sdk.md).
+For description of classes, interfaces, types, please refer to [documentation](https://github.com/silence-laboratories/walletprovider-sdk/tree/main/docs/index.html).
 
-# Features
+# SDK Usage
+## Authentication
+Requests to the network can be authenticated by the User, using Externally Owned Account (EOA), by Passkeys, some of the requests, by session keys (also known as ephemeral keys).
 
-- Authentication
-- Keygen
-- Signing
+- [Wallet-based](./docs/classes/EOAAuth.html) authenticate users using their digital wallet.
+- [Passkey](./docs/classes/PasskeyAuth.html) has 2 steps: **register** and **login**. The user registers a passkey with the network, then authenticates request in with the Passkey.
+- [Ephemeral keys](./docs/classes/EphAuth.html) Used to issue requests to the network and not prompt the user for the acceptance, contains expiry, and can be (self-)revoked.
 
-## Overview
+The authentication can be required, or not, depending on the version of Silent Network backend.
 
-The library provides API to authenticate, generate keys, and sign messages against the Silent Network. Before sending request for a distributed key or signature, users need to be authenticated to the Silent Network.
+In *no-authentication* case It's backend responsibility to authenticate the User, and then forward the request to the Silent Network nodes.
 
-Once authenticated, users register an ephemeral signing key pair and associate it with their identity. The ephemeral signing keys can later be used to authorize signing requests for duration of the session without the need for repeated user interaction, providing a seamless and secure authentication mechanism.
+For more information, please read [Types of architectures](https://docs.silent.sg/silent-network/architecture) in our high-level documentation.
 
-## Authentication
+> This SDK supports both versions of Silent Network, *no-authentication*, and where User authentication is required.
 
-Users authenticate to Silent Network using 2 methods [Wallet-based](./docs/walletprovider-sdk.eoaauth.md) or [Passkey](./docs/walletprovider-sdk.passkeyauth.md).
+## Network Without Authentication
+The request goes to the backend, without any sort of User authentication.
 
-- [Wallet-based](./docs/walletprovider-sdk.eoaauth.md) authenticate users using their digital wallet, it runs at the same time users start doing **keygen**.
+### Initialize the Client object
+Create the [NoAuthWalletProviderServiceClient](./docs/classes/NoAuthWalletProviderServiceClient.html), using [ClientConfig](./docs/types/ClientConfig.html). The `wpClient` will connect to the Wallet Provider Backend Service (WPBE).
 
-- [Passkey](./docs/walletprovider-sdk.passkeyauth.md) has 2 steps: **register** and **login**. The user registers a passkey with the network, then logs in with the passkey while starting the **keygen** process.
+```typescript
+const config = {
+  walletProviderUrl: "https://silent-network-no-auth.sandbox.silencelaboratories.com/wpbe1",
+  apiVersion: 'v2',
+} as ClientConfig;
 
+const wpClient = new NoAuthWalletProviderServiceClient(clientConfig);
+const sdk = new NetworkSigner(wpClient);
+```
 
-The [ephemeral public claim](./docs/walletprovider-sdk.eoaauth.ephclaim.md) will be associated with both [EOAAuth](./docs/walletprovider-sdk.eoaauth.md) and [PasskeyAuth](./docs/walletprovider-sdk.passkeyauth.md) objects.
+Following snippet will create client to `wpbe1` on our `silent-network-no-auth` sandbox, and will use `v2` endpoints.
 
-- Users will use [EphAuth](./docs/walletprovider-sdk.ephauth.md) to do non-interactive authenticate **during signing**.
-- The library supports 2 signing algorithms for ephemeral signing keys: `secp256k1, ed25519`
+Then pass the `wpClient` to the [NetworkSigner](./docs/classes/NetworkSigner.html). And use `NetworkSigner` for interacting with the WPBE.
 
-## Keygen
+### Keygen
+During keygen provide number of parties `n`, the threshold `t` and [types of the keys](./docs/types/MPCSignAlgorithm.html) you want to generate.
 
-The full working example is in the [demo](https://github.com/silence-laboratories/walletprovider-sdk/blob/main/demo/src/routes/%2Bpage.svelte).
-The core object to use is the [NetworkSigner](./docs/walletprovider-sdk.networksigner.md). It allows to generate keys and do signatures. 
+[Example usage](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/e2e-tests/client/src/actions/noAuth/keygen.ts#L75)
 
-In order to create your keys, you need two other components. The [WalletProviderServiceClient](./docs/walletprovider-sdk.walletproviderserviceclient.md) that connects to the Backend part of the SDK, and the **authenticator module**. 
+```typescript
+ const response = await sdk.generateKey(
+    config.threshold,
+    config.parties,
+    keySignAlgs,
+  );
+```
 
-### Authenticate with EOA wallet
-We provide EOA authentication via [EOAAuth](./docs/walletprovider-sdk.eoaauth.md) module. Let's create the `NetworkSigner` with associated `EOAAuth` object.
+### Signgen
+The message to be signed can be of [different types](./docs/types/SignRequestType.html).
+The example usage of different types is [shown here](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/e2e-tests/client/src/test/signature_verification.ts#L48).
 
-```ts
-const algSign = 'secp256k1'; // Signing algorithms of ephemeral key
-// Generate ephemeral secret key esk
-const sk = generateEphPrivateKey(algSign);
-// Derive public part epk from esk
-const ephPK = getEphPublicKey(sk, algSign);
-// Arbitrary ID to identify the ephemeral key
-const ephId = uuidv4();
-// Create ephemeral key claim instance based on the ephemeral key
-const ephClaim = new EphKeyClaim(
-  ephId,
-  ephPK,
-  algSign,
-  // Lifetime of one hour
-  60 * 60,
-);
+[Example usage](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/e2e-tests/client/src/actions/noAuth/signgen.ts#L58-L74)
 
-// Create EOA authenticator, signature will include epk
-const eoaAuth = new EOAAuth(
-  accountsFromBrowserWallet[0],
-  new BrowserWallet(),
-  ephClaim
-);
+```typescript
+  let sample_message = ...;
 
-// Create a client that connects to the backend service
-const wpClient = await createWalletProviderService(clusterConfig);
+  const response = await sdk.signMessage(
+    config.threshold,
+    config.keyId,
+    config.signAlg,
+    sample_message,
+  );
+```
+
+## Network with Authentication
+### Initialize the Client object
+Create the [WalletProviderServiceClient](./docs/classes/WalletProviderServiceClient.html), using [ClientConfig](./docs/types/ClientConfig.html). The `wpClient` will connect to the Wallet Provider Backend Service (WPBE).
+
+```typescript
+  const config = {
+    walletProviderUrl: "https://silent-network-auth.sandbox.silencelaboratories.com/wpbe1",
+    apiVersion: 'v1',
+  } as ClientConfig;
+
+ const wpClient = new WalletProviderServiceClient(clientConfig);
+```
+Following snippet will create client to our `wpbe1` on our `silent-network-auth` sandbox, and will use `v1` endpoints.
+
+
+### Keygen
+#### Authenticate with EOA wallet
+The full working example is in the [demo](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/demo/src/routes/%2Bpage.svelte#L295-L316).
+
+Apart from `wpClient` that connects to the Backend part of the SDK, you are going to need **authenticator module**.
+
+We provide EOA authentication via [EOAAuth](./docs/classes/EOAAuth.html) module. Let's create the `NetworkSigner` with associated `EOAAuth` object.
+
+```ts
+  // Authenticate using EOA
+  const eoaAuth = new EOAAuth(accountsFromBrowserWallet[0], new BrowserWallet());
+
+  // Create a new signer instance
+  const sdk = new NetworkSigner(wpClient, eoaAuth);
 
-// Create a new signer instance
-const sdk = new NetworkSigner(wpClient, eoaAuth);
 ```
 
-Now you can generate a key, using the [generateKey](./docs/walletprovider-sdk.networksigner.generatekey.md) method. The method accepts optional permissions. No permissions means _allow all operations_.
+Now you can generate a key, using the [generateKey](./docs/classes/NetworkSigner.html#generatekey) method. The method accepts optional permissions. No permissions means _allow all operations_.
 
 ```ts
 const permissions = {
@@ -117,25 +157,35 @@ const permissions = {
 
 let signAlgs = ['secp256k1', 'ed25519'];
 
-// Generate a new key
-let resp: KeygenResponse[] = await sdk.generateKey(threshold, partiesNumber, signAlgs, JSON.stringify(permissions));
+// Generate new eph key, will be later used in sign requests
+const selectedEphSignAlg = 'secp256k1'; // Signing algorithm of ephemeral key
+const sk = generateEphPrivateKey(selectedEphSignAlg);
+const ephPK = getEphPublicKey(sk, selectedEphSignAlg);
+const ephId = uuidv4();
+
+const ephClaim = new EphKeyClaim(ephId, ephPK, selectedEphSignAlg, expireAt(60 * 60));
+
+// Generate keys for secp256k1, ed25519, and include ephemeral key, permissions in the request
+let resp: KeygenResponse[] = await sdk.generateKey(+threshold, +partiesNumber, signAlgs, ephClaim, permissions);
 ```
 
 Calling this method will cause to the Digital Wallet window to pop up, requesting the User to sign the request.
 
-The returned response [KeygenResponse[]](./docs/walletprovider-sdk.keygenresponse.md) is a list of DKG results, each contains `keyId`, `publicKey` and `signAlg`. The `publicKey` is the public part of the key generated by Silent Network. The `signAlg` is the sign algorithm of the MPC key. Use the `keyId` in subsequent calls to sign.
+The returned response [KeygenResponse](./docs/interfaces/KeygenResponse.html) is a list of DKG results, each contains `keyId`, `publicKey` and `signAlg`. The `publicKey` is the public part of the key generated by Silent Network. The `signAlg` is the sign algorithm of the MPC key. Use the `keyId` in subsequent calls to sign.
 
 The ephemeral `sk` key can be later used in subsequent signgen requests for authenticating.
 
-### Authenticate with Passkey
-First, we need to register user passkey to the network. We provide Passkey register via [PasskeyRegister](./docs/walletprovider-sdk.passkeyregister.md) module.
+#### Authenticate with Passkey
+First, we need to register user passkey to the network.
+
+[Example usage](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/demo/src/routes/+page.svelte#L513)
+
 ```ts
-const wpClient = await createWalletProviderService(clusterConfig);
 const rpConfig: RelyingPartyConfig = {
-  rpId: 'localhost',
-  rpName: 'http://localhost:5173',
+  rpId: clusterConfig.rpConfig.rpId,
+  rpName: clusterConfig.rpConfig.rpName,
 };
-const userId = uuidv4();
+userId = newUser();
 const passkeyUser = {
   id: userId,
   displayName: 'Alice',
@@ -146,68 +196,52 @@ const passkeyAuth = new PasskeyRegister(rpConfig, passkeyUser);
 // Create a new signer instance
 const sdk = new NetworkSigner(wpClient, passkeyAuth);
 
-// Register a new passkey
+// Generate a new key
 let resp: RegisterPasskeyResponse = await sdk.registerPasskey();
 ```
 
-We provide Passkey login authentication via [PasskeyAuth](./docs/walletprovider-sdk.passkeyauth.md) module. Let's create the `NetworkSigner` with associated `PasskeyAuth` object.
+We provide Passkey login authentication via [PasskeyAuth](./docs/classes/PasskeyAuth.html) module. Let's create the `NetworkSigner` with associated `PasskeyAuth` object.
 
+[Example usage](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/demo/src/routes/+page.svelte#L441)
 ```ts
-const algSign = 'secp256k1'; // Signing algorithms of ephemeral key
-// Generate ephemeral secret key esk
-const sk = generateEphPrivateKey(algSign);
-// Derive public part epk from esk
-const ephPK = getEphPublicKey(sk, algSign);
-// Arbitrary ID to identify the ephemeral key
-const ephId = uuidv4();
-// Create ephemeral key claim instance based on the ephemeral key
-const ephClaim = new EphKeyClaim(
-  ephId,
-  ephPK,
-  // Lifetime of one hour
-  60 * 60,
-);
-// Create a client that connects to the backend service
-const wpClient = await createWalletProviderService(clusterConfig);
-// Here we configure the relying party for local development
-const rpConfig: RelyingPartyConfig = {
-  rpId: 'localhost',
-  rpName: 'http://localhost:5173',
-};
-
-// Get passkey credential id from your storage
 const credentialId = getPasskeyCredentialId();
-// Create Passkey authenticator, signature will include epk
+if (!credentialId) {
+  throw new Error('Must register passkey first');
+}
 const passkeyAuth = new PasskeyAuth(
   rpConfig,
-  // We will do passkey auth/login with the provided credentialId
   credentialId,
-  ephClaim,
 );
 
 // Create a new signer instance
 const sdk = new NetworkSigner(wpClient, passkeyAuth);
+
+// Generate a new key
+const sk = generateEphPrivateKey(selectedEphSignAlg);
+const ephPK = getEphPublicKey(sk, selectedEphSignAlg);
+const ephId = uuidv4();
+
+const ephClaim = new EphKeyClaim(ephId, ephPK, selectedEphSignAlg, expireAt(60 * 60));
+let resp: KeygenResponse[] = await sdk.generateKey(+threshold, +partiesNumber, signAlgs, ephClaim, permissions);
 ```
 
-Now you can generate a key like in the EOA example by calling the [generateKey](./docs/walletprovider-sdk.networksigner.generatekey.md) method. 
+Now you can generate a key like in the EOA example by calling the [generateKey](./docs/classes/NetworkSigner.html#generatekey) method.
 
-Calling this method will prompt the device to request [Passkey User Verification](https://web.dev/articles/webauthn-user-verification). Once user verification is done, the [KeygenResponse](./docs/walletprovider-sdk.keygenresponse.md) is returned.
+Calling this method will prompt the device to request [Passkey User Verification](https://web.dev/articles/webauthn-user-verification). Once user verification is done, the [KeygenResponse](./docs/interfaces/KeygenResponse.html) is returned.
 
 The `sk` key can be later used in subsequent signgen requests.
 
-## Signing
+### Signing
+The full signing example is [here](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/demo/src/routes/+page.svelte#L374).
 
-The full signing example is [here](https://github.com/silence-laboratories/walletprovider-sdk/blob/main/demo/src/routes/%2Bpage.svelte).
-
-The workflow is similar to the keygen process. The core objects to use are the [NetworkSigner](./docs/walletprovider-sdk.networksigner.md), WalletProviderServiceClient, and the [ephemeral authenticator module](./docs/walletprovider-sdk.ephauth.md).
+The workflow is similar to the keygen process. The core objects to use are the [NetworkSigner](./docs/classes/NetworkSigner.html), [WalletProviderServiceClient](./docs/classes/WalletProviderServiceClient.html), and the [ephemeral authenticator module](./docs/classes/EphAuth.html).
 ```ts
 const authModule = new EphAuth(selectedEphId, ephSK, selectedEphSignAlg);
 // Create a new signer instance
 const sdk = new NetworkSigner(wpClient, authModule);
 ```
 
-
-Use the [SignRequestBuilder](./docs/walletprovider-sdk.signrequestbuilder.md) builder to generate the sign message payload. Then call the [signMessage](./docs/walletprovider-sdk.networksigner.signmessage.md) method to run the signing process.
+Use the [SignRequestBuilder](./docs/classes/SignRequestBuilder.html) builder to generate the sign message payload. Then call the [signMessage](./docs/classes/NetworkSigner.html#signmessage) method to run the signing process.
 
 ```ts
 const signMessage = new SignRequestBuilder()
@@ -242,53 +276,34 @@ const signMessage = new SignRequestBuilder()
 let resp = await sdk.signMessage( threshold, selectedKeyId, signMessage);
 ```
 
-The [SignResponse](./docs/walletprovider-sdk.signresponse.md) contains the signature `sign`, the recovery ID `recid` and the transaction ID `transactionId`.
-
-## Key refresh
+The [SignResponse](./docs/interfaces/SignResponse.html) contains the signature `sign`, the recovery ID `recid` and the transaction ID `transactionId`.
 
-The full key refresh example is [here](https://github.com/silence-laboratories/walletprovider-sdk/blob/main/demo/src/routes/%2Bpage.svelte).
+### Key refresh
 
-The workflow is similar to the keygen process. The core objects to use are the [NetworkSigner](./docs/walletprovider-sdk.networksigner.md), WalletProviderServiceClient, and the [EOAAuth](./docs/walletprovider-sdk.eoaauth.md) module.
+The full key refresh example is [here](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/demo/src/routes/+page.svelte#L351).
 
+The workflow is similar to the keygen process.
 
 ```ts
 const algSign = 'secp256k1'; // Signing algorithms of ephemeral key
-// Generate ephemeral secret key esk
-const sk = generateEphPrivateKey(algSign);
-// Derive public part epk from esk
-const ephPK = getEphPublicKey(sk, algSign);
-// Arbitrary ID to identify the ephemeral key
-const ephId = uuidv4();
-// Create ephemeral key claim instance based on the ephemeral key
-const ephClaim = new EphKeyClaim(
-  ephId,
-  ephPK,
-  algSign,
-  // Lifetime of one hour
-  60 * 60,
-);
 
-// Create EOA authenticator, signature will include epk
+// Create EOA authenticator
 const eoaAuth = new EOAAuth(
   accountsFromBrowserWallet[0],
   new BrowserWallet(),
-  ephClaim
 );
 
-// Create a client that connects to the backend service
-const wpClient = await createWalletProviderService(clusterConfig);
-
 // Create a new signer instance
 const sdk = new NetworkSigner(wpClient, eoaAuth);
 ```
 
-Now you can refresh the key (before doing this, make sure you've already generated the key), using the [refreshKey](./docs/walletprovider-sdk.networksigner.refreshkey.md) method.
+Now you can refresh the key (before doing this, make sure you've already generated the key), using the [refreshKey](./docs/classes/NetworkSigner.html#refreshkey) method.
 
 ```ts
 // Refresh the key
-let resp: KeyRefreshResponse = await sdk.refreshKey(threshold, keyId, mpcKeySignAlg);
+let resp: KeyRefreshResponse = await sdk.refreshKey(+threshold, selectedKeyId, mpcKeySignAlg);
 ```
-The returned response [KeyRefreshResponse](./docs/walletprovider-sdk.keyrefreshresponse.md) contains `keyId`, `publicKey` and `signAlg` of the refreshed MPC key.
+The returned response [KeyRefreshResponse](./docs/types/KeyRefreshResponse.html) contains `keyId`, `publicKey` and `signAlg` of the refreshed MPC key.
 
 
 # Development

package/dist/auth/authentication.d.ts

@@ -1,5 +1,5 @@
-import { AddEphKeyRequest, RegisterPasskeyRequest } from './../client/networkRequest';
-import { KeygenSetupOpts } from '../setupMessage';
+import { AddEphKeyRequest, KeyRefreshRequest, RegisterPasskeyRequest } from './../client/networkRequest';
+import { KeygenSetupOpts, SignSetupOpts, FinishPresignOpts } from '../setupMessage';
 import { EoaAuthPayload, IBrowserWallet } from './EOAauthentication';
 import { PasskeyUser, RelyingPartyConfig } from './passkeyAuthentication';
 import { EphemeralAuthPayload, EphKeySignAlgorithm } from './ephemeralAuthentication';
@@ -28,7 +28,7 @@ export interface AuthModule {
     }): Promise<UserAuthentication>;
 }
 export type AuthPayload = EoaAuthPayload | PasskeyLoginPayload | EphemeralAuthPayload | RegisterPasskeyRequest;
-type PasskeyLoginPayload = KeygenSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest;
+type PasskeyLoginPayload = KeygenSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | SignSetupOpts | FinishPresignOpts | KeyRefreshRequest;
 /** The `EOAAuth` implementing Externally Owned Account authentication.
  * @public
  */

package/dist/auth/passkeyAuthentication.d.ts

@@ -21,6 +21,6 @@ export declare function passkeyRegister({ user, challenge, rpConfig, }: {
 }): Promise<UserAuthentication>;
 export declare function passkeyLogin({ challenge, allowCredentialId, rpConfig, }: {
     challenge: string;
-    allowCredentialId: string | null;
+    allowCredentialId: string;
     rpConfig: RelyingPartyConfig;
 }): Promise<UserAuthentication>;

package/dist/builder/userAuth.d.ts

@@ -1,7 +1,7 @@
 import { AuthModule, UserAuthentication } from '../auth/authentication';
 import { ApiVersion, RequestPayloadV1, RequestPayloadV2, Slug } from '../client/walletProviderServiceClientInterface';
 import { FinishPresignOpts, KeygenSetupOpts, SignSetupOpts } from '../setupMessage';
-import { AddEphKeyRequest, KeyRefreshRequest, QuorumChangeRequest, RegisterPasskeyRequest, RevokeEphKeyRequest } from '../client/networkRequest';
+import { AddEphKeyRequest, KeyRefreshRequest, RegisterPasskeyRequest, RevokeEphKeyRequest } from '../client/networkRequest';
 /**
  * Builder class for constructing user signatures in all kind of client requests to the network.
  * It uses the API of `AuthModule` concrete types together with the `challenge` to generate the user signatures.
@@ -23,7 +23,6 @@ export declare class UserSignatures {
     setRevokeEphKeyUserSigs(payload: RevokeEphKeyRequest, challenge?: string): Promise<void>;
     setRegisterPasskeyUserSigs(payload: RegisterPasskeyRequest, challenge?: string): Promise<void>;
     setKeyRefreshUserSigs(payload: KeyRefreshRequest, challenge?: string): Promise<void>;
-    setQcUserSigs(payload: QuorumChangeRequest, challenge?: string): Promise<void>;
     setFinishPresignUserSigs(payload: FinishPresignOpts, challenge?: string): Promise<void>;
     build(slug: Slug, payload: RequestPayloadV1 | RequestPayloadV2, challenge?: string): Promise<Record<string, UserAuthentication>>;
 }

package/dist/client/networkRequest.d.ts

@@ -34,32 +34,6 @@ export declare class RegisterPasskeyRequest {
     readonly options: string;
     constructor(options: string);
 }
-export declare class QuorumChangeRequest implements EoaAuthPayload {
-    /** Threshold that will be changed */
-    readonly new_t: number;
-    /** Number of nodes that will be changed */
-    readonly new_n: number;
-    /** QC key ID */
-    readonly key_id: string;
-    /** QC key signature algorithm */
-    readonly sign_alg: string;
-    constructor({ newT, newN, keyId, signAlg }: {
-        newT: number;
-        newN: number;
-        keyId: string;
-        signAlg: string;
-    });
-    get eoaRequestSchema(): {
-        Request: {
-            name: string;
-            type: string;
-        }[];
-        QuorumChangeRequest: {
-            name: string;
-            type: string;
-        }[];
-    };
-}
 export declare class KeyRefreshRequest implements EoaAuthPayload {
     /** Threshold of refresh key */
     readonly t: number;

package/dist/client/networkResponse.d.ts

@@ -8,13 +8,14 @@ export interface KeygenResponse {
      */
     keyId: string;
     /**
-     * Public key encoded with SEC1 format.
      *
-     * If point is uncompressed it's in a form of 0x04 || X || Y
+     * For ECDSA: Public key encoded with SEC1 format.
      *
+     * If point is uncompressed it's in a form of 0x04 || X || Y
      * If point is compressed it's in a form Y || X,
-     *
      * where Y is set to 0x02 if Y-coord is even, or 0x03 if Y-coord is odd
+     *
+     * For EdDSA: RFC 8032 32-byte compressed Edwards.
      */
     publicKey: string;
     /**
@@ -34,11 +35,13 @@ export type KeyRefreshResponse = KeygenResponse;
 export interface SignResponse {
     transactionId: string;
     /**
-     * Hexstring of length 128 bytes, in a form: r || s
+     * For ECDSA: Hexstring of length 128 bytes, in a form: r || s. The r and s are 64 bytes long.
+     * For EdDSA: RFC 8032 64-byte signature.
      */
     sign: string;
     /**
-     * Recovery id, either 0, or 1
+     * For ECDSA: Recovery id, either 0, or 1
+     * For EdDSA: unused
      */
     recid: number;
 }
@@ -77,42 +80,3 @@ export interface RegisterPasskeyResponse {
      */
     passkeyCredentialId: string;
 }
-/**
- * Response from the network for quorum change request.
- * @public
- */
-export interface QuorumChangeResponse extends KeygenResponse {
-    /**
-     * Number of nodes of the previous version of the refreshed key.
-     */
-    oldN: number;
-}
-/**
- *
- * @param keysharePlaintext Public data of keyshare in plaintext format
- * @returns Keygen responses {@link KeygenResponse}
- */
-export declare const parseKeysharePublicData: (keysharePlaintext: string) => KeygenResponse;
-/**
- *
- * @param keygenResult MPC keygen result in plaintext format
- * @param totalKey Amount of keys to generate
- * @returns List of keygen responses {@link KeygenResponse}
- * @public
- */
-export declare const parseKeygenResult: (keygenResult: string, totalKey: number) => KeygenResponse[];
-/**
- *
- * @param signResult MPC sign result in plaintext format
- * @param signAlg MPC sign algorithm
- * @returns List of signgen responses {@link SignResponse}
- * @public
- */
-export declare const parseSigngenResult: (signResult: string, signAlg: string) => SignResponse[];
-/**
- *
- * @param keygenResult MPC keygen result in plaintext format
- * @returns List of keygen responses {@link KeygenResponse}
- * @public
- */
-export declare const parseEphKeyOperationResult: (operationsResult: string) => AddEphKeyResponse[];

package/dist/client/walletProviderServiceClientInterface.d.ts

@@ -1,7 +1,7 @@
 import { AuthModule, UserAuthentication } from '../auth/authentication';
 import { KeygenResponse, SignResponse, AddEphKeyResponse, RegisterPasskeyResponse, RevokeEphKeyResponse, KeyRefreshResponse } from './networkResponse';
 import { KeygenSetupOpts, SignSetupOpts, InitPresignOpts, FinishPresignOpts } from '../setupMessage';
-import { AddEphKeyRequest, KeyRefreshRequest, QuorumChangeRequest, RegisterPasskeyRequest, RevokeEphKeyRequest } from './networkRequest';
+import { AddEphKeyRequest, KeyRefreshRequest, RegisterPasskeyRequest, RevokeEphKeyRequest } from './networkRequest';
 /**
  * The config used to create Wallet Provider Service backend client.
  * Please refer to {@link https://shipyard.rs/silencelaboratories/crates/wallet-provider-service | example backend service}
@@ -56,7 +56,7 @@ export interface IWalletProviderServiceClient {
     }): Promise<RegisterPasskeyResponse>;
 }
 export type Slug = 'signgen' | 'keygen' | 'keyRefresh' | 'quorumChange' | 'addEphemeralKey' | 'revokeEphemeralKey' | 'registerPasskey' | 'initPresign' | 'finishPresign';
-export type RequestPayloadV1 = KeygenSetupOpts[] | KeyRefreshRequest | QuorumChangeRequest | SignSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | RegisterPasskeyRequest | FinishPresignOpts;
+export type RequestPayloadV1 = KeygenSetupOpts[] | KeyRefreshRequest | SignSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | RegisterPasskeyRequest | FinishPresignOpts;
 export type RequestPayloadV2 = KeygenSetupOpts[] | SignSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | InitPresignOpts | FinishPresignOpts;
 export interface WpRequest {
     payload: RequestPayloadV1 | RequestPayloadV2;