@privy-io/node 0.4.1 → 0.6.0

package/src/resources/wallets/wallets.ts

@@ -152,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' },
    * });
    * ```
    */
@@ -288,7 +288,7 @@ export type CurveSigningChainType =
 /**
  * The wallet chain types that offer first class support.
  */
-export type FirstClassChainType = 'solana' | 'ethereum';
+export type FirstClassChainType = 'ethereum' | 'solana';
 
 export interface Wallet {
   /**
@@ -362,8 +362,8 @@ export namespace Wallet {
  * The wallet chain types.
  */
 export type WalletChainType =
-  | 'solana'
   | 'ethereum'
+  | 'solana'
   | 'cosmos'
   | 'stellar'
   | 'sui'
@@ -376,233 +376,611 @@ export type WalletChainType =
   | 'starknet'
   | 'spark';
 
-export interface WalletExportResponse {
-  /**
-   * The encrypted private key.
-   */
-  ciphertext: string;
+/**
+ * The wallet chain types that are not first class chains.
+ */
+export type ExtendedChainType =
+  | 'cosmos'
+  | 'stellar'
+  | 'sui'
+  | 'aptos'
+  | 'movement'
+  | 'tron'
+  | 'bitcoin-segwit'
+  | 'near'
+  | 'ton'
+  | 'starknet'
+  | 'spark';
 
-  /**
-   * The base64-encoded encapsulated key that was generated during encryption, for
-   * use during decryption.
-   */
-  encapsulated_key: string;
+/**
+ * Executes the EVM `personal_sign` RPC (EIP-191) to sign a message.
+ */
+export interface EthereumPersonalSignRpcInput {
+  method: 'personal_sign';
 
-  /**
-   * The encryption type of the wallet to import. Currently only supports `HPKE`.
-   */
-  encryption_type: 'HPKE';
+  params: EthereumPersonalSignRpcInput.Params;
+
+  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;
 
-      signed_transaction: string;
+      to?: string;
+
+      type?: 0 | 1 | 2;
+
+      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 };
+
+      primary_type: string;
+
+      types: { [key: string]: Array<TypedData.Type> };
+    }
 
-      transaction_id?: string;
+    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;
 
-      signature: 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 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;
+  }
+}
+
+/**
+ * Executes the SVM `signAndSendTransaction` RPC to sign and broadcast a
+ * transaction.
+ */
+export interface SolanaSignAndSendTransactionRpcInput {
+  caip2: string;
+
+  method: 'signAndSendTransaction';
+
+  params: SolanaSignAndSendTransactionRpcInput.Params;
+
+  address?: string;
+
+  chain_type?: 'solana';
+
+  sponsor?: boolean;
+}
+
+export namespace SolanaSignAndSendTransactionRpcInput {
+  export interface Params {
+    encoding: 'base64';
+
+    transaction: string;
   }
+}
 
-  export namespace EthereumSendTransactionRpcResponse {
-    export interface Data {
-      caip2: string;
+/**
+ * Executes the SVM `signMessage` RPC to sign a message.
+ */
+export interface SolanaSignMessageRpcInput {
+  method: 'signMessage';
 
-      hash: string;
+  params: SolanaSignMessageRpcInput.Params;
 
-      transaction_id?: string;
+  address?: string;
 
-      transaction_request?: Data.TransactionRequest;
-    }
+  chain_type?: 'solana';
+}
 
-    export namespace Data {
-      export interface TransactionRequest {
-        chain_id?: string | number;
+export namespace SolanaSignMessageRpcInput {
+  export interface Params {
+    encoding: 'base64';
 
-        data?: string;
+    message: string;
+  }
+}
 
-        from?: string;
+/**
+ * Response to the EVM `eth_signTransaction` RPC.
+ */
+export interface EthereumSignTransactionRpcResponse {
+  data: EthereumSignTransactionRpcResponse.Data;
 
-        gas_limit?: string | number;
+  method: 'eth_signTransaction';
+}
 
-        gas_price?: string | number;
+export namespace EthereumSignTransactionRpcResponse {
+  export interface Data {
+    encoding: 'rlp';
 
-        max_fee_per_gas?: string | number;
+    signed_transaction: string;
+  }
+}
 
-        max_priority_fee_per_gas?: string | number;
+/**
+ * Response to the EVM `eth_sendTransaction` RPC.
+ */
+export interface EthereumSendTransactionRpcResponse {
+  data: EthereumSendTransactionRpcResponse.Data;
 
-        nonce?: string | number;
+  method: 'eth_sendTransaction';
+}
 
-        to?: string;
+export namespace EthereumSendTransactionRpcResponse {
+  export interface Data {
+    caip2: string;
 
-        type?: 0 | 1 | 2;
+    hash: string;
 
-        value?: string | number;
-      }
+    transaction_id?: string;
+
+    transaction_request?: Data.TransactionRequest;
+  }
+
+  export namespace Data {
+    export interface TransactionRequest {
+      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 interface EthereumPersonalSignRpcResponse {
-    data: EthereumPersonalSignRpcResponse.Data;
+/**
+ * Response to the EVM `personal_sign` RPC.
+ */
+export interface EthereumPersonalSignRpcResponse {
+  data: EthereumPersonalSignRpcResponse.Data;
 
-    method: 'personal_sign';
+  method: 'personal_sign';
+}
+
+export namespace EthereumPersonalSignRpcResponse {
+  export interface Data {
+    encoding: 'hex';
+
+    signature: string;
   }
+}
 
-  export namespace EthereumPersonalSignRpcResponse {
-    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;
   }
+}
+
+/**
+ * Response to the EVM `eth_signUserOperation` RPC.
+ */
+export interface EthereumSignUserOperationRpcResponse {
+  data: EthereumSignUserOperationRpcResponse.Data;
 
-  export interface EthereumSignTypedDataRpcResponse {
-    data: EthereumSignTypedDataRpcResponse.Data;
+  method: 'eth_signUserOperation';
+}
 
-    method: 'eth_signTypedData_v4';
+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 EthereumSignTypedDataRpcResponse {
-    export interface Data {
-      encoding: 'hex';
+  export namespace Data {
+    export interface Authorization {
+      chain_id: string | number;
+
+      contract: string;
+
+      nonce: string | number;
+
+      r: string;
+
+      s: string;
 
-      signature: string;
+      y_parity: number;
     }
   }
+}
 
-  export interface EthereumSign7702AuthorizationRpcResponse {
-    data: EthereumSign7702AuthorizationRpcResponse.Data;
+/**
+ * Response to the EVM `secp256k1_sign` RPC.
+ */
+export interface EthereumSecp256k1SignRpcResponse {
+  data: EthereumSecp256k1SignRpcResponse.Data;
 
-    method: 'eth_sign7702Authorization';
+  method: 'secp256k1_sign';
+}
+
+export namespace EthereumSecp256k1SignRpcResponse {
+  export interface Data {
+    encoding: 'hex';
+
+    signature: 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;
   }
+}
 
-  export namespace EthereumSign7702AuthorizationRpcResponse {
-    export interface Data {
-      authorization: Data.Authorization;
-    }
+/**
+ * Response to the SVM `signAndSendTransaction` RPC.
+ */
+export interface SolanaSignAndSendTransactionRpcResponse {
+  data: SolanaSignAndSendTransactionRpcResponse.Data;
+
+  method: 'signAndSendTransaction';
+}
+
+export namespace SolanaSignAndSendTransactionRpcResponse {
+  export interface Data {
+    caip2: string;
+
+    hash: string;
 
-    export namespace Data {
-      export interface Authorization {
-        chain_id: string | number;
+    transaction_id?: string;
+  }
+}
+
+/**
+ * Response to the SVM `signMessage` RPC.
+ */
+export interface SolanaSignMessageRpcResponse {
+  data: SolanaSignMessageRpcResponse.Data;
 
-        contract: string;
+  method: 'signMessage';
+}
 
-        nonce: string | number;
+export namespace SolanaSignMessageRpcResponse {
+  export interface Data {
+    encoding: 'base64';
 
-        r: string;
+    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;
 
-        s: 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;
@@ -741,20 +1119,10 @@ export namespace WalletCreateParams {
 }
 
 export interface WalletListParams extends CursorParams {
-  chain_type?:
-    | 'cosmos'
-    | 'stellar'
-    | 'sui'
-    | 'aptos'
-    | 'movement'
-    | 'tron'
-    | 'bitcoin-segwit'
-    | 'near'
-    | 'ton'
-    | 'starknet'
-    | 'spark'
-    | 'solana'
-    | 'ethereum';
+  /**
+   * The wallet chain types.
+   */
+  chain_type?: WalletChainType;
 
   user_id?: string;
 }
@@ -864,7 +1232,7 @@ export namespace WalletRawSignParams {
   }
 
   /**
-   * Hash and sign bytes (Tron only)
+   * Hash and sign bytes
    */
   export interface UnionMember1 {
     /**
@@ -873,34 +1241,40 @@ export namespace WalletRawSignParams {
     bytes: string;
 
     /**
-     * Encoding scheme. Currently only utf-8 is supported.
+     * Encoding scheme for the bytes.
+     */
+    encoding: 'utf-8' | 'hex';
+
+    /**
+     * Hash function to use for the bytes.
      */
-    encoding: 'utf-8';
+    hash_function: 'keccak256' | 'sha256';
   }
 }
 
 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:
@@ -925,53 +1299,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:
@@ -983,11 +1388,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.
@@ -1001,7 +1401,7 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace EthereumSendTransactionRpcInput {
+  export namespace EthereumSignTransactionRpcInput {
     export interface Params {
       transaction: Params.Transaction;
     }
@@ -1033,16 +1433,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:
@@ -1067,24 +1467,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:
@@ -1096,6 +1531,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.
@@ -1109,28 +1549,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;
       }
     }
   }
@@ -1219,16 +1665,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:
@@ -1253,29 +1699,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:
@@ -1287,11 +1728,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.
@@ -1305,7 +1741,7 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace SolanaSignAndSendTransactionRpcInput {
+  export namespace SolanaSignTransactionRpcInput {
     export interface Params {
       encoding: 'base64';
 
@@ -1313,16 +1749,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:
@@ -1334,6 +1775,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.
@@ -1347,11 +1793,11 @@ export declare namespace WalletRpcParams {
     'privy-idempotency-key'?: string;
   }
 
-  export namespace SolanaSignMessageRpcInput {
+  export namespace SolanaSignAndSendTransactionRpcInput {
     export interface Params {
       encoding: 'base64';
 
-      message: string;
+      transaction: string;
     }
   }
 }
@@ -1598,6 +2044,27 @@ export declare namespace Wallets {
     type FirstClassChainType as FirstClassChainType,
     type Wallet as Wallet,
     type WalletChainType as WalletChainType,
+    type ExtendedChainType as ExtendedChainType,
+    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,