@privy-io/react-auth 1.23.2 → 1.24.0-beta.1

package/dist/index.d.ts

@@ -1,11 +1,25 @@
 import React, { ReactElement } from 'react';
-import { ExternalProvider, Web3Provider } from '@ethersproject/providers';
+import { ExternalProvider, InfuraProvider, Web3Provider } from '@ethersproject/providers';
+import EventEmitter from 'eventemitter3';
 import WCProvider from '@walletconnect/web3-provider';
 import { AbstractProvider } from 'web3-core';
 import { AxiosResponse, AxiosRequestConfig } from 'axios';
 
+/**
+ * We support a subset of the provider methods found here:
+ *
+ *     https://ethereum.org/en/developers/docs/apis/json-rpc/#json-rpc-methods
+ *
+ * For now, we're focused on signing-related methods because the iframe (this code)
+ * is the only place that has access to the private key and thus is the only one
+ * who can create signatures. All other methods do not need the private key and
+ * can therefore be implemented by clients of the iframe.
+ */
+declare const SUPPORTED_JSON_RPC_METHODS: readonly ["eth_sign", "eth_populateTransactionRequest", "eth_signTransaction", "personal_sign"];
+type JsonRpcMethodType = typeof SUPPORTED_JSON_RPC_METHODS[number];
 type Quantity = string | number | bigint;
 type UnsignedTransactionRequest = {
+    from?: string;
     to?: string;
     nonce?: number;
     gasLimit?: Quantity;
@@ -51,10 +65,47 @@ type TransactionReceipt = {
     cumulativeGasUsed: string;
     effectiveGasPrice: string;
 };
+interface BaseRpcRequestType {
+    method: JsonRpcMethodType;
+}
+interface eth_populateTransactionRequest extends BaseRpcRequestType {
+    method: 'eth_populateTransactionRequest';
+    params: [UnsignedTransactionRequest];
+}
+interface eth_populateTransactionRequestResponse {
+    method: 'eth_populateTransactionRequest';
+    data: UnsignedTransactionRequest;
+}
+interface eth_signTransaction extends BaseRpcRequestType {
+    method: 'eth_signTransaction';
+    params: [UnsignedTransactionRequest];
+}
+interface eth_sign extends BaseRpcRequestType {
+    method: 'eth_sign';
+    params: [address: string, message: string];
+}
+interface eth_signResponse {
+    method: 'eth_sign';
+    data: string;
+}
+interface personal_sign extends BaseRpcRequestType {
+    method: 'personal_sign';
+    params: [string, string];
+}
+interface personal_signResponse {
+    method: 'personal_sign';
+    data: string;
+}
+interface eth_signTransactionResponse {
+    method: 'eth_signTransaction';
+    data: string;
+}
+type RpcRequestType = eth_signTransaction | eth_populateTransactionRequest | eth_sign | personal_sign;
+type RpcResponseType = eth_signTransactionResponse | eth_populateTransactionRequestResponse | eth_signResponse | personal_signResponse;
 
 declare const SUPPORTED_OAUTH_PROVIDERS: readonly ["google", "discord", "twitter", "github", "apple"];
 type OAuthProviderType = typeof SUPPORTED_OAUTH_PROVIDERS[number];
-declare const SUPPORTED_WALLET_CONNECTION_TYPES: readonly ["metamask", "phantom", "coinbase_wallet", "wallet_connect"];
+declare const SUPPORTED_WALLET_CONNECTION_TYPES: readonly ["metamask", "phantom", "coinbase_wallet", "wallet_connect", "embedded"];
 type WalletType = typeof SUPPORTED_WALLET_CONNECTION_TYPES[number];
 /**
  * Wallet metadata currently for internal use only
@@ -369,6 +420,44 @@ interface PrivyProviderProps {
  */
 declare const PrivyProvider: (props: PrivyProviderProps) => JSX.Element;
 
+type WalletCreateRequestDataType = {
+    accessToken: string;
+    recoveryPin: string;
+};
+type WalletConnectRequestDataType = {
+    accessToken: string;
+    address: string;
+};
+type WalletRecoverRequestDataType = {
+    accessToken: string;
+    address: string;
+    recoveryPin: string;
+};
+type WalletRpcRequestDataType = {
+    accessToken: string;
+    address: string;
+    request: RpcRequestType;
+};
+type WalletCreateResponseDataType = {
+    address: string;
+};
+type WalletConnectResponseDataType = {
+    address: string;
+};
+type WalletRecoverResponseDataType = {
+    address: string;
+};
+type WalletRpcResponseDataType = {
+    address: string;
+    response: RpcResponseType;
+};
+interface EmbeddedWalletProxy {
+    create: (data: WalletCreateRequestDataType) => Promise<WalletCreateResponseDataType>;
+    connect: (data: WalletConnectRequestDataType) => Promise<WalletConnectResponseDataType>;
+    recover: (data: WalletRecoverRequestDataType) => Promise<WalletRecoverResponseDataType>;
+    rpc: (data: WalletRpcRequestDataType) => Promise<WalletRpcResponseDataType>;
+}
+
 declare global {
     interface Window {
         ethereum?: any;
@@ -398,6 +487,23 @@ declare class PrivyProxyProvider implements EIP1193Provider {
     removeListener: (eventName: string | symbol, listener: (...args: any[]) => void) => any;
     setWalletProvider: (provider: EIP1193Provider) => void;
 }
+interface RequestArguments {
+    readonly method: string;
+    readonly params?: readonly unknown[] | object;
+}
+declare class Embedded1193Provider extends EventEmitter implements EIP1193Provider {
+    walletProxy: EmbeddedWalletProxy;
+    address: string;
+    infuraProvider: InfuraProvider;
+    chainId: number;
+    constructor(walletProxy: EmbeddedWalletProxy, address: string, chainId?: number);
+    handleSendTransaction(args: RequestArguments): Promise<string>;
+    private handleSwitchEthereumChain;
+    private handlePersonalSign;
+    private handleEstimateGas;
+    request(args: RequestArguments): Promise<unknown>;
+    connect(): Promise<string | null>;
+}
 /**
  * Shim to convert to ethers-compatible ExternalProvider class.
  * @hidden
@@ -420,23 +526,31 @@ declare class AsExternalProvider extends PrivyProxyProvider implements ExternalP
 
 /** @hidden */
 declare abstract class WalletConnector {
-    proxyProvider: PrivyProxyProvider;
+    proxyProvider: PrivyProxyProvider | Embedded1193Provider;
     walletType: WalletType;
     connected: boolean;
     address: string | null;
     chain: string | null;
-    constructor(walletType: WalletType, proxyProvider: PrivyProxyProvider, address: string | null);
+    constructor(walletType: WalletType, proxyProvider: PrivyProxyProvider | Embedded1193Provider, address: string | null);
     fetchAddress(): Promise<string | null>;
     fetchChainId(): Promise<string>;
     getConnectedWallet(): Promise<Wallet | null>;
     abstract get walletBranding(): WalletBranding;
     abstract connect(options: {
         showPrompt: boolean;
+        chainId?: number;
     }): Promise<Wallet | null>;
     abstract disconnect(): void;
     abstract isConnected(): Promise<boolean>;
     abstract promptConnection(walletType: WalletType): void;
     setActive(): Promise<boolean>;
+    /**
+     * Perform personal_sign with the user's wallet.
+     *
+     * @param {string} message The message to sign.
+     * @returns {string} The resulting signature.
+     */
+    sign(message: string): Promise<string>;
 }
 
 /**
@@ -454,6 +568,7 @@ type WalletId = '1ae92b26df02f0abca6304df07debccd18262fdf5fe82daa81593582dac9a36
  */
 declare class WCWalletConnector extends WalletConnector {
     private connectionManager;
+    proxyProvider: PrivyProxyProvider;
     constructor(connectionManager: WCConnectionManager, proxyProvider: PrivyProxyProvider, address: string | null);
     setActive(): Promise<boolean>;
     connect(options: {
@@ -563,6 +678,7 @@ declare class ConnectorManager {
     load(): void;
     /** Persist the instance state to storage to reload the connectors later. */
     save(): void;
+    addEmbeddedWalletConnector(walletProxy: EmbeddedWalletProxy, address: string): void;
     addWalletConnector(walletConnector: WalletConnector): void;
     getConnectorByAddress(address: string): WalletConnector | undefined;
     removeWallet(address: string): Promise<void>;