@silencelaboratories/walletprovider-sdk 1.7.0 → 4.0.1-hackathon

package/README.md

@@ -137,36 +137,77 @@ We provide EOA authentication via [EOAAuth](./docs/classes/EOAAuth.html) module.
 
 ```
 
-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_.
+Now you can generate a key, using the [generateKey](./docs/classes/NetworkSigner.html#generatekey) method. The method accepts optional Policy. No Policy means _allow all operations_.
 
 ```ts
-const permissions = {
-  permissions: [
-    {
-      type: 'erc20',
-      method: 'approve',
-      to: '0x1234567890123456789012345678901234567890',
-      args: {
-        spender: '0x1234567890123456789012345678901234567890',
-        value: 10000,
-        eq: '<',
-      },
-    },
+const POLICY_ERC20_TRANSFER = new Policy({
+  version: '1.0',
+  description: 'Simple ERC20 transfer policy',
+  rules: [
+    new Rule({
+      description: 'ERC20 transferFrom: sender/recipient match and value < 10000',
+      chain_type: ChainType.Ethereum,
+      conditions: [
+        {
+          logic: Logic.And,
+          abi: {
+            name: 'transfer',
+            type: 'function',
+            inputs: [
+              {
+                name: 'to',
+                type: 'address',
+              },
+              {
+                name: 'amount',
+                type: 'uint256',
+              },
+            ],
+            outputs: [
+              {
+                name: '',
+                type: 'bool',
+              },
+            ],
+          },
+          group: [
+            {
+              transaction_type: TransactionType.Erc20,
+              transaction_attr: TransactionAttribute.Receiver,
+              operator: Operator.Eq,
+              value: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238',
+            },
+            {
+              transaction_type: TransactionType.Erc20,
+              transaction_attr: "to",
+              operator: Operator.Eq,
+              value: '0x1758f42af7026fbbb559dc60ece0de3ef81f665e',
+            },
+            {
+              transaction_type: TransactionType.Erc20,
+              transaction_attr: "amount",
+              operator: Operator.Lt,
+              value: 10000,
+            },
+          ],
+        },
+      ],
+    }),
   ],
-};
+});
 
 let signAlgs = ['secp256k1', 'ed25519'];
 
 // Generate new eph key, will be later used in sign requests
-const selectedEphSignAlg = 'secp256k1'; // Signing algorithm of ephemeral 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));
 
-// Generate keys for secp256k1, ed25519, and include ephemeral key, permissions in the request
-let resp: KeygenResponse[] = await sdk.generateKey(+threshold, +partiesNumber, signAlgs, ephClaim, permissions);
+// Generate keys for secp256k1, ed25519, and include Ephemeral Key, Policy in the request
+let resp: KeygenResponse[] = await sdk.generateKey(+threshold, +partiesNumber, signAlgs, ephClaim, POLICY_ERC20_TRANSFER);
 ```
 
 Calling this method will cause to the Digital Wallet window to pop up, requesting the User to sign the request.
@@ -222,7 +263,7 @@ 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);
+let resp: KeygenResponse[] = await sdk.generateKey(+threshold, +partiesNumber, signAlgs, ephClaim);
 ```
 
 Now you can generate a key like in the EOA example by calling the [generateKey](./docs/classes/NetworkSigner.html#generatekey) method.
@@ -244,27 +285,28 @@ const sdk = new NetworkSigner(wpClient, authModule);
 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 data = encodeFunctionData({
+      abi: ERC_20_ABI,
+      functionName: 'transfer',
+      args: ['0x1758f42af7026fbbb559dc60ece0de3ef81f665e', 1000n],
+});
+
+const eip1559Tx: UnsignedTransactionRequest = {
+      from: ethAddress,
+      to: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238', // USDC Contract
+      value: '0x0',
+      data,
+      chainId: 80002,
+      nonce: 0,
+      gas: '0x18473',
+      maxFeePerGas: '0x18473',
+      maxPriorityFeePerGas: '0x1000',
+};
 const signMessage = new SignRequestBuilder()
     .setRequest(
       uuidv4(),
-      JSON.stringify({
-        userOperation: {
-          sender: '0x8d4cb2540d993fe34c646299f1ab4af3012ff34c',
-          nonce: '0x7',
-          initCode: '0x',
-          callData: '0000...',
-          callGasLimit: '0x18473',
-          verificationGasLimit: '0x18473',
-          preVerificationGas: '66768',
-          maxFeePerGas: '',
-          maxPriorityFeePerGas: '',
-          paymasterAndData: '0x',
-        },
-        entryPointVersion: 'v0.6.0',
-        entryPointAddress: '0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789',
-        chainId: 80002,
-      }),
-      'accountAbstractionTx',
+      JSON.stringify(eip1559Tx),
+      'EIP1559',
     )
     .setRequest(
       uuidv4(),
@@ -273,7 +315,7 @@ const signMessage = new SignRequestBuilder()
     )
     .build();
 
-let resp = await sdk.signMessage( threshold, selectedKeyId, signMessage);
+let resp = await sdk.signMessage(threshold, selectedKeyId, 'secp256k1', signMessage);
 ```
 
 The [SignResponse](./docs/interfaces/SignResponse.html) contains the signature `sign`, the recovery ID `recid` and the transaction ID `transactionId`.
@@ -285,7 +327,7 @@ The full key refresh example is [here](https://github.com/silence-laboratories/w
 The workflow is similar to the keygen process.
 
 ```ts
-const algSign = 'secp256k1'; // Signing algorithms of ephemeral key
+const algSign = 'secp256k1'; // Signing algorithms of Ephemeral Key
 
 // Create EOA authenticator
 const eoaAuth = new EOAAuth(

package/dist/EOAauthentication.d.ts

@@ -0,0 +1,67 @@
+/** Externally Owned Account (EOA) atuhentication. Uses secret key stored on a wallet to sign requests.
+ * The requests are presented to the user in a readable form by using TypedData (EIP712).
+ */
+import { MetadataSetupOpts, KeygenSetupOpts } from './setupMessage';
+import { type UserAuthentication } from './authentication';
+import { type TypedDataDomain } from 'viem';
+import { EphKeyClaim } from './ephemeralAuthentication';
+export type FieldDefinition = {
+    name: string;
+    type: string;
+};
+/** EIP-712 Typed data struct definition.
+ * @alpha
+ * */
+export type TypedData<T> = {
+    /** contains the schema definition of the types that are in `msg` */
+    types: Record<string, Array<FieldDefinition>>;
+    /** is the signature domain separator */
+    domain: TypedDataDomain;
+    /** points to the type from `types`. It's the root object of `message` */
+    primaryType: string;
+    /** the request that User is asked to sign */
+    message: T;
+};
+/**
+ * Interface to implement communication between this library, and a Browser Wallet. In order to
+ * request the signature from the User.
+ * @alpha
+ */
+export interface IBrowserWallet {
+    /** Sign data using the secret key stored on Browser Wallet
+     * It creates a popup window, presenting the human readable form of `request`
+     * @param from - the address used to sign the request
+     * @param request - the request to sign by the User in the form of EIP712 typed data.
+     * @throws Throws an error if User rejected signature
+     * @example The example implementation:
+     * ```ts
+     * async signTypedData<T>(from: string, request: TypedData<T>): Promise<unknown> {
+     *   return await browserWallet.request({
+     *     method: 'eth_signTypedData_v4',
+     *     params: [from, JSON.stringify(request)],
+     *   });
+     * }
+     * ```
+     */
+    signTypedData<T>(from: string, request: TypedData<T>): Promise<unknown>;
+}
+type RequestToSign<T> = {
+    setup: T;
+    challenge: string;
+};
+export declare const EIP712SilentShardAuthenticationDomain: {
+    name: string;
+    version: string;
+};
+export declare function createTypedRequest(setup: KeygenSetupOpts | MetadataSetupOpts, aggregated_challenge: string, ephClaim: EphKeyClaim): TypedData<RequestToSign<KeygenSetupOpts | MetadataSetupOpts>>;
+/** 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, }: {
+    setup: KeygenSetupOpts | MetadataSetupOpts;
+    eoa: string;
+    challenge: string;
+    browserWallet: IBrowserWallet;
+    ephClaim: EphKeyClaim;
+}): Promise<UserAuthentication>;
+export {};

package/dist/auth/EOAauthentication.d.ts

@@ -1,7 +1,7 @@
 /** Externally Owned Account (EOA) atuhentication. Uses secret key stored on a wallet to sign requests.
  * The requests are presented to the user in a readable form by using TypedData (EIP712).
  */
-import { type UserAuthentication } from './authentication';
+import { UserAuthentication } from './authentication';
 import { type TypedDataDomain } from 'viem';
 export type FieldDefinition = {
     name: string;

package/dist/auth/authentication.d.ts

@@ -1,4 +1,4 @@
-import { AddEphKeyRequest, KeyRefreshRequest, RegisterPasskeyRequest } from './../client/networkRequest';
+import { AddEphKeyRequest, DeletePolicyRequest, KeyRefreshRequest, RegisterPasskeyRequest, UpdatePolicyRequest } from './../client/networkRequest';
 import { KeygenSetupOpts, SignSetupOpts, FinishPresignOpts } from '../setupMessage';
 import { EoaAuthPayload, IBrowserWallet } from './EOAauthentication';
 import { PasskeyUser, RelyingPartyConfig } from './passkeyAuthentication';
@@ -11,24 +11,25 @@ export type AuthMethod = 'eoa' | 'ephemeral' | 'passkey';
 export type UserCredentials = {
     id: string;
     method: AuthMethod;
-    credentials: string;
 };
 /** User signature container.
  *  It contains the signature of the request and the user credentials (authentication method, id and additional credential information).
  * @public
  */
-export type UserAuthentication = {
+export declare class UserAuthentication {
     credentials: UserCredentials;
     signature: string;
-};
+    constructor(credentials: UserCredentials, signature: string);
+}
+export interface AuthModuleParams<T extends AuthPayload = AuthPayload> {
+    payload: T;
+    challenge: string;
+}
 export interface AuthModule {
-    authenticate({ payload, challenge }: {
-        payload: AuthPayload;
-        challenge: string;
-    }): Promise<UserAuthentication>;
+    authenticate(params: AuthModuleParams): Promise<UserAuthentication>;
 }
 export type AuthPayload = EoaAuthPayload | PasskeyLoginPayload | EphemeralAuthPayload | RegisterPasskeyRequest;
-type PasskeyLoginPayload = KeygenSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | SignSetupOpts | FinishPresignOpts | KeyRefreshRequest;
+type PasskeyLoginPayload = KeygenSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | UpdatePolicyRequest | DeletePolicyRequest | SignSetupOpts | FinishPresignOpts | KeyRefreshRequest;
 /** The `EOAAuth` implementing Externally Owned Account authentication.
  * @public
  */
@@ -50,10 +51,7 @@ export declare class EOAAuth {
      * @param challenge - the challenge received from the backend in v1 or generated by client in v2
      * @public
      */
-    authenticate({ payload, challenge, }: {
-        payload: EoaAuthPayload;
-        challenge: string;
-    }): Promise<UserAuthentication>;
+    authenticate({ payload, challenge }: AuthModuleParams<EoaAuthPayload>): Promise<UserAuthentication>;
 }
 /** The `EphAuth` module is only used for signing requests to the network.
  * @public
@@ -80,15 +78,12 @@ export declare class EphAuth implements AuthModule {
      *
      * @public
      */
-    authenticate({ payload, challenge, }: {
-        payload: EphemeralAuthPayload;
-        challenge: string;
-    }): Promise<UserAuthentication>;
+    authenticate({ payload, challenge }: AuthModuleParams<EphemeralAuthPayload>): Promise<UserAuthentication>;
 }
 /** The `AuthModule` implementing Passkey authentication.
  * @public
  */
-export declare class PasskeyAuth {
+export declare class PasskeyAuth implements AuthModule {
     /** Replying party object. Read more: https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions#rp */
     private rpConfig;
     /** ID of the acceptable credential by user. App proves that user has passkey credential by passing the value of this field */
@@ -106,10 +101,7 @@ export declare class PasskeyAuth {
      * @public
      */
     authenticate({ payload, // TODO: Passkey login doesnt require payload, we should clean up this
-    challenge, }: {
-        payload: PasskeyLoginPayload;
-        challenge: string;
-    }): Promise<UserAuthentication>;
+    challenge, }: AuthModuleParams<PasskeyLoginPayload>): Promise<UserAuthentication>;
 }
 /** The `AuthModule` implementing Passkey register.
  * @public
@@ -131,9 +123,6 @@ export declare class PasskeyRegister implements AuthModule {
      * @param challenge - the challenge received from the backend in v1 or generated by client in v2
      * @public
      */
-    authenticate({ payload, challenge, }: {
-        payload: RegisterPasskeyRequest;
-        challenge: string;
-    }): Promise<UserAuthentication>;
+    authenticate({ payload, challenge }: AuthModuleParams<RegisterPasskeyRequest>): Promise<UserAuthentication>;
 }
 export {};

package/dist/authentication.d.ts

@@ -0,0 +1,146 @@
+import { MetadataSetupOpts, KeygenSetupOpts, SignSetupOpts } from './setupMessage';
+import { IBrowserWallet } from './EOAauthentication';
+import { PasskeyUser, RelyingPartyConfig } from './passkeyAuthentication';
+import { EphKeyClaim, SignAlgorithm } from './ephemeralAuthentication';
+/** Type of the request authentication
+ * @alpha
+ */
+export type UserCredentials = {
+    id: string;
+    method: 'eoa' | 'ephemeral' | 'passkey';
+    credentials: string;
+};
+export type UserAuthentication = {
+    credentials: UserCredentials;
+    signature: string;
+};
+export interface AuthModule {
+    authenticate({ setup, challenge, signAlg, }: {
+        setup: KeygenSetupOpts | SignSetupOpts | MetadataSetupOpts;
+        challenge: string;
+        signAlg: string;
+    }): Promise<UserAuthentication>;
+}
+export interface DkgAuthModule extends AuthModule {
+    getEphClaims(): EphKeyClaim | Map<string, EphKeyClaim>;
+}
+/** The `EOAAuth` implementing Externally Owned Account authentication.
+ * @alpha
+ */
+export declare class EOAAuth implements DkgAuthModule {
+    /** An interface to the wallet, like MetaMask, that is used to sign the requests */
+    private browserWallet;
+    /** the ETH address that is used to do EOA authentication */
+    private eoa;
+    /** Ephemeral key claim populated for non batched requests*/
+    ephClaim?: EphKeyClaim;
+    /** Ephemeral key claims map contains pairs of
+     * SignatureAlgorithms and their appropriate EphKeyClaims in case of batched requests */
+    ephClaims?: Map<string, EphKeyClaim>;
+    /**
+     *
+     * @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, ephClaimOptions: {
+        ephClaim?: EphKeyClaim;
+        ephClaims?: Map<string, EphKeyClaim>;
+    });
+    private validateInputs;
+    getEphClaims(): EphKeyClaim | Map<string, EphKeyClaim>;
+    /**
+     * Prepares a message to present on the Browser Wallet window and requests to sign it.
+     * @param setup - Keygen setup options
+     * @param challenge - the challenge received from the backend
+     * @param signAlg - signature algorithm of the EphKeyClaim used for authentication
+     * @public
+     */
+    authenticate({ setup, challenge, signAlg, }: {
+        setup: KeygenSetupOpts | MetadataSetupOpts;
+        challenge: string;
+        signAlg: string;
+    }): Promise<UserAuthentication>;
+}
+/** The `EphAuth` module is only used for signing requests to the network.
+ * @alpha
+ * An Ephmeral key used to locally sign the signature requests to network.
+ * This eph key is registered during keygen. The key is used to sign the requests without
+ * asking the user to sign the request each time.
+ * */
+export declare class EphAuth implements AuthModule {
+    /** Secret key of the ephemeral keypair */
+    private ephSK;
+    /** Ephemeral key claim */
+    private ephClaim;
+    /**
+     *
+     * @param ephId - Ephemeral key ID
+     * @param ephSK - Ephemeral secret key
+     * @param signAlg - Signature algorithm
+     */
+    constructor(ephId: string, ephSK: Uint8Array, signAlg: SignAlgorithm);
+    /**
+     * Prepares a message to present on the Browser Wallet window and requests to sign it.
+     * @param setup - Signgen setup options
+     * @param challenge - the challenge received from the backend
+     *
+     * @public
+     */
+    authenticate({ setup, challenge, }: {
+        setup: SignSetupOpts | MetadataSetupOpts;
+        challenge: string;
+        signAlg: string;
+    }): Promise<UserAuthentication>;
+}
+/** The `AuthModule` implementing Passkey authentication.
+ * @alpha
+ */
+export declare class PasskeyAuth implements DkgAuthModule {
+    /** Replying party object. Read more: https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions#rp */
+    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*/
+    ephClaim?: EphKeyClaim;
+    /** Ephemeral key claims map contains pairs of
+     * SignatureAlgorithms and their appropriate EphKeyClaims in case of batched requests */
+    ephClaims?: Map<string, EphKeyClaim>;
+    /**
+     *
+     * @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, ephClaimOptions: {
+        ephClaim?: EphKeyClaim;
+        ephClaims?: Map<string, EphKeyClaim>;
+    });
+    private validateInputs;
+    getEphClaims(): EphKeyClaim | Map<string, EphKeyClaim>;
+    authenticate({ setup, challenge, signAlg, }: {
+        setup: KeygenSetupOpts | MetadataSetupOpts;
+        challenge: string;
+        signAlg: string;
+    }): Promise<UserAuthentication>;
+}
+/** The `AuthModule` implementing Passkey register.
+ * @alpha
+ */
+export declare class PasskeyRegister implements AuthModule {
+    /** Replying party object. Read more: https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions#rp */
+    private rpConfig;
+    /** Passkey user information, only requires while registering. Read more: https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions#user */
+    private user;
+    /**
+     *
+     * @param rpConfig - Passkey relying party configuration. Read more: https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions#rp
+     * @param user - Passkey user information, only requires while registering. Read more: https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions#user
+     */
+    constructor(rpConfig: RelyingPartyConfig, user: PasskeyUser);
+    authenticate({ setup, challenge, }: {
+        setup: MetadataSetupOpts;
+        challenge: string;
+        signAlg: string;
+    }): Promise<UserAuthentication>;
+}

package/dist/builder/signRequest.d.ts

@@ -1,9 +1,9 @@
 /**
  * Type of signing transaction.
- * For `eddsa` it is REQUIRED to encode the message in hex.
+ * For `rawBytes` | `solanaTransaction` it is REQUIRED to encode the message in hex.
  * @public
  */
-export type SignRequestType = 'accountAbstractionTx' | 'EIP712' | 'EIP191' | 'rawBytes' | 'eddsa';
+export type SignRequestType = 'EIP1559' | 'EIP712' | 'EIP191' | 'rawBytes' | 'solanaTransaction';
 /**
  * Builder class for constructing request payload for DSG.
  * The returned value from `build()` is the value of `message` field of SignSetupOpts.

package/dist/builder/userAuth.d.ts

@@ -1,7 +1,10 @@
-import { AuthModule, UserAuthentication } from '../auth/authentication';
+import { AuthModule, AuthModuleParams, UserAuthentication } from '../auth/authentication';
 import { ApiVersion, RequestPayloadV1, RequestPayloadV2, Slug } from '../client/walletProviderServiceClientInterface';
 import { FinishPresignOpts, KeygenSetupOpts, SignSetupOpts } from '../setupMessage';
-import { AddEphKeyRequest, KeyRefreshRequest, RegisterPasskeyRequest, RevokeEphKeyRequest } from '../client/networkRequest';
+import { AddEphKeyRequest, DeletePolicyRequest, KeyRefreshRequest, RegisterPasskeyRequest, RevokeEphKeyRequest, UpdatePolicyRequest } from '../client/networkRequest';
+export type UserSignaturesOptionalParams = {
+    challenge?: string | undefined;
+};
 /**
  * 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.
@@ -18,11 +21,13 @@ export declare class UserSignatures {
     setKeygenUserSigs(payload: KeygenSetupOpts[], challenges?: {
         [key: string]: string;
     }): Promise<void>;
-    setSigngenUserSigs(payload: SignSetupOpts, challenge?: string): Promise<void>;
-    setAddEphKeyUserSigs(payload: AddEphKeyRequest, challenge?: string): Promise<void>;
-    setRevokeEphKeyUserSigs(payload: RevokeEphKeyRequest, challenge?: string): Promise<void>;
-    setRegisterPasskeyUserSigs(payload: RegisterPasskeyRequest, challenge?: string): Promise<void>;
-    setKeyRefreshUserSigs(payload: KeyRefreshRequest, challenge?: string): Promise<void>;
-    setFinishPresignUserSigs(payload: FinishPresignOpts, challenge?: string): Promise<void>;
-    build(slug: Slug, payload: RequestPayloadV1 | RequestPayloadV2, challenge?: string): Promise<Record<string, UserAuthentication>>;
+    setSigngenUserSigs(authParams: AuthModuleParams<SignSetupOpts>): Promise<void>;
+    setAddEphKeyUserSigs(authParams: AuthModuleParams<AddEphKeyRequest>): Promise<void>;
+    setRevokeEphKeyUserSigs(authParams: AuthModuleParams<RevokeEphKeyRequest>): Promise<void>;
+    setRegisterPasskeyUserSigs(authParams: AuthModuleParams<RegisterPasskeyRequest>): Promise<void>;
+    setKeyRefreshUserSigs(authParams: AuthModuleParams<KeyRefreshRequest>): Promise<void>;
+    setFinishPresignUserSigs(authParams: AuthModuleParams<FinishPresignOpts>): Promise<void>;
+    setUpdatePolicyUserSigs(authParams: AuthModuleParams<UpdatePolicyRequest>): Promise<void>;
+    setDeletePolicyUserSigs(authParams: AuthModuleParams<DeletePolicyRequest>): Promise<void>;
+    build(slug: Slug, payload: RequestPayloadV1 | RequestPayloadV2, options?: UserSignaturesOptionalParams): Promise<Record<string, UserAuthentication>>;
 }

package/dist/client/api.d.ts

@@ -0,0 +1,18 @@
+interface RequestOptions extends RequestInit {
+    headers?: Record<string, string>;
+}
+export declare class HttpClient {
+    private readonly baseURL;
+    private defaultHeaders;
+    constructor(baseURL?: string);
+    setDefaultHeaders(headers: Record<string, string>): void;
+    private buildUrl;
+    private handleResponse;
+    private request;
+    get<T>(endpoint: string, options?: RequestOptions): Promise<T>;
+    post<T, D = unknown>(endpoint: string, data: D, options?: RequestOptions): Promise<T>;
+    put<T, D = unknown>(endpoint: string, data: D, options?: RequestOptions): Promise<T>;
+    patch<T, D = unknown>(endpoint: string, data: D, options?: RequestOptions): Promise<T>;
+    delete<T>(endpoint: string, options?: RequestOptions): Promise<T>;
+}
+export {};

package/dist/client/intentServiceClient.d.ts

@@ -0,0 +1,4 @@
+export interface IntentSetupOpts {
+    t: number;
+    message: string;
+}

package/dist/client/keyRefresher.d.ts

@@ -0,0 +1,34 @@
+import { AuthModule } from '../auth/authentication';
+import { type IWalletProviderServiceClient } from './walletProviderServiceClientInterface';
+import { KeyRefreshResponse } from './networkResponse';
+import { MPCSignAlgorithm } from './networkSigner';
+/** The NetworkKeyRefresher contains API to run key refresh towards Silent Network.
+ * the Auth module, that is used to prompt the User before executing the request.
+ * @public
+ */
+export declare class NetworkKeyRefresher {
+    /** Authentication module, used to get confirmation from the User before request execution */
+    authModule: AuthModule;
+    /** Number of nodes that needs to participate in DSG. New `t` of (t;n) setup for this key. */
+    newThreshold: number;
+    /** Number of nodes that participate in key refresh operation. New `n` of (t;n) setup for this key. */
+    newTotalNodes: number;
+    /** Wallet Provider backend client */
+    wpClient: IWalletProviderServiceClient;
+    /**
+     * Facade class used to execute key refresh on Silent Network.
+     * @param wpClient - Wallet Provider backend client
+     * @param newThreshold - Number of nodes that needs to participate in DSG. New `t` of (t;n) setup for this key.
+     * @param newTotalNodes - Number of nodes that participate in key refresh operation. New `n` of (t;n) setup for this key.
+     * @param authModule - Authentication module, used to get confirmation from the User before request execution
+     */
+    constructor(wpClient: IWalletProviderServiceClient, newThreshold: number, newTotalNodes: number, authModule: AuthModule);
+    /** Generate a distributed key that's generated by Silent Network.
+     * Uses `authModule` to authenticate the User with the Silent Network.
+     * @param keyId - the key id returned from `keygen`
+     * @param signAlg - signature algorithm of the refresh key.
+     * @returns {@link KeyRefreshResponse} containing `keyId`, `pubKey`,
+     * @public
+     */
+    refreshKey(keyId: string, signAlg: MPCSignAlgorithm): Promise<KeyRefreshResponse>;
+}

package/dist/client/networkRequest.d.ts

@@ -1,5 +1,6 @@
 import { EoaAuthPayload } from '../auth/EOAauthentication';
 import { EphKeyClaim } from '../auth/ephemeralAuthentication';
+import { Policy } from '../policy';
 export declare class RevokeEphKeyRequest implements EoaAuthPayload {
     readonly key_id: string;
     readonly eph_claim: string;
@@ -57,3 +58,40 @@ export declare class KeyRefreshRequest implements EoaAuthPayload {
         }[];
     };
 }
+export declare class UpdatePolicyRequest implements EoaAuthPayload {
+    /** Policy associated key ID */
+    readonly key_id: string;
+    /** New policy */
+    readonly policy: string;
+    constructor({ keyId, policy }: {
+        keyId: string;
+        policy: Policy;
+    });
+    get eoaRequestSchema(): {
+        Request: {
+            name: string;
+            type: string;
+        }[];
+        UpdatePolicyRequest: {
+            name: string;
+            type: string;
+        }[];
+    };
+}
+export declare class DeletePolicyRequest implements EoaAuthPayload {
+    /** Policy associated key ID */
+    readonly key_id: string;
+    constructor({ keyId }: {
+        keyId: string;
+    });
+    get eoaRequestSchema(): {
+        Request: {
+            name: string;
+            type: string;
+        }[];
+        DeletePolicyRequest: {
+            name: string;
+            type: string;
+        }[];
+    };
+}