@silencelaboratories/walletprovider-sdk 1.6.0 → 4.0.0-hackaton

package/README.md

@@ -55,24 +55,32 @@ For more information, please read [Types of architectures](https://docs.silent.s
 
 > This SDK supports both versions of Silent Network, *no-authentication*, and where User authentication is required.
 
+## Network Without Authentication
+The request goes to the backend, without any sort of User authentication.
 
+### 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).
 
-The core object to use is the [NetworkSigner](./docs/classes/NetworkSigner.html). It allows to send requests to the Silent Network.
+```typescript
+const config = {
+  walletProviderUrl: "https://silent-network-no-auth.sandbox.silencelaboratories.com/wpbe1",
+  apiVersion: 'v2',
+} as ClientConfig;
 
-## Network Without Authentication
-The request goes to the backend, without any sort of User authentication.
+const wpClient = new NoAuthWalletProviderServiceClient(clientConfig);
+const sdk = new NetworkSigner(wpClient);
+```
+
+Following snippet will create client to `wpbe1` on our `silent-network-no-auth` sandbox, and will use `v2` endpoints.
+
+Then pass the `wpClient` to the [NetworkSigner](./docs/classes/NetworkSigner.html). And use `NetworkSigner` for interacting with the WPBE.
 
-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)
+[Example usage](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/e2e-tests/client/src/actions/noAuth/keygen.ts#L75)
 
 ```typescript
- const wpClient = new NoAuthWalletProviderServiceClient(selectedWpProvider);
-
- const sdk = new NetworkSigner(wpClient);
-
  const response = await sdk.generateKey(
     config.threshold,
     config.parties,
@@ -87,10 +95,6 @@ The example usage of different types is [shown here](https://github.com/silence-
 [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);
-
-  const sdk = new NetworkSigner(wpClient);
-
   let sample_message = ...;
 
   const response = await sdk.signMessage(
@@ -102,62 +106,113 @@ The example usage of different types is [shown here](https://github.com/silence-
 ```
 
 ## 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).
 
-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**.
+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
-  // Create Client to the network
-  const wpClient = createWalletProviderService(clusterConfig);
-
   // Authenticate using EOA
   const eoaAuth = new EOAAuth(accountsFromBrowserWallet[0], new BrowserWallet());
 
   // 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));
-
 ```
 
-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 keys for secp256k1, ed25519, and include ephemeral key, permissions in the request
-let resp: KeygenResponse[] = await sdk.generateKey(+threshold, +partiesNumber, signAlgs, ephClaim, 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, 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.
 
-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 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.
 
@@ -167,7 +222,6 @@ 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 = createWalletProviderService(clusterConfig);
 const rpConfig: RelyingPartyConfig = {
   rpId: clusterConfig.rpConfig.rpId,
   rpName: clusterConfig.rpConfig.rpName,
@@ -191,9 +245,6 @@ We provide Passkey login authentication via [PasskeyAuth](./docs/classes/Passkey
 
 [Example usage](https://github.com/silence-laboratories/walletprovider-sdk/blob/564cca4bb59658a6e477a59e8ea554a67c26b161/demo/src/routes/+page.svelte#L441)
 ```ts
-// Create a new signer instance
-const sdk = new NetworkSigner(wpClient, passkeyAuth);
-
 const credentialId = getPasskeyCredentialId();
 if (!credentialId) {
   throw new Error('Must register passkey first');
@@ -212,8 +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.
@@ -225,7 +275,7 @@ 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/564cca4bb59658a6e477a59e8ea554a67c26b161/demo/src/routes/+page.svelte#L374).
 
-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).
+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
@@ -235,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(),
@@ -264,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`.
@@ -276,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(
@@ -284,9 +335,6 @@ const eoaAuth = new EOAAuth(
   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);
 ```

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,5 +1,5 @@
-import { AddEphKeyRequest, RegisterPasskeyRequest } from './../client/networkRequest';
-import { KeygenSetupOpts } from '../setupMessage';
+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';
 import { EphemeralAuthPayload, EphKeySignAlgorithm } from './ephemeralAuthentication';
@@ -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;
+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/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/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, QuorumChangeRequest, 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,12 +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>;
-    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>>;
+    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;
@@ -34,18 +35,15 @@ 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 */
+export declare class KeyRefreshRequest implements EoaAuthPayload {
+    /** Threshold of refresh key */
+    readonly t: number;
+    /** Refresh key ID */
     readonly key_id: string;
-    /** QC key signature algorithm */
+    /** Refresh key signature algorithm */
     readonly sign_alg: string;
-    constructor({ newT, newN, keyId, signAlg }: {
-        newT: number;
-        newN: number;
+    constructor({ t, keyId, signAlg }: {
+        t: number;
         keyId: string;
         signAlg: string;
     });
@@ -54,30 +52,44 @@ export declare class QuorumChangeRequest implements EoaAuthPayload {
             name: string;
             type: string;
         }[];
-        QuorumChangeRequest: {
+        KeyRefreshRequest: {
             name: string;
             type: string;
         }[];
     };
 }
-export declare class KeyRefreshRequest implements EoaAuthPayload {
-    /** Threshold of refresh key */
-    readonly t: number;
-    /** Refresh key ID */
+export declare class UpdatePolicyRequest implements EoaAuthPayload {
+    /** Policy associated key ID */
     readonly key_id: string;
-    /** Refresh key signature algorithm */
-    readonly sign_alg: string;
-    constructor({ t, keyId, signAlg }: {
-        t: number;
+    /** New policy */
+    readonly policy: string;
+    constructor({ keyId, policy }: {
         keyId: string;
-        signAlg: string;
+        policy: Policy;
     });
     get eoaRequestSchema(): {
         Request: {
             name: string;
             type: string;
         }[];
-        KeyRefreshRequest: {
+        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;
         }[];