@silencelaboratories/walletprovider-sdk 1.7.0 → 4.0.0-hackaton

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/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/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/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;
+        }[];
+    };
+}

package/dist/client/networkResponse.d.ts

@@ -45,30 +45,27 @@ export interface SignResponse {
      */
     recid: number;
 }
+interface SimpleResponse {
+    /**
+     * Status of the request.
+     */
+    status: string;
+}
 /**
  * Response from the SDK for adding ephemeral key request. Receive plaintext response from network.
  * @public
  */
-export interface AddEphKeyResponse {
+export interface AddEphKeyResponse extends SimpleResponse {
     /**
      * Unique ID of produced key used in subsequent API calls.
      */
     keyId: string;
-    /**
-     * Status of the request.
-     */
-    status: string;
 }
 /**
  * Response from the network for revoking ephemeral key request.
  * @public
  */
-export interface RevokeEphKeyResponse {
-    /**
-     * Status of the request.
-     */
-    status: string;
-}
+export type RevokeEphKeyResponse = SimpleResponse;
 /**
  * Response from the network for registering passkey request.
  * @public
@@ -80,3 +77,14 @@ export interface RegisterPasskeyResponse {
      */
     passkeyCredentialId: string;
 }
+/**
+ * Response from the network for updating passkey policy request.
+ * @public
+ */
+export type UpdatePolicyResponse = SimpleResponse;
+/**
+ * Response from the network for deleting passkey policy request.
+ * @public
+ */
+export type DeletePolicyResponse = SimpleResponse;
+export {};

package/dist/client/networkSigner.d.ts

@@ -1,7 +1,8 @@
 import { AuthModule } from '../auth/authentication';
 import { INoAuthWpServiceClient, type IWalletProviderServiceClient } from './walletProviderServiceClientInterface';
-import { KeygenResponse, AddEphKeyResponse, RegisterPasskeyResponse, SignResponse, RevokeEphKeyResponse, KeyRefreshResponse } from './networkResponse';
+import { KeygenResponse, AddEphKeyResponse, RegisterPasskeyResponse, SignResponse, RevokeEphKeyResponse, KeyRefreshResponse, UpdatePolicyResponse, DeletePolicyResponse } from './networkResponse';
 import { EphKeyClaim } from '../auth/ephemeralAuthentication';
+import { Policy } from '../policy';
 /**
  * Supported signature algorithms for MPC signing.
  * @public
@@ -32,12 +33,12 @@ export declare class NetworkSigner {
      * @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.
+     * @param policy - optional policy that will be stored in the key metadata.
+     * The policy 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[], ephClaim?: EphKeyClaim, permissions?: string): Promise<KeygenResponse[]>;
+    generateKey(threshold: number, totalNodes: number, signAlgs: string[], ephClaim?: EphKeyClaim, policy?: Policy): 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.
@@ -81,4 +82,19 @@ export declare class NetworkSigner {
      * @public
      */
     registerPasskey(options?: string): Promise<RegisterPasskeyResponse>;
+    /** Update user's key policy on the network. This will try to update to all the available nodes on the network.
+     * Uses `authModule` to authenticate the request by the User.
+     * @param keyId - the key id returned from `keygen`
+     * @param policy - the key policy to be updated
+     * @returns {@link UpdatePolicyResponse}
+     * @public
+     */
+    updatePolicy(keyId: string, policy: Policy): Promise<UpdatePolicyResponse>;
+    /** Delete user's key policy on the network. This will try to delete to all the available nodes on the network.
+     * Uses `authModule` to authenticate the request by the User.
+     * @param keyId - the key id returned from `keygen`
+     * @returns {@link DeletePolicyResponse}
+     * @public
+     */
+    deletePolicy(keyId: string): Promise<DeletePolicyResponse>;
 }

package/dist/client/walletProviderServiceClient.d.ts

@@ -1,8 +1,8 @@
 import { AuthModule } from '../auth/authentication';
-import { type KeygenResponse, type SignResponse, type AddEphKeyResponse, type RegisterPasskeyResponse, RevokeEphKeyResponse, KeyRefreshResponse } from './networkResponse';
+import { type KeygenResponse, type SignResponse, type AddEphKeyResponse, type RegisterPasskeyResponse, RevokeEphKeyResponse, KeyRefreshResponse, UpdatePolicyResponse, DeletePolicyResponse } from './networkResponse';
 import { KeygenSetupOpts, SignSetupOpts } from '../setupMessage';
 import { ApiVersion, type ClientConfig, IWalletProviderServiceClient, Slug, RequestPayloadV1, RequestPayloadV2, INoAuthWpServiceClient, NoAuthSlug, NoAuthRequestPayload } from './walletProviderServiceClientInterface';
-import { AddEphKeyRequest, KeyRefreshRequest, RegisterPasskeyRequest, RevokeEphKeyRequest } from './networkRequest';
+import { AddEphKeyRequest, DeletePolicyRequest, KeyRefreshRequest, RegisterPasskeyRequest, RevokeEphKeyRequest, UpdatePolicyRequest } from './networkRequest';
 declare enum ProtocolState {
     initiated = 0,
     waitingForSign = 1,
@@ -47,6 +47,14 @@ export declare class WalletProviderServiceClient implements IWalletProviderServi
         payload: RegisterPasskeyRequest;
         authModule: AuthModule;
     }): Promise<RegisterPasskeyResponse>;
