@privy-io/api-types 0.1.1 → 0.2.0

package/src/resources/wallets/wallets.ts

@@ -113,7 +113,11 @@ export class Wallets extends APIResource {
    * ```ts
    * const response = await client.wallets._rawSign(
    *   'wallet_id',
-   *   { params: {} },
+   *   {
+   *     params: {
+   *       hash: '0x0775aeed9c9ce6e0fbc4db25c5e4e6368029651c905c286f813126a09025a21e',
+   *     },
+   *   },
    * );
    * ```
    */
@@ -148,8 +152,8 @@ export class Wallets extends APIResource {
    * @example
    * ```ts
    * const response = await client.wallets._rpc('wallet_id', {
-   *   method: 'eth_signTransaction',
-   *   params: { transaction: {} },
+   *   method: 'personal_sign',
+   *   params: { encoding: 'utf-8', message: 'message' },
    * });
    * ```
    */
@@ -379,233 +383,595 @@ export interface WalletRevokeResponse {
   message: string;
 }
 
-export interface WalletExportResponse {
-  /**
-   * The encrypted private key.
-   */
-  ciphertext: string;
+/**
+ * Executes the EVM `personal_sign` RPC (EIP-191) to sign a message.
+ */
+export interface EthereumPersonalSignRpcInput {
+  method: 'personal_sign';
 
-  /**
-   * The base64-encoded encapsulated key that was generated during encryption, for
-   * use during decryption.
-   */
-  encapsulated_key: string;
+  params: EthereumPersonalSignRpcInput.Params;
 
-  /**
-   * The encryption type of the wallet to import. Currently only supports `HPKE`.
-   */
-  encryption_type: 'HPKE';
+  address?: string;
+
+  chain_type?: 'ethereum';
 }
 
-export interface WalletInitImportResponse {
-  /**
-   * The base64-encoded encryption public key to encrypt the wallet entropy with.
-   */
-  encryption_public_key: string;
+export namespace EthereumPersonalSignRpcInput {
+  export interface Params {
+    encoding: 'utf-8' | 'hex';
 
-  /**
-   * The encryption type of the wallet to import. Currently only supports `HPKE`.
-   */
-  encryption_type: 'HPKE';
+    message: string;
+  }
 }
 
-export interface WalletRawSignResponse {
-  data: WalletRawSignResponse.Data;
+/**
+ * Executes the EVM `eth_signTransaction` RPC to sign a transaction.
+ */
+export interface EthereumSignTransactionRpcInput {
+  method: 'eth_signTransaction';
+
+  params: EthereumSignTransactionRpcInput.Params;
+
+  address?: string;
+
+  chain_type?: 'ethereum';
 }
 
-export namespace WalletRawSignResponse {
-  export interface Data {
-    encoding: 'hex';
+export namespace EthereumSignTransactionRpcInput {
+  export interface Params {
+    transaction: Params.Transaction;
+  }
 
-    signature: string;
+  export namespace Params {
+    export interface Transaction {
+      chain_id?: string | number;
+
+      data?: string;
+
+      from?: string;
+
+      gas_limit?: string | number;
+
+      gas_price?: string | number;
+
+      max_fee_per_gas?: string | number;
+
+      max_priority_fee_per_gas?: string | number;
+
+      nonce?: string | number;
+
+      to?: string;
+
+      type?: 0 | 1 | 2;
+
+      value?: string | number;
+    }
   }
 }
 
-export type WalletRpcResponse =
-  | WalletRpcResponse.SolanaSignTransactionRpcResponse
-  | WalletRpcResponse.SolanaSignAndSendTransactionRpcResponse
-  | WalletRpcResponse.SolanaSignMessageRpcResponse
-  | WalletRpcResponse.EthereumSignTransactionRpcResponse
-  | WalletRpcResponse.EthereumSendTransactionRpcResponse
-  | WalletRpcResponse.EthereumPersonalSignRpcResponse
-  | WalletRpcResponse.EthereumSignTypedDataRpcResponse
-  | WalletRpcResponse.EthereumSign7702AuthorizationRpcResponse
-  | WalletRpcResponse.EthereumSecp256k1SignRpcResponse;
-
-export namespace WalletRpcResponse {
-  export interface SolanaSignTransactionRpcResponse {
-    data: SolanaSignTransactionRpcResponse.Data;
+/**
+ * Executes the EVM `eth_sendTransaction` RPC to sign and broadcast a transaction.
+ */
+export interface EthereumSendTransactionRpcInput {
+  caip2: string;
 
-    method: 'signTransaction';
+  method: 'eth_sendTransaction';
+
+  params: EthereumSendTransactionRpcInput.Params;
+
+  address?: string;
+
+  chain_type?: 'ethereum';
+
+  sponsor?: boolean;
+}
+
+export namespace EthereumSendTransactionRpcInput {
+  export interface Params {
+    transaction: Params.Transaction;
   }
 
-  export namespace SolanaSignTransactionRpcResponse {
-    export interface Data {
-      encoding: 'base64';
+  export namespace Params {
+    export interface Transaction {
+      chain_id?: string | number;
+
+      data?: string;
+
+      from?: string;
+
+      gas_limit?: string | number;
+
+      gas_price?: string | number;
+
+      max_fee_per_gas?: string | number;
+
+      max_priority_fee_per_gas?: string | number;
+
+      nonce?: string | number;
+
+      to?: string;
+
+      type?: 0 | 1 | 2;
 
-      signed_transaction: string;
+      value?: string | number;
     }
   }
+}
 
-  export interface SolanaSignAndSendTransactionRpcResponse {
-    data: SolanaSignAndSendTransactionRpcResponse.Data;
+/**
+ * Executes the EVM `eth_signTypedData_v4` RPC (EIP-712) to sign a typed data
+ * object.
+ */
+export interface EthereumSignTypedDataRpcInput {
+  method: 'eth_signTypedData_v4';
 
-    method: 'signAndSendTransaction';
+  params: EthereumSignTypedDataRpcInput.Params;
+
+  address?: string;
+
+  chain_type?: 'ethereum';
+}
+
+export namespace EthereumSignTypedDataRpcInput {
+  export interface Params {
+    typed_data: Params.TypedData;
   }
 
-  export namespace SolanaSignAndSendTransactionRpcResponse {
-    export interface Data {
-      caip2: string;
+  export namespace Params {
+    export interface TypedData {
+      domain: { [key: string]: unknown };
 
-      hash: string;
+      message: { [key: string]: unknown };
 
-      transaction_id?: string;
+      primary_type: string;
+
+      types: { [key: string]: Array<TypedData.Type> };
+    }
+
+    export namespace TypedData {
+      export interface Type {
+        name: string;
+
+        type: string;
+      }
     }
   }
+}
 
-  export interface SolanaSignMessageRpcResponse {
-    data: SolanaSignMessageRpcResponse.Data;
+/**
+ * Executes an RPC method to hash and sign a UserOperation.
+ */
+export interface EthereumSignUserOperationRpcInput {
+  method: 'eth_signUserOperation';
 
-    method: 'signMessage';
+  params: EthereumSignUserOperationRpcInput.Params;
+
+  address?: string;
+
+  chain_type?: 'ethereum';
+}
+
+export namespace EthereumSignUserOperationRpcInput {
+  export interface Params {
+    chain_id: string | number;
+
+    contract: string;
+
+    user_operation: Params.UserOperation;
   }
 
-  export namespace SolanaSignMessageRpcResponse {
-    export interface Data {
-      encoding: 'base64';
+  export namespace Params {
+    export interface UserOperation {
+      call_data: string;
+
+      call_gas_limit: string;
+
+      max_fee_per_gas: string;
 
-      signature: string;
+      max_priority_fee_per_gas: string;
+
+      nonce: string;
+
+      paymaster: string;
+
+      paymaster_data: string;
+
+      paymaster_post_op_gas_limit: string;
+
+      paymaster_verification_gas_limit: string;
+
+      pre_verification_gas: string;
+
+      sender: string;
+
+      verification_gas_limit: string;
     }
   }
+}
 
-  export interface EthereumSignTransactionRpcResponse {
-    data: EthereumSignTransactionRpcResponse.Data;
+/**
+ * Signs an EIP-7702 authorization.
+ */
+export interface EthereumSign7702AuthorizationRpcInput {
+  method: 'eth_sign7702Authorization';
 
-    method: 'eth_signTransaction';
+  params: EthereumSign7702AuthorizationRpcInput.Params;
+
+  address?: string;
+
+  chain_type?: 'ethereum';
+}
+
+export namespace EthereumSign7702AuthorizationRpcInput {
+  export interface Params {
+    chain_id: string | number;
+
+    contract: string;
+
+    nonce?: string | number;
   }
+}
 
-  export namespace EthereumSignTransactionRpcResponse {
-    export interface Data {
-      encoding: 'rlp';
+/**
+ * Signs a raw hash on the secp256k1 curve.
+ */
+export interface EthereumSecp256k1SignRpcInput {
+  method: 'secp256k1_sign';
 
-      signed_transaction: string;
-    }
+  params: EthereumSecp256k1SignRpcInput.Params;
+
+  address?: string;
+
+  chain_type?: 'ethereum';
+}
+
+export namespace EthereumSecp256k1SignRpcInput {
+  export interface Params {
+    hash: string;
   }
+}
 
-  export interface EthereumSendTransactionRpcResponse {
-    data: EthereumSendTransactionRpcResponse.Data;
+/**
+ * Executes the SVM `signTransaction` RPC to sign a transaction.
+ */
+export interface SolanaSignTransactionRpcInput {
+  method: 'signTransaction';
 
-    method: 'eth_sendTransaction';
+  params: SolanaSignTransactionRpcInput.Params;
+
+  address?: string;
+
+  chain_type?: 'solana';
+}
+
+export namespace SolanaSignTransactionRpcInput {
+  export interface Params {
+    encoding: 'base64';
+
+    transaction: string;
   }
+}
 
-  export namespace EthereumSendTransactionRpcResponse {
-    export interface Data {
-      caip2: string;
+/**
+ * Executes the SVM `signAndSendTransaction` RPC to sign and broadcast a
+ * transaction.
+ */
+export interface SolanaSignAndSendTransactionRpcInput {
+  caip2: string;
 
-      hash: string;
+  method: 'signAndSendTransaction';
 
-      transaction_id?: string;
+  params: SolanaSignAndSendTransactionRpcInput.Params;
 
-      transaction_request?: Data.TransactionRequest;
-    }
+  address?: string;
 
-    export namespace Data {
-      export interface TransactionRequest {
-        chain_id?: string | number;
+  chain_type?: 'solana';
 
-        data?: string;
+  sponsor?: boolean;
+}
 
-        from?: string;
+export namespace SolanaSignAndSendTransactionRpcInput {
+  export interface Params {
+    encoding: 'base64';
 
-        gas_limit?: string | number;
+    transaction: string;
+  }
+}
 
-        gas_price?: string | number;
+/**
+ * Executes the SVM `signMessage` RPC to sign a message.
+ */
+export interface SolanaSignMessageRpcInput {
+  method: 'signMessage';
 
-        max_fee_per_gas?: string | number;
+  params: SolanaSignMessageRpcInput.Params;
 
-        max_priority_fee_per_gas?: string | number;
+  address?: string;
 
-        nonce?: string | number;
+  chain_type?: 'solana';
+}
 
-        to?: string;
+export namespace SolanaSignMessageRpcInput {
+  export interface Params {
+    encoding: 'base64';
 
-        type?: 0 | 1 | 2;
+    message: string;
+  }
+}
 
-        value?: string | number;
-      }
-    }
+/**
+ * Response to the EVM `eth_signTransaction` RPC.
+ */
+export interface EthereumSignTransactionRpcResponse {
+  data: EthereumSignTransactionRpcResponse.Data;
+
+  method: 'eth_signTransaction';
+}
+
+export namespace EthereumSignTransactionRpcResponse {
+  export interface Data {
+    encoding: 'rlp';
+
+    signed_transaction: string;
   }
+}
 
-  export interface EthereumPersonalSignRpcResponse {
-    data: EthereumPersonalSignRpcResponse.Data;
+/**
+ * Response to the EVM `eth_sendTransaction` RPC.
+ */
+export interface EthereumSendTransactionRpcResponse {
+  data: EthereumSendTransactionRpcResponse.Data;
 
-    method: 'personal_sign';
+  method: 'eth_sendTransaction';
+}
+
+export namespace EthereumSendTransactionRpcResponse {
+  export interface Data {
+    caip2: string;
+
+    hash: string;
+
+    transaction_id?: string;
+
+    transaction_request?: Data.TransactionRequest;
   }
 
-  export namespace EthereumPersonalSignRpcResponse {
-    export interface Data {
-      encoding: 'hex';
+  export namespace Data {
+    export interface TransactionRequest {
+      chain_id?: string | number;
 
-      signature: string;
+      data?: string;
+
+      from?: string;
+
+      gas_limit?: string | number;
+
+      gas_price?: string | number;
+
+      max_fee_per_gas?: string | number;
+
+      max_priority_fee_per_gas?: string | number;
+
+      nonce?: string | number;
+
+      to?: string;
+
+      type?: 0 | 1 | 2;
+
+      value?: string | number;
     }
   }
+}
 
-  export interface EthereumSignTypedDataRpcResponse {
-    data: EthereumSignTypedDataRpcResponse.Data;
+/**
+ * Response to the EVM `personal_sign` RPC.
+ */
+export interface EthereumPersonalSignRpcResponse {
+  data: EthereumPersonalSignRpcResponse.Data;
 
-    method: 'eth_signTypedData_v4';
+  method: 'personal_sign';
+}
+
+export namespace EthereumPersonalSignRpcResponse {
+  export interface Data {
+    encoding: 'hex';
+
+    signature: string;
   }
+}
 
-  export namespace EthereumSignTypedDataRpcResponse {
-    export interface Data {
-      encoding: 'hex';
+/**
+ * Response to the EVM `eth_signTypedData_v4` RPC.
+ */
+export interface EthereumSignTypedDataRpcResponse {
+  data: EthereumSignTypedDataRpcResponse.Data;
 
-      signature: string;
-    }
+  method: 'eth_signTypedData_v4';
+}
+
+export namespace EthereumSignTypedDataRpcResponse {
+  export interface Data {
+    encoding: 'hex';
+
+    signature: string;
   }
+}
 
-  export interface EthereumSign7702AuthorizationRpcResponse {
-    data: EthereumSign7702AuthorizationRpcResponse.Data;
+/**
+ * Response to the EVM `eth_signUserOperation` RPC.
+ */
+export interface EthereumSignUserOperationRpcResponse {
+  data: EthereumSignUserOperationRpcResponse.Data;
 
-    method: 'eth_sign7702Authorization';
+  method: 'eth_signUserOperation';
+}
+
+export namespace EthereumSignUserOperationRpcResponse {
+  export interface Data {
+    encoding: 'hex';
+
+    signature: string;
   }
+}
+
+/**
+ * Response to the EVM `eth_sign7702Authorization` RPC.
+ */
+export interface EthereumSign7702AuthorizationRpcResponse {
+  data: EthereumSign7702AuthorizationRpcResponse.Data;
+
+  method: 'eth_sign7702Authorization';
+}
 
-  export namespace EthereumSign7702AuthorizationRpcResponse {
-    export interface Data {
-      authorization: Data.Authorization;
+export namespace EthereumSign7702AuthorizationRpcResponse {
+  export interface Data {
+    authorization: Data.Authorization;
+  }
+
+  export namespace Data {
+    export interface Authorization {
+      chain_id: string | number;
+
+      contract: string;
+
+      nonce: string | number;
+
+      r: string;
+
+      s: string;
+
+      y_parity: number;
     }
+  }
+}
 
-    export namespace Data {
-      export interface Authorization {
-        chain_id: string | number;
+/**
+ * Response to the EVM `secp256k1_sign` RPC.
+ */
+export interface EthereumSecp256k1SignRpcResponse {
+  data: EthereumSecp256k1SignRpcResponse.Data;
+
+  method: 'secp256k1_sign';
+}
 
-        contract: string;
+export namespace EthereumSecp256k1SignRpcResponse {
+  export interface Data {
+    encoding: 'hex';
 
-        nonce: string | number;
+    signature: string;
+  }
+}
 
-        r: string;
+/**
+ * Response to the SVM `signTransaction` RPC.
+ */
+export interface SolanaSignTransactionRpcResponse {
+  data: SolanaSignTransactionRpcResponse.Data;
+
+  method: 'signTransaction';
+}
+
+export namespace SolanaSignTransactionRpcResponse {
+  export interface Data {
+    encoding: 'base64';
+
+    signed_transaction: string;
+  }
+}
 
-        s: string;
+/**
+ * Response to the SVM `signAndSendTransaction` RPC.
+ */
+export interface SolanaSignAndSendTransactionRpcResponse {
+  data: SolanaSignAndSendTransactionRpcResponse.Data;
+
+  method: 'signAndSendTransaction';
+}
+
+export namespace SolanaSignAndSendTransactionRpcResponse {
+  export interface Data {
+    caip2: string;
+
+    hash: string;
+
+    transaction_id?: string;
+  }
+}
+
+/**
+ * Response to the SVM `signMessage` RPC.
+ */
+export interface SolanaSignMessageRpcResponse {
+  data: SolanaSignMessageRpcResponse.Data;
+
+  method: 'signMessage';
+}
+
+export namespace SolanaSignMessageRpcResponse {
+  export interface Data {
+    encoding: 'base64';
+
+    signature: string;
+  }
+}
+
+export interface WalletExportResponse {
+  /**
+   * The encrypted private key.
+   */
+  ciphertext: string;
+
+  /**
+   * The base64-encoded encapsulated key that was generated during encryption, for
+   * use during decryption.
+   */
+  encapsulated_key: string;
+
+  /**
+   * The encryption type of the wallet to import. Currently only supports `HPKE`.
+   */
+  encryption_type: 'HPKE';
+}
 
-        y_parity: number;
-      }
-    }
-  }
+export interface WalletInitImportResponse {
+  /**
+   * The base64-encoded encryption public key to encrypt the wallet entropy with.
+   */
+  encryption_public_key: string;
 
-  export interface EthereumSecp256k1SignRpcResponse {
-    data: EthereumSecp256k1SignRpcResponse.Data;
+  /**
+   * The encryption type of the wallet to import. Currently only supports `HPKE`.
+   */
+  encryption_type: 'HPKE';
+}
 
-    method: 'secp256k1_sign';
-  }
+export interface WalletRawSignResponse {
+  data: WalletRawSignResponse.Data;
+}
 
-  export namespace EthereumSecp256k1SignRpcResponse {
-    export interface Data {
-      encoding: 'hex';
+export namespace WalletRawSignResponse {
+  export interface Data {
+    encoding: 'hex';
 
-      signature: string;
-    }
+    signature: string;
   }
 }
 
+/**
+ * Response to the EVM `personal_sign` RPC.
+ */
+export type WalletRpcResponse =
+  | EthereumPersonalSignRpcResponse
+  | EthereumSignTypedDataRpcResponse
+  | EthereumSignTransactionRpcResponse
+  | EthereumSendTransactionRpcResponse
+  | EthereumSignUserOperationRpcResponse
+  | EthereumSign7702AuthorizationRpcResponse
+  | EthereumSecp256k1SignRpcResponse
+  | SolanaSignMessageRpcResponse
+  | SolanaSignTransactionRpcResponse
+  | SolanaSignAndSendTransactionRpcResponse;
+
 export type WalletAuthenticateWithJwtResponse =
   | WalletAuthenticateWithJwtResponse.WithEncryption
   | WalletAuthenticateWithJwtResponse.WithoutEncryption;
@@ -725,8 +1091,9 @@ export namespace WalletCreateParams {
   }
 
   /**
-   * The P-256 public key of the owner of the resource. If you provide this, do not
-   * specify an owner_id as it will be generated automatically.
+   * The P-256 public key of the owner of the resource, in base64-encoded DER format.
+   * If you provide this, do not specify an owner_id as it will be generated
+   * automatically.
    */
   export interface PublicKeyOwner {
     public_key: string;
@@ -837,9 +1204,9 @@ export declare namespace WalletInitImportParams {
 
 export interface WalletRawSignParams {
   /**
-   * Body param:
+   * Body param: Sign a pre-computed hash
    */
-  params: WalletRawSignParams.Params;
+  params: WalletRawSignParams.Hash | WalletRawSignParams.Bytes;
 
   /**
    * Header param: Request authorization signature. If multiple signatures are
@@ -855,36 +1222,55 @@ export interface WalletRawSignParams {
 }
 
 export namespace WalletRawSignParams {
-  export interface Params {
+  /**
+   * Sign a pre-computed hash
+   */
+  export interface Hash {
     /**
      * The hash to sign. Must start with `0x`.
      */
-    hash?: string;
+    hash: string;
+  }
+
+  /**
+   * Hash and sign bytes (Tron only)
+   */
+  export interface Bytes {
+    /**
+     * The bytes to hash and sign.
+     */
+    bytes: string;
+
+    /**
+     * Encoding scheme. Currently only utf-8 is supported.
+     */
+    encoding: 'utf-8';
   }
 }
 
 export type WalletRpcParams =
-  | WalletRpcParams.EthereumSignTransactionRpcInput
-  | WalletRpcParams.EthereumSendTransactionRpcInput
   | WalletRpcParams.EthereumPersonalSignRpcInput
   | WalletRpcParams.EthereumSignTypedDataRpcInput
+  | WalletRpcParams.EthereumSignTransactionRpcInput
+  | WalletRpcParams.EthereumSignUserOperationRpcInput
+  | WalletRpcParams.EthereumSendTransactionRpcInput
   | WalletRpcParams.EthereumSign7702AuthorizationRpcInput
   | WalletRpcParams.EthereumSecp256k1SignRpcInput
+  | WalletRpcParams.SolanaSignMessageRpcInput
   | WalletRpcParams.SolanaSignTransactionRpcInput
-  | WalletRpcParams.SolanaSignAndSendTransactionRpcInput
-  | WalletRpcParams.SolanaSignMessageRpcInput;
+  | WalletRpcParams.SolanaSignAndSendTransactionRpcInput;
 
 export declare namespace WalletRpcParams {
-  export interface EthereumSignTransactionRpcInput {
+  export interface EthereumPersonalSignRpcInput {
     /**
      * Body param:
      */
-    method: 'eth_signTransaction';
+    method: 'personal_sign';
 
     /**
      * Body param:
      */
-    params: EthereumSignTransactionRpcInput.Params;
+    params: EthereumPersonalSignRpcInput.Params;
 
     /**
      * Body param:
@@ -909,53 +1295,84 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace EthereumSignTransactionRpcInput {
+  export namespace EthereumPersonalSignRpcInput {
     export interface Params {
-      transaction: Params.Transaction;
+      encoding: 'utf-8' | 'hex';
+
+      message: string;
     }
+  }
 
-    export namespace Params {
-      export interface Transaction {
-        chain_id?: string | number;
+  export interface EthereumSignTypedDataRpcInput {
+    /**
+     * Body param:
+     */
+    method: 'eth_signTypedData_v4';
 
-        data?: string;
+    /**
+     * Body param:
+     */
+    params: EthereumSignTypedDataRpcInput.Params;
 
-        from?: string;
+    /**
+     * Body param:
+     */
+    address?: string;
 
-        gas_limit?: string | number;
+    /**
+     * Body param:
+     */
+    chain_type?: 'ethereum';
 
-        gas_price?: string | number;
+    /**
+     * Header param: Request authorization signature. If multiple signatures are
+     * required, they should be comma separated.
+     */
+    'privy-authorization-signature'?: string;
 
-        max_fee_per_gas?: string | number;
+    /**
+     * Header param: Idempotency keys ensure API requests are executed only once within
+     * a 24-hour window.
+     */
+    'privy-idempotency-key'?: string;
+  }
 
-        max_priority_fee_per_gas?: string | number;
+  export namespace EthereumSignTypedDataRpcInput {
+    export interface Params {
+      typed_data: Params.TypedData;
+    }
 
-        nonce?: string | number;
+    export namespace Params {
+      export interface TypedData {
+        domain: { [key: string]: unknown };
 
-        to?: string;
+        message: { [key: string]: unknown };
 
-        type?: 0 | 1 | 2;
+        primary_type: string;
 
-        value?: string | number;
+        types: { [key: string]: Array<TypedData.Type> };
+      }
+
+      export namespace TypedData {
+        export interface Type {
+          name: string;
+
+          type: string;
+        }
       }
     }
   }
 
-  export interface EthereumSendTransactionRpcInput {
-    /**
-     * Body param:
-     */
-    caip2: string;
-
+  export interface EthereumSignTransactionRpcInput {
     /**
      * Body param:
      */
-    method: 'eth_sendTransaction';
+    method: 'eth_signTransaction';
 
     /**
      * Body param:
      */
-    params: EthereumSendTransactionRpcInput.Params;
+    params: EthereumSignTransactionRpcInput.Params;
 
     /**
      * Body param:
@@ -967,11 +1384,6 @@ export declare namespace WalletRpcParams {
      */
     chain_type?: 'ethereum';
 
-    /**
-     * Body param:
-     */
-    sponsor?: boolean;
-
     /**
      * Header param: Request authorization signature. If multiple signatures are
      * required, they should be comma separated.
@@ -985,7 +1397,7 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace EthereumSendTransactionRpcInput {
+  export namespace EthereumSignTransactionRpcInput {
     export interface Params {
       transaction: Params.Transaction;
     }
@@ -1017,16 +1429,16 @@ export declare namespace WalletRpcParams {
     }
   }
 
-  export interface EthereumPersonalSignRpcInput {
+  export interface EthereumSignUserOperationRpcInput {
     /**
      * Body param:
      */
-    method: 'personal_sign';
+    method: 'eth_signUserOperation';
 
     /**
      * Body param:
      */
-    params: EthereumPersonalSignRpcInput.Params;
+    params: EthereumSignUserOperationRpcInput.Params;
 
     /**
      * Body param:
@@ -1051,24 +1463,59 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace EthereumPersonalSignRpcInput {
+  export namespace EthereumSignUserOperationRpcInput {
     export interface Params {
-      encoding: 'utf-8' | 'hex';
+      chain_id: string | number;
 
-      message: string;
+      contract: string;
+
+      user_operation: Params.UserOperation;
+    }
+
+    export namespace Params {
+      export interface UserOperation {
+        call_data: string;
+
+        call_gas_limit: string;
+
+        max_fee_per_gas: string;
+
+        max_priority_fee_per_gas: string;
+
+        nonce: string;
+
+        paymaster: string;
+
+        paymaster_data: string;
+
+        paymaster_post_op_gas_limit: string;
+
+        paymaster_verification_gas_limit: string;
+
+        pre_verification_gas: string;
+
+        sender: string;
+
+        verification_gas_limit: string;
+      }
     }
   }
 
-  export interface EthereumSignTypedDataRpcInput {
+  export interface EthereumSendTransactionRpcInput {
     /**
      * Body param:
      */
-    method: 'eth_signTypedData_v4';
+    caip2: string;
 
     /**
      * Body param:
      */
-    params: EthereumSignTypedDataRpcInput.Params;
+    method: 'eth_sendTransaction';
+
+    /**
+     * Body param:
+     */
+    params: EthereumSendTransactionRpcInput.Params;
 
     /**
      * Body param:
@@ -1080,6 +1527,11 @@ export declare namespace WalletRpcParams {
      */
     chain_type?: 'ethereum';
 
+    /**
+     * Body param:
+     */
+    sponsor?: boolean;
+
     /**
      * Header param: Request authorization signature. If multiple signatures are
      * required, they should be comma separated.
@@ -1093,28 +1545,34 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace EthereumSignTypedDataRpcInput {
+  export namespace EthereumSendTransactionRpcInput {
     export interface Params {
-      typed_data: Params.TypedData;
+      transaction: Params.Transaction;
     }
 
     export namespace Params {
-      export interface TypedData {
-        domain: { [key: string]: unknown };
+      export interface Transaction {
+        chain_id?: string | number;
 
-        message: { [key: string]: unknown };
+        data?: string;
 
-        primary_type: string;
+        from?: string;
 
-        types: { [key: string]: Array<TypedData.Type> };
-      }
+        gas_limit?: string | number;
 
-      export namespace TypedData {
-        export interface Type {
-          name: string;
+        gas_price?: string | number;
 
-          type: string;
-        }
+        max_fee_per_gas?: string | number;
+
+        max_priority_fee_per_gas?: string | number;
+
+        nonce?: string | number;
+
+        to?: string;
+
+        type?: 0 | 1 | 2;
+
+        value?: string | number;
       }
     }
   }
@@ -1203,16 +1661,16 @@ export declare namespace WalletRpcParams {
     }
   }
 
-  export interface SolanaSignTransactionRpcInput {
+  export interface SolanaSignMessageRpcInput {
     /**
      * Body param:
      */
-    method: 'signTransaction';
+    method: 'signMessage';
 
     /**
      * Body param:
      */
-    params: SolanaSignTransactionRpcInput.Params;
+    params: SolanaSignMessageRpcInput.Params;
 
     /**
      * Body param:
@@ -1237,29 +1695,24 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace SolanaSignTransactionRpcInput {
+  export namespace SolanaSignMessageRpcInput {
     export interface Params {
       encoding: 'base64';
 
-      transaction: string;
+      message: string;
     }
   }
 
-  export interface SolanaSignAndSendTransactionRpcInput {
-    /**
-     * Body param:
-     */
-    caip2: string;
-
+  export interface SolanaSignTransactionRpcInput {
     /**
      * Body param:
      */
-    method: 'signAndSendTransaction';
+    method: 'signTransaction';
 
     /**
      * Body param:
      */
-    params: SolanaSignAndSendTransactionRpcInput.Params;
+    params: SolanaSignTransactionRpcInput.Params;
 
     /**
      * Body param:
@@ -1271,11 +1724,6 @@ export declare namespace WalletRpcParams {
      */
     chain_type?: 'solana';
 
-    /**
-     * Body param:
-     */
-    sponsor?: boolean;
-
     /**
      * Header param: Request authorization signature. If multiple signatures are
      * required, they should be comma separated.
@@ -1289,7 +1737,7 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace SolanaSignAndSendTransactionRpcInput {
+  export namespace SolanaSignTransactionRpcInput {
     export interface Params {
       encoding: 'base64';
 
@@ -1297,16 +1745,21 @@ export declare namespace WalletRpcParams {
     }
   }
 
-  export interface SolanaSignMessageRpcInput {
+  export interface SolanaSignAndSendTransactionRpcInput {
     /**
      * Body param:
      */
-    method: 'signMessage';
+    caip2: string;
 
     /**
      * Body param:
      */
-    params: SolanaSignMessageRpcInput.Params;
+    method: 'signAndSendTransaction';
+
+    /**
+     * Body param:
+     */
+    params: SolanaSignAndSendTransactionRpcInput.Params;
 
     /**
      * Body param:
@@ -1318,6 +1771,11 @@ export declare namespace WalletRpcParams {
      */
     chain_type?: 'solana';
 
+    /**
+     * Body param:
+     */
+    sponsor?: boolean;
+
     /**
      * Header param: Request authorization signature. If multiple signatures are
      * required, they should be comma separated.
@@ -1331,11 +1789,11 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace SolanaSignMessageRpcInput {
+  export namespace SolanaSignAndSendTransactionRpcInput {
     export interface Params {
       encoding: 'base64';
 
-      message: string;
+      transaction: string;
     }
   }
 }
@@ -1482,8 +1940,9 @@ export namespace WalletUpdateParams {
   }
 
   /**
-   * The P-256 public key of the owner of the resource. If you provide this, do not
-   * specify an owner_id as it will be generated automatically.
+   * The P-256 public key of the owner of the resource, in base64-encoded DER format.
+   * If you provide this, do not specify an owner_id as it will be generated
+   * automatically.
    */
   export interface PublicKeyOwner {
     public_key: string;
@@ -1582,6 +2041,26 @@ export declare namespace Wallets {
     type Wallet as Wallet,
     type WalletChainType as WalletChainType,
     type WalletRevokeResponse as WalletRevokeResponse,
+    type EthereumPersonalSignRpcInput as EthereumPersonalSignRpcInput,
+    type EthereumSignTransactionRpcInput as EthereumSignTransactionRpcInput,
+    type EthereumSendTransactionRpcInput as EthereumSendTransactionRpcInput,
+    type EthereumSignTypedDataRpcInput as EthereumSignTypedDataRpcInput,
+    type EthereumSignUserOperationRpcInput as EthereumSignUserOperationRpcInput,
+    type EthereumSign7702AuthorizationRpcInput as EthereumSign7702AuthorizationRpcInput,
+    type EthereumSecp256k1SignRpcInput as EthereumSecp256k1SignRpcInput,
+    type SolanaSignTransactionRpcInput as SolanaSignTransactionRpcInput,
+    type SolanaSignAndSendTransactionRpcInput as SolanaSignAndSendTransactionRpcInput,
+    type SolanaSignMessageRpcInput as SolanaSignMessageRpcInput,
+    type EthereumSignTransactionRpcResponse as EthereumSignTransactionRpcResponse,
+    type EthereumSendTransactionRpcResponse as EthereumSendTransactionRpcResponse,
+    type EthereumPersonalSignRpcResponse as EthereumPersonalSignRpcResponse,
+    type EthereumSignTypedDataRpcResponse as EthereumSignTypedDataRpcResponse,
+    type EthereumSignUserOperationRpcResponse as EthereumSignUserOperationRpcResponse,
+    type EthereumSign7702AuthorizationRpcResponse as EthereumSign7702AuthorizationRpcResponse,
+    type EthereumSecp256k1SignRpcResponse as EthereumSecp256k1SignRpcResponse,
+    type SolanaSignTransactionRpcResponse as SolanaSignTransactionRpcResponse,
+    type SolanaSignAndSendTransactionRpcResponse as SolanaSignAndSendTransactionRpcResponse,
+    type SolanaSignMessageRpcResponse as SolanaSignMessageRpcResponse,
     type WalletExportResponse as WalletExportResponse,
     type WalletInitImportResponse as WalletInitImportResponse,
     type WalletRawSignResponse as WalletRawSignResponse,