@silencelaboratories/walletprovider-sdk 1.4.0 → 1.6.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,106 @@ 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.
+
+For more information, please read [Types of architectures](https://docs.silent.sg/silent-network/architecture) in our high-level documentation.
+
+> This SDK supports both versions of Silent Network, *no-authentication*, and where User authentication is required.
 
-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.
 
-## Authentication
 
-Users authenticate to Silent Network using 2 methods [Wallet-based](./docs/walletprovider-sdk.eoaauth.md) or [Passkey](./docs/walletprovider-sdk.passkeyauth.md).
+The core object to use is the [NetworkSigner](./docs/classes/NetworkSigner.html). It allows to send requests to the Silent Network.
 
-- [Wallet-based](./docs/walletprovider-sdk.eoaauth.md) authenticate users using their digital wallet, it runs at the same time users start doing **keygen**.
+## Network Without Authentication
+The request goes to the backend, without any sort of User authentication.
 
-- [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.
+Use the [NoAuthWalletProviderServiceClient](./docs/classes/NoAuthWalletProviderServiceClient.html) with the `Network Signer`.
+### Keygen
+During keygen provide number of parties `n`, the threshold `t` and [types of the keys](./docs/types/MPCSignAlgorithm.html) you want to generate.
 
+[Example usage](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/e2e-tests/client/src/actions/noAuth/keygen.ts#L35-L37)
 
-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.
+```typescript
+ const wpClient = new NoAuthWalletProviderServiceClient(selectedWpProvider);
 
-- 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`
+ const sdk = new NetworkSigner(wpClient);
 
-## Keygen
+ const response = await sdk.generateKey(
+    config.threshold,
+    config.parties,
+    keySignAlgs,
+  );
+```
+
+### 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).
+
+[Example usage](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/e2e-tests/client/src/actions/noAuth/signgen.ts#L58-L74)
+
+```typescript
+  const wpClient = new NoAuthWalletProviderServiceClient(selectedWpProvider);
 
-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. 
+  const sdk = new NetworkSigner(wpClient);
+
+  let sample_message = ...;
+
+  const response = await sdk.signMessage(
+    config.threshold,
+    config.keyId,
+    config.signAlg,
+    sample_message,
+  );
+```
 
-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**. 
+## Network with Authentication
+### 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).
 
-### 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.
+In order to create your keys, you need two other components. The [WalletProviderServiceClient](./docs/classes/WalletProviderServiceClient.html) that connects to the Backend part of the SDK, and the **authenticator module**.
+
+We provide EOA authentication via [EOAAuth](./docs/classes/EOAAuth.html) module. Let's create the `NetworkSigner` with associated `EOAAuth` object.
 
 ```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 Client to the network
+  const wpClient = createWalletProviderService(clusterConfig);
 
-// Create EOA authenticator, signature will include epk
-const eoaAuth = new EOAAuth(
-  accountsFromBrowserWallet[0],
-  new BrowserWallet(),
-  ephClaim
-);
+  // Authenticate using EOA
+  const eoaAuth = new EOAAuth(accountsFromBrowserWallet[0], new BrowserWallet());
 
-// 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);
+
+
+  // Generate new eph key
+  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));
 
-// 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 +151,28 @@ const permissions = {
 
 let signAlgs = ['secp256k1', 'ed25519'];
 
-// Generate a new key
-let resp: KeygenResponse[] = await sdk.generateKey(threshold, partiesNumber, signAlgs, JSON.stringify(permissions));
+// 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 wpClient = 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 +183,56 @@ 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',
-};
+// Create a new signer instance
+const sdk = new NetworkSigner(wpClient, passkeyAuth);
 