+    updatePolicy({ payload, authModule, }: {
+        payload: UpdatePolicyRequest;
+        authModule: AuthModule;
+    }): Promise<UpdatePolicyResponse>;
+    deletePolicy({ payload, authModule, }: {
+        payload: DeletePolicyRequest;
+        authModule: AuthModule;
+    }): Promise<DeletePolicyResponse>;
     connect(slug: Slug, payload: RequestPayloadV1, authModule: AuthModule): Promise<string>;
     connectV2(slug: Slug, payload: RequestPayloadV2, authModule: AuthModule): Promise<string>;
     /**
@@ -85,6 +93,12 @@ export declare class NoAuthWalletProviderServiceClient implements INoAuthWpServi
     startKeyRefresh({ payload }: {
         payload: KeyRefreshRequest;
     }): Promise<KeyRefreshResponse>;
+    updatePolicy({ payload }: {
+        payload: UpdatePolicyRequest;
+    }): Promise<UpdatePolicyResponse>;
+    deletePolicy({ payload }: {
+        payload: DeletePolicyRequest;
+    }): Promise<DeletePolicyResponse>;
     connect(slug: NoAuthSlug, payload: NoAuthRequestPayload): Promise<string>;
 }
 export {};

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 { KeygenResponse, SignResponse, AddEphKeyResponse, RegisterPasskeyResponse, RevokeEphKeyResponse, KeyRefreshResponse, UpdatePolicyResponse, DeletePolicyResponse } from './networkResponse';
 import { KeygenSetupOpts, SignSetupOpts, InitPresignOpts, FinishPresignOpts } from '../setupMessage';
-import { AddEphKeyRequest, KeyRefreshRequest, RegisterPasskeyRequest, RevokeEphKeyRequest } from './networkRequest';
+import { AddEphKeyRequest, DeletePolicyRequest, KeyRefreshRequest, RegisterPasskeyRequest, RevokeEphKeyRequest, UpdatePolicyRequest } 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}
@@ -54,10 +54,18 @@ export interface IWalletProviderServiceClient {
         payload: RegisterPasskeyRequest;
         authModule: AuthModule;
     }): Promise<RegisterPasskeyResponse>;
+    updatePolicy({ payload, authModule, }: {
+        payload: UpdatePolicyRequest;
+        authModule: AuthModule;
+    }): Promise<UpdatePolicyResponse>;
+    deletePolicy({ payload, authModule, }: {
+        payload: DeletePolicyRequest;
+        authModule: AuthModule;
+    }): Promise<DeletePolicyResponse>;
 }
-export type Slug = 'signgen' | 'keygen' | 'keyRefresh' | 'quorumChange' | 'addEphemeralKey' | 'revokeEphemeralKey' | 'registerPasskey' | 'initPresign' | 'finishPresign';
-export type RequestPayloadV1 = KeygenSetupOpts[] | KeyRefreshRequest | SignSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | RegisterPasskeyRequest | FinishPresignOpts;
-export type RequestPayloadV2 = KeygenSetupOpts[] | SignSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | InitPresignOpts | FinishPresignOpts;
+export type Slug = 'signgen' | 'keygen' | 'keyRefresh' | 'quorumChange' | 'addEphemeralKey' | 'revokeEphemeralKey' | 'registerPasskey' | 'initPresign' | 'finishPresign' | 'updatePolicy' | 'deletePolicy';
+export type RequestPayloadV1 = KeygenSetupOpts[] | KeyRefreshRequest | SignSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | RegisterPasskeyRequest | UpdatePolicyRequest | DeletePolicyRequest | FinishPresignOpts;
+export type RequestPayloadV2 = KeygenSetupOpts[] | SignSetupOpts | AddEphKeyRequest | RevokeEphKeyRequest | InitPresignOpts | FinishPresignOpts | UpdatePolicyRequest | DeletePolicyRequest;
 export interface WpRequest {
     payload: RequestPayloadV1 | RequestPayloadV2;
     userSigs: Record<string, UserAuthentication> | undefined;
@@ -76,6 +84,12 @@ export interface INoAuthWpServiceClient {
     startKeyRefresh({ payload }: {
         payload: KeyRefreshRequest;
     }): Promise<KeyRefreshResponse>;
+    updatePolicy({ payload }: {
+        payload: UpdatePolicyRequest;
+    }): Promise<UpdatePolicyResponse>;
+    deletePolicy({ payload }: {
+        payload: DeletePolicyRequest;
+    }): Promise<DeletePolicyResponse>;
 }
-export type NoAuthSlug = 'signgen' | 'keygen' | 'keyRefresh';
-export type NoAuthRequestPayload = KeygenSetupOpts[] | SignSetupOpts | InitPresignOpts | FinishPresignOpts | KeyRefreshRequest;
+export type NoAuthSlug = 'signgen' | 'keygen' | 'keyRefresh' | 'updatePolicy' | 'deletePolicy';
+export type NoAuthRequestPayload = KeygenSetupOpts[] | SignSetupOpts | InitPresignOpts | FinishPresignOpts | KeyRefreshRequest | UpdatePolicyRequest | DeletePolicyRequest;