-// 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
-
-The full signing example is [here](https://github.com/silence-laboratories/walletprovider-sdk/blob/main/demo/src/routes/%2Bpage.svelte).
+### Signing
+The full signing example is [here](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/demo/src/routes/+page.svelte#L374).
 
-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, 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,37 +267,21 @@ 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`.
+The [SignResponse](./docs/interfaces/SignResponse.html) contains the signature `sign`, the recovery ID `recid` and the transaction ID `transactionId`.
 
-## Key refresh
+### Key refresh
 
-The full key refresh 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 [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
@@ -282,13 +291,13 @@ const wpClient = await createWalletProviderService(clusterConfig);
 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/EOAauthentication.d.ts

@@ -3,7 +3,6 @@
  */
 import { type UserAuthentication } from './authentication';
 import { type TypedDataDomain } from 'viem';
-import { EphKeyClaim } from './ephemeralAuthentication';
 export type FieldDefinition = {
     name: string;
     type: string;
@@ -51,20 +50,18 @@ export declare const EIP712SilentShardAuthenticationDomain: {
 type RequestToSign<T> = {
     setup: T;
     challenge: string;
-    eph_claim: string;
 };
 export interface EoaAuthPayload {
     get eoaRequestSchema(): any;
 }
-export declare function createTypedRequest(request: EoaAuthPayload, final_challenge: string, eph_claim: string): TypedData<RequestToSign<EoaAuthPayload>>;
+export declare function createTypedRequest(request: EoaAuthPayload, final_challenge: string): TypedData<RequestToSign<EoaAuthPayload>>;
 /** Present the request to the User using wallet UI, and ask for sign.
  * The signature is the authorization for keygen operation
  */
-export declare function authenticateUsingEOA({ setup, eoa, challenge, browserWallet, ephClaim, }: {
+export declare function authenticateUsingEOA({ setup, eoa, challenge, browserWallet, }: {
     setup: EoaAuthPayload;
     eoa: string;
     challenge: string;
     browserWallet: IBrowserWallet;
-    ephClaim: EphKeyClaim | undefined;
 }): Promise<UserAuthentication>;
 export {};

package/dist/auth/authentication.d.ts

@@ -2,14 +2,15 @@ import { AddEphKeyRequest, RegisterPasskeyRequest } from './../client/networkReq
 import { KeygenSetupOpts } from '../setupMessage';
 import { EoaAuthPayload, IBrowserWallet } from './EOAauthentication';
 import { PasskeyUser, RelyingPartyConfig } from './passkeyAuthentication';
-import { EphemeralAuthPayload, EphKeyClaim, EphKeySignAlgorithm } from './ephemeralAuthentication';
+import { EphemeralAuthPayload, EphKeySignAlgorithm } from './ephemeralAuthentication';
 import { RevokeEphKeyRequest } from '../client/networkRequest';
+export type AuthMethod = 'eoa' | 'ephemeral' | 'passkey';
 /** Contains essential information about how to authenticate the user request.
  * @public
  */
 export type UserCredentials = {
     id: string;
-    method: 'eoa' | 'ephemeral' | 'passkey';
+    method: AuthMethod;
     credentials: string;
 };
 /** User signature container.
@@ -36,15 +37,12 @@ export declare class EOAAuth {
     private browserWallet;
     /** the ETH address that is used to do EOA authentication */
     private eoa;
-    /** Ephemeral key claim populated for single or batched keys*/
-    private ephClaim;
     /**
      *
      * @param eoa - Ethereum address
      * @param browserWallet - Interface to the wallet provider, like MetaMask, that is used to sign the requests
-     * @param ephClaimOptions - Either EphKeyClaim or Map of SignatureAlgorithms and their appropriate EphKeyClaims
      */
-    constructor(eoa: string, browserWallet: IBrowserWallet, ephClaim?: EphKeyClaim);
+    constructor(eoa: string, browserWallet: IBrowserWallet);
     private validateInputs;
     /**
      * Prepares a message to present on the Browser Wallet window and requests to sign it.
@@ -95,15 +93,12 @@ export declare class PasskeyAuth {
     private rpConfig;
     /** ID of the acceptable credential by user. App proves that user has passkey credential by passing the value of this field */
     private allowCredentialId;
-    /** Ephemeral key claim populated for non batched requests*/
-    private ephClaim;
     /**
      *
      * @param rpConfig - Passkey relying party configuration. Read more: https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions#rp
      * @param allowCredentialId - ID of the acceptable credential by user. App proves that user has passkey credential by passing the value of this field
-     * @param ephClaimOptions - Either EphKeyClaim or Map of SignatureAlgorithms and their appropriate EphKeyClaims
      */
-    constructor(rpConfig: RelyingPartyConfig, allowCredentialId: string, ephClaim: EphKeyClaim);
+    constructor(rpConfig: RelyingPartyConfig, allowCredentialId: string);
     /**
      * Prepares a message for Passkey login flow and prompts user device's authenticator to sign it.
      * @param payload - request payload to be sent to the backend

package/dist/auth/ephemeralAuthentication.d.ts

@@ -1,12 +1,12 @@
 import { UserAuthentication } from './authentication';
-import { SignSetupOpts } from '../setupMessage';
+import { FinishPresignOpts, SignSetupOpts } from '../setupMessage';
 import { RevokeEphKeyRequest } from '../client/networkRequest';
 /**
  * Supported signature algorithms for ephemeral signing.
  * @public
  */
 export type EphKeySignAlgorithm = 'ed25519' | 'secp256k1';
-export type EphemeralAuthPayload = SignSetupOpts | RevokeEphKeyRequest;
+export type EphemeralAuthPayload = SignSetupOpts | RevokeEphKeyRequest | FinishPresignOpts;
 /** The `EphKeyClaim` object represents the public claim of the ephemeral key.
  * @public
  */

package/dist/auth/passkeyAuthentication.d.ts

@@ -1,5 +1,4 @@
 import { UserAuthentication } from './authentication';
-import { EphKeyClaim } from './ephemeralAuthentication';
 /** Information about the user currently registering. Read more: https://w3c.github.io/webauthn/#dom-publickeycredentialcreationoptions-user
  * @public
  * */
@@ -20,9 +19,8 @@ export declare function passkeyRegister({ user, challenge, rpConfig, }: {
     challenge: string;
     rpConfig: RelyingPartyConfig;
 }): Promise<UserAuthentication>;
-export declare function passkeyLogin({ challenge, allowCredentialId, rpConfig, ephClaim, }: {
+export declare function passkeyLogin({ challenge, allowCredentialId, rpConfig, }: {
     challenge: string;
     allowCredentialId: string | null;
     rpConfig: RelyingPartyConfig;
-    ephClaim: EphKeyClaim;
 }): Promise<UserAuthentication>;

package/dist/builder/userAuth.d.ts

@@ -1,6 +1,6 @@
 import { AuthModule, UserAuthentication } from '../auth/authentication';
 import { ApiVersion, RequestPayloadV1, RequestPayloadV2, Slug } from '../client/walletProviderServiceClientInterface';
-import { KeygenSetupOpts, SignSetupOpts } from '../setupMessage';
+import { FinishPresignOpts, KeygenSetupOpts, SignSetupOpts } from '../setupMessage';
 import { AddEphKeyRequest, KeyRefreshRequest, QuorumChangeRequest, RegisterPasskeyRequest, RevokeEphKeyRequest } from '../client/networkRequest';
 /**
  * Builder class for constructing user signatures in all kind of client requests to the network.
@@ -24,5 +24,6 @@ export declare class UserSignatures {
     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

@@ -1,7 +1,9 @@
 import { EoaAuthPayload } from '../auth/EOAauthentication';
+import { EphKeyClaim } from '../auth/ephemeralAuthentication';
 export declare class RevokeEphKeyRequest implements EoaAuthPayload {
     readonly key_id: string;
-    constructor(keyId: string);
+    readonly eph_claim: string;
+    constructor(keyId: string, eph_claim: EphKeyClaim);
     get eoaRequestSchema(): {
         Request: {
             name: string;
@@ -15,7 +17,8 @@ export declare class RevokeEphKeyRequest implements EoaAuthPayload {
 }
 export declare class AddEphKeyRequest implements EoaAuthPayload {
     readonly key_id_list: string[];
-    constructor(keyIdList: string[]);
+    readonly eph_claim: string;
+    constructor(keyIdList: string[], eph_claim: EphKeyClaim);
     get eoaRequestSchema(): {
         Request: {
             name: string;

package/dist/client/networkSigner.d.ts

@@ -1,6 +1,7 @@
 import { AuthModule } from '../auth/authentication';
-import { type IWalletProviderServiceClient } from './walletProviderServiceClientInterface';
+import { INoAuthWpServiceClient, type IWalletProviderServiceClient } from './walletProviderServiceClientInterface';
 import { KeygenResponse, AddEphKeyResponse, RegisterPasskeyResponse, SignResponse, RevokeEphKeyResponse, KeyRefreshResponse } from './networkResponse';
+import { EphKeyClaim } from '../auth/ephemeralAuthentication';
 /**
  * Supported signature algorithms for MPC signing.
  * @public
@@ -12,15 +13,15 @@ export type MPCSignAlgorithm = 'ed25519' | 'secp256k1';
  */
 export declare class NetworkSigner {
     /** Authentication module, used to get confirmation from the User before request execution */
-    authModule: AuthModule;
+    authModule: AuthModule | undefined;
     /** Wallet Provider backend client */
-    wpClient: IWalletProviderServiceClient;
+    wpClient: IWalletProviderServiceClient | INoAuthWpServiceClient;
     /**
      * Facade class used to execute operations on Silent Network.
      * @param wpClient - Wallet Provider backend client
      * @param authModule - Authentication module, used to get confirmation from the User before request execution
      */
-    constructor(wpClient: IWalletProviderServiceClient, authModule: AuthModule);
+    constructor(wpClient: IWalletProviderServiceClient | INoAuthWpServiceClient, authModule?: AuthModule);
     validateQuorumSetup({ threshold, totalNodes }: {
         threshold?: number;
         totalNodes?: number;
@@ -30,12 +31,13 @@ export declare class NetworkSigner {
      * @param threshold - Number of nodes that needs to participate in protocol in order to generate valid signature. Also known as `t`.
      * @param totalNodes - Number of nodes that participate in keygen operation. Also known as `n`.
      * @param signAlgs - signature algorithms for which MPC keys will be generated.
+     * @param eph_claim - optional eph key added to the generated key
      * @param permissions - optional permissions that will be stored in the key metadata.
      * The permissions are validated during sign requests.
      * @returns {@link KeygenResponse} containing `keyId` and the `pubKey` public part of the key
      * @public
      */
-    generateKey(threshold: number, totalNodes: number, signAlgs: string[], permissions?: string): Promise<KeygenResponse[]>;
+    generateKey(threshold: number, totalNodes: number, signAlgs: string[], ephClaim?: EphKeyClaim, permissions?: string): Promise<KeygenResponse[]>;
     /** Generate a signature by the distributed key of Silent Network.
      * Uses `authModule` to authenticate the sign request by the User.
      * The network chooses `t` nodes to execute the protocol.
@@ -59,17 +61,19 @@ export declare class NetworkSigner {
     /** Add new ephemeral key to an exist distributed key on the network.
      * Uses `authModule` to authenticate the request by the User.
      * @param keyIdList - the list of key id returned from `keygen`
+     * @param eph_claim - the claim to be added
      * @returns {@link AddEphKeyResponse}
      * @public
      */
-    addEphemeralKey(keyIdList: string[]): Promise<AddEphKeyResponse[]>;
+    addEphemeralKey(keyIdList: string[], eph_claim: EphKeyClaim): Promise<AddEphKeyResponse[]>;
     /** Revoke ephemeral key of an exist distributed key on the network.
      * Uses `authModule` to authenticate the request by the User.
      * @param keyId - the key id returned from `keygen`
+     * @param eph_claim - the claim to be revoked
      * @returns {@link RevokeEphKeyResponse}
      * @public
      */
-    revokeEphemeralKey(keyId: string): Promise<RevokeEphKeyResponse>;
+    revokeEphemeralKey(keyId: string, eph_claim: EphKeyClaim): Promise<RevokeEphKeyResponse>;
     /** Register new user's passkey on the network. This will try to register to all the available nodes on the network.
      * Uses `authModule` to authenticate the request by the User.
      * @param options - the options to customize the passkey authentication