@privy-io/js-sdk-core
Version:
Vanilla JS client for the Privy Auth API
1,269 lines • 126 kB
text/typescript
import { AuthenticatedUser, CoinbaseOnRampInitInput, CoinbaseOnRampInitResponse, LinkedAccount, LinkedAccountBitcoinSegwitEmbeddedWallet, LinkedAccountBitcoinTaprootEmbeddedWallet, LinkedAccountEmbeddedWallet, LinkedAccountEmbeddedWalletWithID, LinkedAccountEthereumEmbeddedWallet, LinkedAccountSmartWallet, LinkedAccountSolanaEmbeddedWallet, MfaPasskeyInitRequestBody, MfaSMSInitRequestBody, MoonpayOnRampSignInput, OAuthProviderID, OAuthProviderID as OAuthProviderID$1, OAuthTokens, PasskeyAuthenticatorVerifyResponse, RawSignResponse, SmartWalletConfiguration, SmartWalletType as SmartWalletType$1, UnsignedEthereumTransaction, User, Wallet, WalletCreateParams, WalletRawSignParams, WalletRpcParams, WalletRpcResponse, WalletUpdateParams } from "@privy-io/api-types";
import { Chain, RpcConfig } from "@privy-io/chains";
import { Route } from "@privy-io/routes";
import "@metamask/eth-sig-util";
import "viem/account-abstraction";
import { StrictUnsignedTempoTransactionRequest, StrictUnsignedTransactionRequest } from "@privy-io/ethereum";
import EventEmitter from "eventemitter3";
import { PrivyErrorCode } from "@privy-io/api-base";
import { Connection, SendOptions, Transaction, VersionedTransaction } from "@solana/web3.js";
import { AuthenticationResponseJSON, RegistrationResponseJSON } from "@simplewebauthn/types";
import { Hex, HttpTransport, TypedDataDefinition } from "viem";
import "viem/chains";
import { AsYouType, CountryCallingCode, CountryCode, getCountryCallingCode } from "libphonenumber-js/min";
import { SolanaSignAndSendTransactionFeature, SolanaSignInFeature, SolanaSignMessageFeature, SolanaSignTransactionFeature } from "@solana/wallet-standard-features";
import { WalletWithFeatures } from "@wallet-standard/base";
import { StandardConnectFeature, StandardDisconnectFeature, StandardEventsFeature } from "@wallet-standard/features";
import { WalletAccount } from "@wallet-standard/core";
export * from "@privy-io/chains";
//#endregion
//#region src/embedded/errors.d.ts
declare enum PrivyEmbeddedWalletErrorCode {
MISSING_OR_INVALID_PRIVY_APP_ID = "missing_or_invalid_privy_app_id",
MISSING_OR_INVALID_PRIVY_ACCOUNT_ID = "missing_or_invalid_privy_account_id",
INVALID_DATA = "invalid_data",
LINKED_TO_ANOTHER_USER = "linked_to_another_user",
ALLOWLIST_REJECTED = "allowlist_rejected",
OAUTH_USER_DENIED = "oauth_user_denied",
UNKNOWN_AUTH_ERROR = "unknown_auth_error",
USER_EXITED_AUTH_FLOW = "exited_auth_flow",
MUST_BE_AUTHENTICATED = "must_be_authenticated",
UNKNOWN_CONNECT_WALLET_ERROR = "unknown_connect_wallet_error",
GENERIC_CONNECT_WALLET_ERROR = "generic_connect_wallet_error",
CLIENT_REQUEST_TIMEOUT = "client_request_timeout",
INVALID_CREDENTIALS = "invalid_credentials"
}
declare abstract class PrivyError extends Error {
/**
* Privy error type.
*/
abstract type: string;
/**
* Original Error object, it the error originated client-side.
*/
cause?: Error;
/**
* An optional error code, often included in Privy API responses.
*/
privyErrorCode?: PrivyEmbeddedWalletErrorCode;
/**
* @param type Privy error type.
* @param message Human-readable message.
* @param cause Source of this error.
*/
protected constructor(message: string, cause?: unknown, privyErrorCode?: PrivyEmbeddedWalletErrorCode);
toString(): string;
}
/**
* A ProviderRpcError combines the necessary bits of the {PrivyError} with the
* EIP-compliant ProviderRpcError. This is meant to be a type around errors raised
* by the ethereum provider.
*/
declare class ProviderRpcError extends PrivyError {
type: string;
readonly code: number;
readonly data?: unknown;
constructor(message: string, code: number, data?: unknown);
}
declare class PrivyIframeError extends Error {
type: PrivyIframeErrorTypesType;
constructor(type: PrivyIframeErrorTypesType, message: string);
}
declare class PrivyConnectorError extends PrivyError {
type: string;
constructor(message: string, cause?: unknown, privyErrorCode?: PrivyEmbeddedWalletErrorCode);
}
declare class EmbeddedProviderError extends Error {
code: number;
data?: unknown;
constructor(message: string, code: number, data?: unknown);
}
declare const ProviderErrors: {
E32002_CONNECTION_ALREADY_PENDING: {
eipCode: number;
message: string;
detail: string;
retryable: boolean;
};
E32002_REQUEST_ALREADY_PENDING: {
eipCode: number;
message: string;
detail: string;
retryable: boolean;
};
E32002_WALLET_LOCKED: {
eipCode: number;
message: string;
detail: string;
retryable: boolean;
};
E4001_USER_REJECTED_REQUEST: {
eipCode: number;
message: string;
detail: string;
retryable: boolean;
};
E4001_DEFAULT_USER_REJECTED_REQUEST: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E4100_DEFAULT_UNAUTHORIZED: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E4200_DEFAULT_UNSUPPORTED_METHOD: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E4900_DEFAULT_DISCONNECTED: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E4901_DEFAULT_CHAIN_DISCONNECTED: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32700_DEFAULT_PARSE_ERROR: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32600_DEFAULT_INVALID_REQUEST: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32601_DEFAULT_METHOD_NOT_FOUND: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32602_DEFAULT_INVALID_PARAMS: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32603_DEFAULT_INTERNAL_ERROR: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32000_DEFAULT_INVALID_INPUT: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32001_DEFAULT_RESOURCE_NOT_FOUND: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32002_DEFAULT_RESOURCE_UNAVAILABLE: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32003_DEFAULT_TRANSACTION_REJECTED: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32004_DEFAULT_METHOD_NOT_SUPPORTED: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32005_DEFAULT_LIMIT_EXCEEDED: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
E32006_DEFAULT_JSON_RPC_VERSION_NOT_SUPPORTED: {
eipCode: number;
message: string;
detail: string;
default: boolean;
retryable: boolean;
};
UNKNOWN_ERROR: {
eipCode: number;
message: string;
detail: string;
retryable: boolean;
};
};
declare function errorIndicatesRecoveryIsNeeded(error: unknown): error is PrivyIframeError;
declare function errorIndicatesMfaTimeout(error: unknown): error is PrivyIframeError;
declare function errorIndicatesMfaVerificationFailed(error: unknown): error is PrivyIframeError;
declare function errorIndicatesMaxMfaRetries(error: unknown): error is PrivyIframeError;
declare function errorIndicatesMfaRateLimit(error: unknown): error is PrivyIframeError;
/**
* Represents an error message meant to display within the UI
*/
type UiErrorMessage = {
/**
* Main message to convey, one line
*/
message: string;
/**
* Additional detail that may be relevant if it cannot be conveyed in the message
*/
detail: string;
/**
* Whether this error is expected to be retryable
*/
retryable: boolean;
};
type ProviderError = UiErrorMessage & {
/**
* The EIP code, either [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193#provider-errors)
* or [EIP-1474](https://eips.ethereum.org/EIPS/eip-1474#error-codes)
*/
eipCode: number;
/**
* Whether the contents (message & detail) are the default specified by the
* EIP or if this is a custom message from our own semantic understanding of
* the error.
*/
default?: boolean;
};
/**
* A PrivyProviderRpcError is a classified {ProviderRpcError}. When relevant,
* we will attempt to replace the original messaging with our best guess of what
* is going on.
*/
declare class PrivyProviderRpcError extends ProviderRpcError {
details: ProviderError;
constructor(error: unknown);
}
//#endregion
//#region src/embedded/EmbeddedWalletProvider.d.ts
type ProviderConnectInfo = {
chainId: string;
};
type OnConnectEventHandler = (connectInfo: ProviderConnectInfo) => void;
type OnDisconnectEventHandler = (error: ProviderRpcError) => void;
type OnChainChangedEventHandler = (chainId: string | number) => void;
type OnAccountsChangedEventHandler = (accounts: string[]) => void;
type ProviderMessage = {
type: string;
data: unknown;
};
type OnMessageEventHandler = (message: ProviderMessage) => void;
type EIP1193OnEventHandler = OnConnectEventHandler | OnDisconnectEventHandler | OnChainChangedEventHandler | OnAccountsChangedEventHandler | OnMessageEventHandler;
interface EIP1193Provider {
request: (request: {
method: string;
params?: Array<unknown> | undefined;
}) => Promise<unknown>;
on: (eventName: string, listener: EIP1193OnEventHandler) => unknown;
removeListener: (eventName: string | symbol, listener: (...args: unknown[]) => void) => unknown;
}
type RequestArguments = {
method: string;
params?: Array<any> | undefined;
};
type OnNeedsRecovery = (input: {
recoveryMethod: EmbeddedWalletRecoveryOptions;
onRecovered: () => void;
}) => Promise<void> | void;
declare class EmbeddedWalletProvider extends EventEmitter implements EIP1193Provider {
request(request: RequestArguments): Promise<any>;
/**
* Backfills a transaction that may not specify a `chainId` with the provider's `this._chainId`
* and switches the provider to that chain. Works for both standard EVM and
* Tempo (type 118) requests.
*/
private ensureChainId;
/**
* If a chainId is provided that differs from the current `this._chainId`,
* the new chain and StaticJsonRpcProvider will be set
*/
private internalSwitchEthereumChain;
private handlePopulateTransaction;
private handleSignTransaction;
private handleSendTransaction;
private handleEstimateGas;
private handleSwitchEthereumChain;
private handleIFrameRpc;
private handleJsonRpc;
toJSON(): string;
}
//#endregion
//#region src/Error.d.ts
type AuthAction = 'login' | 'link';
type Method = 'email' | 'sms' | 'oauth' | 'siwe' | 'passkey' | 'farcaster' | 'siws';
type ClientErrorCode = `failed_to_complete_${AuthAction}_with_oauth` | `${AuthAction}_with_oauth_returned_with_invalid_credentials` | `${AuthAction}_with_oauth_was_cancelled_by_user` | 'attempted_rpc_call_before_logged_in' | 'attempted_submit_otp_before_sending' | 'attempted_to_set_password_before_connected' | 'attempted_to_set_password_but_password_already_set' | `attempted_login_with_${Method}_while_already_logged_in` | `attempted_link_${Method}_before_logged_in` | 'attempted_link_cross_app_before_logged_in' | 'attempted_login_with_cross_app_while_already_logged_in' | 'attempted_cross_app_request_before_logged_in' | 'attempted_update_before_logged_in' | 'attempted_update_email_without_a_linked_email' | 'attempted_update_phone_without_a_linked_phone' | 'cross_app_invalid_app' | 'cross_app_read_only' | 'cross_app_invalid_wallet' | 'cross_app_request_error' | `attempted_unlink_siwe_before_logged_in` | 'oauth_session_failed' | 'oauth_session_timeout' | 'user_signer_sign_error' | 'invalid_input' | 'embedded_wallet_before_logged_in' | 'embedded_wallet_needs_recovery' | 'embedded_wallet_creation_error' | 'embedded_wallet_recovery_error' | 'embedded_wallet_set_password_error' | 'embedded_wallet_set_recovery_error' | 'unknown_embedded_wallet_error' | 'embedded_wallet_does_not_exist' | 'embedded_wallet_already_exists' | 'embedded_wallet_webview_not_loaded' | 'embedded_wallet_request_error' | 'embedded_wallet_request_expired' | 'delegated_actions_before_logged_in' | 'delegated_actions_wallet_not_found' | 'delegated_actions_no_wallet_to_revoke' | 'no_passkey_found_for_challenge' | 'pkce_state_code_mismatch' | 'failed_to_create_passkey' | 'failed_to_generate_farcaster_uri' | 'failed_to_generate_farcaster_channel_token' | 'farcaster_polling_timeout' | 'farcaster_polling_canceled' | 'unsupported_recovery_method' | 'attempted_to_create_guest_account_for_logged_in_user' | 'attempted_to_read_storage_before_client_initialized' | 'third_party_auth_error' | 'invalid_native_app_id' | 'unsupported_mfa_method' | 'unsupported_chain_type' | 'invalid_mfa_code' | 'invalid_passkey_response' | 'storage_error' | 'smart_wallet_client_error' | 'chain_not_supported' | 'mfa_canceled' | 'configuration_error' | 'failed_to_fetch_moonpay_transaction_status' | 'unsupported_wallet_type';
type ErrorBody<T extends PrivyErrorCode | ClientErrorCode> = {
error: string;
code: T;
};
type ServerErrorBody = ErrorBody<PrivyErrorCode> & {
status: number;
};
declare class PrivyApiError extends Error {
name: string;
error: string;
code: PrivyErrorCode;
status: number;
constructor({ error, code, status }: ServerErrorBody);
}
declare class PrivyClientError extends Error {
error: string;
code: ClientErrorCode;
constructor({ error, code }: ErrorBody<ClientErrorCode>);
}
declare class MoonpayApiError extends Error {
error: string;
code: ClientErrorCode;
response: Response;
constructor({ error, code, response }: ErrorBody<ClientErrorCode> & {
response: Response;
});
}
/**
* This type converts the {@link PrivyErrorCode} enum into a string literal union type,
* in order to match the structure of {@link ClientErrorCode}.
*
* Note this is valid because the {@link PrivyErrorCode} enum is a string enum.
*/
type PrivyApiErrorCode = `${PrivyErrorCode}`;
/**
* All possible error codes, be it from the API or the client, plus an `'unknown_error'`
* code for unexpected errors.
*/
type ErrorCode = PrivyApiErrorCode | ClientErrorCode | 'unknown_error';
/**
* A partial map of error codes to error messages, with a `default` message as a fallback.
*/
type ErrorMessageMap = Partial<Record<ErrorCode, string>> & {
default: string;
};
/**
* Takes a message map and return an error formatter, that takes an error and
* returns the corresponding error message.
*
* Valid errors are all those in the classes {@link PrivyApiError} and {@link PrivyClientError}.
* Any other error will be treated as an unknown error.
*
* @param messageMap The partial map used to format error messages by their error code.
* @returns
*/
declare const createErrorFormatter: (messageMap: ErrorMessageMap) => (error: unknown) => string;
declare function errorIndicatesMfaCanceled(error: unknown): unknown;
//#endregion
//#region src/embedded/withMfa.d.ts
type MfaMethod = 'sms' | 'totp' | 'passkey';
type MfaSubmitArgs = {
mfaMethod: MfaMethod;
mfaCode: string | PasskeyAuthenticatorVerifyResponse;
relyingParty: string;
};
type MfaPromise = {
current: {
resolve: (args: MfaSubmitArgs) => void;
reject: (error: PrivyClientError) => void;
} | null;
};
type MfaSubmitPromise = {
current: {
resolve: (x: undefined) => void;
reject: (error: PrivyIframeError) => void;
} | null;
};
//#endregion
//#region src/embedded/types.d.ts
type Quantity = string | number | bigint;
type UnsignedTransactionRequest = {
from?: string;
to?: string;
nonce?: Quantity;
gasLimit?: Quantity;
gasPrice?: Quantity;
data?: ArrayLike<number> | string;
value?: Quantity;
chainId?: number;
type?: number;
accessList?: Array<{
address: string;
storageKeys: Array<string>;
}> | Array<[string, Array<string>]> | Record<string, Array<string>>;
maxPriorityFeePerGas?: Quantity;
maxFeePerGas?: Quantity;
/** Batch of calls to execute atomically. Required for Tempo transactions. */
calls?: Array<{
to: string;
data?: string;
value?: Quantity;
}>;
/** Token used to pay gas fees for Tempo transactions. */
feeToken?: string;
/** 2D nonce key for Tempo transactions (0 = protocol nonce, >0 = user nonces). */
nonceKey?: Quantity;
/** Earliest inclusion timestamp for Tempo transactions (seconds since epoch). */
validAfter?: Quantity;
/** Expiration timestamp for Tempo transactions (seconds since epoch). */
validBefore?: Quantity;
};
/**
* {@link UnsignedTransactionRequest} specifies the `chainId` field as optional,
* which matches ethers, wagmi, and a bunch of other libraries.
*
* However, we need the transaction's `chainId` to ensure it does price conversion, quote
* labeling, etc. importantly.
*
* > Note:
* > If the developer does not set a `chainId` in their `UnsignedTransactionRequest`,
* > we default to the embedded provider's current `chainId`
*/
type UnsignedTransactionRequestWithChainId = UnsignedTransactionRequest & {
chainId: number;
};
interface eth_populateTransactionRequestResponse {
method: 'eth_populateTransactionRequest';
data: UnsignedTransactionRequest;
}
interface eth_signResponse {
method: 'eth_sign';
data: string;
}
interface personal_signResponse {
method: 'personal_sign';
data: string;
}
interface eth_signTransactionResponse {
method: 'eth_signTransaction';
data: string;
}
interface eth_signTypedData_v4Response {
method: 'eth_signTypedData_v4';
data: string;
}
interface csw_signUserOperationResponse {
method: 'csw_signUserOperation';
data: string;
}
interface secp256k1_signResponse {
method: 'secp256k1_sign';
data: `0x${string}`;
}
type RpcResponseType = eth_signTransactionResponse | eth_populateTransactionRequestResponse | eth_signResponse | personal_signResponse | eth_signTypedData_v4Response | csw_signUserOperationResponse | secp256k1_signResponse;
interface SolanaRpcResponseType {
data: {
signature: string;
};
}
type BaseBitcoinRpcResponseType = {
method: string;
data: any;
};
/**
* The Privy SDK(s) will return the signature as a `Uint8Array`, but the iframe must serialize it to
* a `string` in order to pass it over the message bus. You can see how this is done in the signature handler.
*
* The Privy SDK(s) themselves must then deserialize the `string` to a `Uint8Array` before
* returning the signature to the caller.
*/
interface bitcoin_signResponse extends BaseBitcoinRpcResponseType {
method: 'sign';
data: {
signature: string;
};
}
interface bitcoin_signTransactionResponse extends BaseBitcoinRpcResponseType {
method: 'signTransaction';
data: {
signedTransaction: string;
};
}
type BitcoinRpcResponseType = bitcoin_signResponse | bitcoin_signTransactionResponse;
type PrivyEventType = 'privy:iframe:ready' | 'privy:user-signer:sign' | 'privy:wallets:create' | 'privy:wallets:add' | 'privy:wallets:set-recovery' | 'privy:wallets:connect' | 'privy:wallets:recover' | 'privy:wallets:rpc' | 'privy:wallet:create' | 'privy:wallet:connect' | 'privy:wallet:recover' | 'privy:wallet:rpc' | 'privy:solana-wallet:create' | 'privy:solana-wallet:create-additional' | 'privy:solana-wallet:connect' | 'privy:solana-wallet:recover' | 'privy:solana-wallet:rpc' | 'privy:delegated-actions:consent' | 'privy:mfa:verify' | 'privy:mfa:init-enrollment' | 'privy:mfa:submit-enrollment' | 'privy:mfa:unenroll' | 'privy:mfa:clear' | 'privy:auth:unlink-passkey';
type EmbeddedWalletRecoveryOptions = LinkedAccountEmbeddedWallet['recovery_method'];
type IEmbeddedWalletRecoveryOptions = EmbeddedWalletRecoveryOptions | 'icloud-native';
type PasswordRecoveryInput = {
recoveryMethod: 'user-passcode';
password: string;
};
type AppKeyRecoveryInput = {
recoveryMethod: 'recovery-encryption-key';
recoveryKey: string;
};
type CloudRecoveryInput = {
recoveryMethod: 'google-drive' | 'icloud';
recoveryAccessToken: string;
};
type ICloudNativeRecoveryInput = {
recoveryMethod: 'icloud-native';
recoverySecretOverride: string;
iCloudRecordNameOverride: string;
};
type SetRecoveryInput = {
wallet: LinkedAccountEthereumEmbeddedWallet | LinkedAccountSolanaEmbeddedWallet;
} & (PasswordRecoveryInput | CloudRecoveryInput | ICloudNativeRecoveryInput | PrivyRecoveryInput | AppKeyRecoveryInput);
interface SetRecoveryOutput {
/** User object with the updated embedded wallet */
user: User;
/**
* Provider for the embedded ethereum wallet.
*
* This value will be `null` if and only if the wallet passed in the input is not an Ethereum wallet.
* @deprecated Get the provider instance from the `getProvider(...)` method instead.
*/
provider: EmbeddedWalletProvider | null;
}
type BaseProxyRequest = {
accessToken: string;
} & Partial<MfaSubmitArgs>;
type PrivyResponseBaseEventType<E extends PrivyEventType, D extends PrivyResponseDataType> = {
id: string;
event: E;
data: D;
};
type ChainType = 'ethereum' | 'solana' | 'bitcoin-taproot' | 'bitcoin-segwit';
type BaseWalletsRequestData = BaseProxyRequest;
type IframeReadyResponseDataType = Record<string, never>;
type IframeReadyResponseEventType = PrivyResponseBaseEventType<'privy:iframe:ready', IframeReadyResponseDataType>;
type WalletsCreateResponseDataType = {
address: string;
};
type WalletsCreateResponseEventType = PrivyResponseBaseEventType<'privy:wallets:create', WalletsCreateResponseDataType>;
type EntropyIdVerifier = 'ethereum-address-verifier' | 'solana-address-verifier';
type UserSignerSignResponseDataType = {
/** The signature */
signature: string;
};
type UserSignerSignResponseEventType = PrivyResponseBaseEventType<'privy:user-signer:sign', UserSignerSignResponseDataType>;
type WalletsAddResponseDataType = {
address: string;
};
type WalletsAddResponseEventType = PrivyResponseBaseEventType<'privy:wallets:add', WalletsAddResponseDataType>;
type WalletsSetRecoveryBaseRequestDataType = BaseWalletsRequestData & {
/**
* Key with which to look up the existing entropy
*/
entropyId: string;
/**
* Source of the `entropyId` property. This field determines how the entropyId will
* be used. Possible values include:
* - ethereum-address-verifier: the entropyId is the address of the Ethereum wallet derived
* at index 0 for this entropy
* - solana-address-verifier: the entropyId is a the address of the Solana wallet derived
* at index 0 for this entropy
*
* When this field is a wallet address, we can verify reconstitution was successful by
* deriving the specified wallet and comparing the address to the `entropyId`
*/
entropyIdVerifier: EntropyIdVerifier;
existingRecoveryMethod?: EmbeddedWalletRecoveryOptions;
};
type WalletsSetRecoveryPasswordDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'user-passcode';
recoveryPassword: string;
};
type WalletsSetRecoveryGoogleDriveDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'google-drive';
recoveryAccessToken: string;
};
type WalletsSetRecoveryICloudDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'icloud';
recoveryAccessToken: string;
};
type WalletsSetRecoveryICloudNativeDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'icloud-native';
recoverySecretOverride: string;
iCloudRecordNameOverride: string;
};
type WalletsRecoveryEncyrptionKeyDataType = WalletsSetRecoveryBaseRequestDataType & {
recoveryMethod: 'recovery-encryption-key';
recoveryKey: string;
};
type WalletsSetRecoveryRequestDataType = Omit<WalletsSetRecoveryPasswordDataType, 'chainType'> | Omit<WalletsSetRecoveryGoogleDriveDataType, 'chainType'> | Omit<WalletsSetRecoveryICloudDataType, 'chainType'> | Omit<WalletsSetRecoveryICloudNativeDataType, 'chainType'> | Omit<WalletsRecoveryEncyrptionKeyDataType, 'chainType'>;
type WalletsSetRecoveryResponseDataType = {
entropyId: string;
entropyIdVerifier: EntropyIdVerifier;
recoveryMethod: WalletsSetRecoveryRequestDataType['recoveryMethod'];
};
type WalletsSetRecoveryResponseEventType = PrivyResponseBaseEventType<'privy:wallets:set-recovery', WalletsSetRecoveryResponseDataType>;
type WalletsConnectResponseDataType = {
entropyId: string;
};
type WalletsConnectResponseEventType = PrivyResponseBaseEventType<'privy:wallets:connect', WalletsConnectResponseDataType>;
type WalletsRecoverResponseDataType = {
entropyId: string;
};
type WalletsRecoverResponseEventType = PrivyResponseBaseEventType<'privy:wallets:recover', WalletsRecoverResponseDataType>;
type WalletsRpcEthereumResponseDataType = {
chainType: 'ethereum';
response: RpcResponseType;
};
type WalletsRpcSolanaResponseDataType = {
chainType: 'solana';
response: SolanaRpcResponseType;
};
type WalletsRpcBitcoinResponseDataType = {
chainType: 'bitcoin-taproot' | 'bitcoin-segwit';
response: BitcoinRpcResponseType;
};
type WalletsRpcResponseDataType = {
address: string;
} & (WalletsRpcEthereumResponseDataType | WalletsRpcSolanaResponseDataType | WalletsRpcBitcoinResponseDataType);
type WalletsRpcResponseEventType = PrivyResponseBaseEventType<'privy:wallets:rpc', WalletsRpcResponseDataType>;
type WalletCreateResponseDataType = {
address: string;
};
type WalletCreateResponseEventType = PrivyResponseBaseEventType<'privy:wallet:create', WalletCreateResponseDataType>;
type WalletConnectResponseDataType = {
address: string;
};
type WalletConnectResponseEventType = PrivyResponseBaseEventType<'privy:wallet:connect', WalletConnectResponseDataType>;
type WalletRecoverResponseDataType = {
address: string;
};
type WalletRecoverResponseEventType = PrivyResponseBaseEventType<'privy:wallet:recover', WalletRecoverResponseDataType>;
type WalletRpcResponseDataType = {
address: string;
response: RpcResponseType;
};
type WalletRpcResponseEventType = PrivyResponseBaseEventType<'privy:wallet:rpc', WalletRpcResponseDataType>;
type SolanaWalletCreateResponseDataType = {
publicKey: string;
};
type SolanaWalletCreateResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:create', SolanaWalletCreateResponseDataType>;
type SolanaWalletCreateAdditionalResponseDataType = {
publicKey: string;
};
type SolanaWalletCreateAdditionalResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:create-additional', SolanaWalletCreateAdditionalResponseDataType>;
type SolanaWalletConnectResponseDataType = {
publicKey: string;
};
type SolanaWalletConnectResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:connect', SolanaWalletConnectResponseDataType>;
type SolanaWalletRecoverResponseDataType = {
publicKey: string;
};
type SolanaWalletRecoverResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:recover', SolanaWalletRecoverResponseDataType>;
type SolanaWalletRpcResponseDataType = {
publicKey: string;
response: SolanaRpcResponseType;
};
type SolanaWalletRpcResponseEventType = PrivyResponseBaseEventType<'privy:solana-wallet:rpc', SolanaWalletRpcResponseDataType>;
type RootWalletForDelegation = {
/** Address of the root wallet for the entropy being delegated. */
address: string;
/** Chain type of the root wallet for the entropy being delegated. */
chainType: 'ethereum' | 'solana';
/** Whether or not the root wallet for the entropy being delegated is imported. */
imported: boolean;
};
type DelegatedWallet = {
/** Address for a wallet to delegate. */
address: string;
/** Chain type for a wallet to delegate. */
chainType: 'ethereum' | 'solana';
/** HD index for the wallet to delegate. */
walletIndex: number;
};
type DelegatedActionsConsentResponseDataType = {
success: boolean;
};
type DelegatedActionsConsentResponseEventType = PrivyResponseBaseEventType<'privy:delegated-actions:consent', DelegatedActionsConsentResponseDataType>;
type MfaVerifyResponseDataType = Record<string, never>;
type MfaVerifyResponseEventType = PrivyResponseBaseEventType<'privy:mfa:verify', MfaVerifyResponseDataType>;
type MfaInitEnrollmentResponseDataType = {
method: string;
secret?: string;
authUrl?: string;
};
type MfaInitEnrollmentResponseEventType = PrivyResponseBaseEventType<'privy:mfa:init-enrollment', MfaInitEnrollmentResponseDataType>;
type MfaSubmitEnrollmentResponseDataType = Record<string, never>;
type MfaSubmitEnrollmentResponseEventType = PrivyResponseBaseEventType<'privy:mfa:submit-enrollment', MfaSubmitEnrollmentResponseDataType>;
type MfaUnenrollResponseDataType = Record<string, never>;
type MfaUnenrollResponseEventType = PrivyResponseBaseEventType<'privy:mfa:unenroll', MfaUnenrollResponseDataType>;
type MfaClearResponseDataType = Record<string, never>;
type MfaClearResponseEventType = PrivyResponseBaseEventType<'privy:mfa:clear', MfaClearResponseDataType>;
type UnlinkPasskeyResponseDataType = Record<string, never>;
type UnlinkPasskeyResponseEventType = PrivyResponseBaseEventType<'privy:auth:unlink-passkey', UnlinkPasskeyResponseDataType>;
type PrivyResponseDataType = IframeReadyResponseDataType | UserSignerSignResponseDataType | WalletsCreateResponseDataType | WalletsAddResponseDataType | WalletsSetRecoveryResponseDataType | WalletsConnectResponseDataType | WalletsRecoverResponseDataType | WalletsRpcResponseDataType | WalletCreateResponseDataType | WalletConnectResponseDataType | WalletRecoverResponseDataType | WalletRpcResponseDataType | SolanaWalletCreateResponseDataType | SolanaWalletConnectResponseDataType | SolanaWalletRecoverResponseDataType | SolanaWalletRpcResponseDataType | DelegatedActionsConsentResponseDataType | MfaVerifyResponseDataType | MfaInitEnrollmentResponseDataType | MfaSubmitEnrollmentResponseDataType | MfaUnenrollResponseDataType | MfaClearResponseDataType | UnlinkPasskeyResponseDataType;
declare const PrivyIframeErrorTypes: readonly ['error', 'invalid_request_arguments', 'wallet_not_on_device', 'invalid_recovery_pin', 'insufficient_funds', 'mfa_timeout', 'missing_or_invalid_mfa', 'mfa_verification_max_attempts_reached'];
type PrivyIframeErrorTypesType = (typeof PrivyIframeErrorTypes)[number];
type PrivyErrorResponseEventType = PrivyResponseBaseEventType<PrivyEventType, PrivyResponseDataType> & {
error: {
type: PrivyIframeErrorTypesType;
message: string;
};
};
type PrivyResponseEvent = IframeReadyResponseEventType | PrivyErrorResponseEventType | UserSignerSignResponseEventType | WalletsCreateResponseEventType | WalletsAddResponseEventType | WalletsSetRecoveryResponseEventType | WalletsConnectResponseEventType | WalletsRecoverResponseEventType | WalletsRpcResponseEventType | WalletCreateResponseEventType | WalletConnectResponseEventType | WalletRecoverResponseEventType | WalletRpcResponseEventType | SolanaWalletCreateResponseEventType | SolanaWalletCreateAdditionalResponseEventType | SolanaWalletConnectResponseEventType | SolanaWalletRecoverResponseEventType | SolanaWalletRpcResponseEventType | DelegatedActionsConsentResponseEventType | MfaVerifyResponseEventType | MfaInitEnrollmentResponseEventType | MfaSubmitEnrollmentResponseEventType | MfaUnenrollResponseEventType | MfaClearResponseEventType | UnlinkPasskeyResponseEventType;
type EmbeddedWalletMessagePoster = {
postMessage: (message: any, targetOrigin: string, transfer?: Transferable) => void;
reload: () => void;
};
type PreparedTransactionRequestEIP1559 = UnsignedTransactionRequest & {
from: string;
to: string;
nonce: Quantity;
chainId: number;
gasLimit: Quantity;
type: 2;
maxFeePerGas: Quantity;
};
type PreparedTransactionRequestLegacy = UnsignedTransactionRequest & {
from: string;
to: string;
nonce: Quantity;
chainId: number;
gasLimit: Quantity;
type: 0 | 1;
gasPrice: Quantity;
};
type PreparedTransactionRequestTempo = UnsignedTransactionRequest & {
from: string;
chainId: number;
type: 118;
calls: Array<{
to: string;
data?: string;
value?: Quantity;
}>;
};
type PreparedTransactionRequest = PreparedTransactionRequestEIP1559 | PreparedTransactionRequestLegacy | PreparedTransactionRequestTempo;
//#endregion
//#region src/storage/Storage.d.ts
interface Storage {
get(key: string): unknown | Promise<unknown>;
put(key: string, value: unknown): void | Promise<void>;
del(key: string): void | Promise<void>;
getKeys(): string[] | Promise<string[]>;
}
//#endregion
//#region src/utils/NonEmptyArray.d.ts
type NonEmptyArray<T> = [T, ...T[]];
//#endregion
//#region src/client/AppApi.d.ts
declare class AppApi {
private _smartWalletConfig;
getConfig(): import("@privy-io/api-types").AppResponse | undefined;
getSmartWalletConfig(): Promise<SmartWalletConfiguration>;
get appId(): string;
}
//#endregion
//#region src/client/CrossAppApi.d.ts
declare class CrossAppApi {
/** Defines the format of the storage key for provider access tokens */
private static providerAccessTokenStorageKey;
/**
* Updates the stored token information of a given cross-app provider.
* @param providerAppId the Privy app ID to which the oauth tokens correspond.
* @param tokens should be the result of cross app authentication (be it login or linking).
*/
updateOnCrossAppAuthentication(providerAppId: string, tokens: OAuthTokens): Promise<void>;
/**
* Returns the last known access token for a given cross-app provider.
* @param providerAppId the Privy app ID on which you want to act.
*/
getProviderAccessToken(providerAppId: string): Promise<string | null>;
/**
* Fetches the metadata of all cross-app connections for the current app.
*/
getCrossAppConnections(): Promise<import("@privy-io/api-types").CrossAppConnectionsResponse>;
}
//#endregion
//#region src/client/DelegatedWalletsApi.d.ts
declare class DelegatedWalletsApi {
/**
* Revokes delegation permission of all the wallets associated with the user.
*/
revoke(): Promise<void>;
}
//#endregion
//#region src/embedded/EmbeddedSolanaWalletProvider.d.ts
type SignMessageRequestArguments = {
method: 'signMessage';
params: {
message: string;
};
};
type SignAndSendTransactionRequestArguments = {
method: 'signAndSendTransaction';
params: {
transaction: Transaction | VersionedTransaction;
connection: Connection;
options?: SendOptions;
};
};
type SignTransactionRequestArguments<T extends Transaction | VersionedTransaction = Transaction> = {
method: 'signTransaction';
params: {
transaction: T;
};
};
/**
* Privy embedded wallet provider for Solana accounts.
*
* Currently only supports signing messages.
*/
declare class EmbeddedSolanaWalletProvider {
request(request: SignMessageRequestArguments): Promise<{
signature: string;
}>;
request(request: SignAndSendTransactionRequestArguments): Promise<{
signature: string;
}>;
request<T extends Transaction | VersionedTransaction>(request: SignTransactionRequestArguments<T>): Promise<{
signedTransaction: T;
}>;
/**
* Legacy API for reading the public key for this provider.
*
* @deprecated
*/
get _publicKey(): string;
private connectAndRecover;
private signMessageRpc;
private handleIFrameRpc;
private handleSignAndSendTransaction;
private handleSignTransaction;
/**
* Pretty log output for when an instance of this class is `console.log`'d
*/
toJSON(): string;
}
//#endregion
//#region src/embedded/EmbeddedBitcoinWalletProvider.d.ts
/**
* Privy embedded wallet provider for Bitcoin accounts.
*
* Currently only supports signing messages.
*/
declare class EmbeddedBitcoinWalletProvider {
/**
* Sign an arbitrary message
*
* @param o the input object
* @param o.message a byte array to sign
*
* @returns a base64-endoed signature
*/
sign({ message }: {
message: Uint8Array;
}): Promise<{
signature: string;
}>;
/**
* Sign an encoded transaction
*
* @param o the input object
* @param o.txPSBT a bitcoin transaction in PSBT format, hex-encoded
*
* @returns a hex-encoded signed transaction
*/
signTransaction({ psbt }: {
psbt: string;
}): Promise<{
signedTransaction: string;
}>;
private request;
private handleIFrameRpc;
/**
* Pretty log output for when an instance of this class is `console.log`'d
*/
toJSON(): string;
}
//#endregion
//#region src/client/EmbeddedWalletApi.d.ts
/** Options for creating the Solana embedded wallet */
type CreateSolanaOpts = {
/**
* The user's existing Ethereum embedded wallet if they have one. This parameter
* MUST be set if the user has an Ethereum embedded wallet, otherwise Solana creation
* will fail in the iframe.
*/
ethereumAccount?: LinkedAccountEthereumEmbeddedWallet;
/** Optional idempotency key for automatic wallet creation */
idempotencyKey?: string;
};
declare class EmbeddedWalletApi {
/**
* @experimental
* Sign a message with the user's signer.
*
* @param o input options
* @param o.message the base64 encoded message to sign
*
* @returns an object containing the base64 encoded message signature
*/
signWithUserSigner(opts: {
message: string;
}): Promise<{
signature: string;
}>;
/**
* Add a new embedded wallet account.
*
* Requires that the user already have created an embedded wallet via `create`.
*
* @param o input options
* @param o.chainType the type of wallet to create
* @param o.hdWalletIndex the index of the wallet to create
* @param o.entropyId the key used to look up the existing wallet
* @param o.entropyIdVerifier the method used to verify the entropy ID
*
* @returns the updated user
*/
add(opts: {
chainType: ChainType;
hdWalletIndex: number;
entropyId: string;
entropyIdVerifier: EntropyIdVerifier;
}): Promise<{
user: import("@privy-io/api-types").User;
}>;
getBitcoinProvider({ wallet, entropyId, entropyIdVerifier, recoveryPassword, recoveryAccessToken, recoverySecretOverride }: {
wallet: LinkedAccountBitcoinSegwitEmbeddedWallet | LinkedAccountBitcoinTaprootEmbeddedWallet;
entropyId: string;
entropyIdVerifier: EntropyIdVerifier;
recoveryPassword?: string;
recoveryAccessToken?: string;
recoverySecretOverride?: string;
}): Promise<EmbeddedBitcoinWalletProvider>;
/**
* Creates an embedded wallet
*
* @param password Recovery password for the embedded wallet
* @param recoveryMethod recovery method to create the wallet with
* @param recoveryToken access token for recovery
* @param recoverySecretOverride override for the recovery secret used to encrypt the recovery shares
* @param iCloudRecordNameOverride override for the icloud record name where the recovery secret is stored in cloud recovery
* @param solanaAccount The user's existing Solana embedded wallet if they have one. This parameter
* MUST be set if the user has an Solana embedded wallet, otherwise Ethereum creation
* will fail in the iframe.
* @param skipCallbacks whether or not to skip user update callbacks when refreshing the user object
*
* @returns the updated user
*/
create({ password, recoveryMethod, recoveryToken, recoveryKey, recoverySecretOverride, iCloudRecordNameOverride, solanaAccount, skipCallbacks, idempotencyKey }: {
password?: string;
recoveryMethod?: IEmbeddedWalletRecoveryOptions;
recoveryToken?: string;
recoveryKey?: string;
recoverySecretOverride?: string;
iCloudRecordNameOverride?: string;
solanaAccount?: LinkedAccountSolanaEmbeddedWallet;
skipCallbacks?: boolean;
/** Optional idempotency key for automatic wallet creation */
idempotencyKey?: string;
}): Promise<Omit<AuthenticatedUser, 'session_update_action'>>;
/**
* Creates an embedded Solana wallet
*
* @param opts.ethereumAccount the user's existing embedded wallet account if they have one. This parameter
* MUST be passed if the user has an existing Ethereum embedded wallet otherwise Solana wallet creation will fail.
*
* @returns the updated user
*/
createSolana(opts?: CreateSolanaOpts): Promise<Omit<AuthenticatedUser, 'session_update_action'>>;
delegateWallets({ delegatedWallets, rootWallet }: {
delegatedWallets: DelegatedWallet[];
rootWallet: RootWalletForDelegation;
}): Promise<void>;
/**
* Retrieve this user's embedded wallet.
* If the wallet has never been used on this device recover.
*
* @param password Recovery password for the embedded wallet
* @returns EmbeddedWalletProvider implementing EIP1193Provider
*/
getProvider(wallet: LinkedAccountEthereumEmbeddedWallet, recoveryPassword?: string, recoveryAccessToken?: string, recoverySecretOverride?: string, recoveryKey?: string): Promise<EmbeddedWalletProvider>;
/**
* Load this user's embedded ethereum wallet through the given entropy.
* If the wallet has never been used on this device recover.
*
* @returns EmbeddedWalletProvider implementing EIP1193Provider
*/
getEthereumProvider({ wallet, entropyId, entropyIdVerifier, recoveryPassword, recoveryAccessToken, recoverySecretOverride, recoveryKey, onNeedsRecovery }: {
wallet: LinkedAccountEthereumEmbeddedWallet;
entropyId: string;
entropyIdVerifier: EntropyIdVerifier;
recoveryPassword?: string;
recoveryAccessToken?: string;
recoverySecretOverride?: string;
recoveryKey?: string;
/**
* A function that will get called anytime the secure context throws an error that
* indicates recover is required (i.e. on-demand recovery)
*
* @example
* const provider = await getEthereumProvider({
* onNeedsRecovery: async ({recoveryMethod, onRecovered}) => {
* await promptRecovery({recoveryMethod})
* onRecovered();
* },
* })
*/
onNeedsRecovery?: OnNeedsRecovery;
}): Promise<EmbeddedWalletProvider>;
/**
* Retrieve this users embedded Solana wallet.
* If the wallet has never been used on this device recover.
*
* @returns EmbeddedSolanaWalletProvider
*/
getSolanaProvider(account: LinkedAccountSolanaEmbeddedWallet, entropyId: string, entropyIdVerifier: EntropyIdVerifier, recoveryPassword?: string, recoveryAccessToken?: string, recoverySecretOverride?: string,
/**
* A function that will get called anytime the secure context throws an error that
* indicates recover is required (i.e. on-demand recovery)
*
* @example
* const provider = await getEthereumProvider({
* onNeedsRecovery: async ({recoveryMethod, onRecovered}) => {
* await promptRecovery({recoveryMethod})
* onRecovered();
* },
* })
*/
onNeedsRecovery?: OnNeedsRecovery): Promise<EmbeddedSolanaWalletProvider>;
/**
* Add or change the recovery method used to recover an embedded wallet.
*
* @param password New recovery password
* @param currentPassword Current recovery password used to recover the embedded wallet
* @returns User the user object with the updated embedded wallet.
* @returns EmbeddedWalletProvider implementing EIP1193Provider if the input wallet is an Ethereum wallet.
*/
setRecovery(setRecoveryInput: SetRecoveryInput): Promise<SetRecoveryOutput>;
/**
* @returns URL to load in the embedded wallet iframe
*/
getURL(): string;
/**
* @deprecated Require higher level SDKs to pass in the chain configuration
*/
get chains(): NonEmptyArray<Chain>;
/**
* Handles messages from the embedded wallet secure contexts
*
* @example
* const onMessage = async (e: WebViewMessageEvent) => {
* const {data} = e.nativeEvent;
* client.embeddedWallet.onMessage(JSON.parse(data));
* }
*/
onMessage(event: PrivyResponseEvent): void;
reload(): void;
/** Call when the app backgrounds. The next operation will re-verify WebView responsiveness before proceeding. */
onBackground(): void;
ping(timeoutMs: number): Promise<boolean>;
}
//#endregion
//#region src/client/MfaPromises.d.ts
declare class MfaPromises extends EventEmitter<{
mfaRequired: [];
}> {
/**
* This is the root promise for MFA flows. It is resolved or rejected when MFA is complete.
*/
readonly rootPromise: MfaPromise;
/**
* This is the promise for MFA attempts. It is resolved or rejected for every attempt to verify MFA.
*/
readonly submitPromise: MfaSubmitPromise;
}
//#endregion
//#region src/client/UserApi.d.ts
declare class UserApi {
private readonly _embedded;
private readonly _isMultiUserModeEnabled;
/**
* Get the logged in user.
*/
get(): Promise<{
user: import("@privy-io/api-types").User;
}>;
acceptTerms(): Promise<{
user: import("@privy-io/api-types").User;
}>;
/**
* @experimental
*
* Switches the active user to a saved local session and refreshes that user.
*/
switchActiveUser(o: {
userId: string;
}): Promise<{
user: import("@privy-io/api-types").User;
}>;
}
//#endregion
//#region src/config/types.d.ts
type CreateOnLogin = 'off' | 'users-without-wallets' | 'all-users';
type EmbeddedWalletConfig = {
createOnLogin: CreateOnLogin;
};
type LoginOptions = {
embedded?: {
ethereum?: EmbeddedWalletConfig;
solana?: EmbeddedWalletConfig;
};
};
//#endregion
//#region src/client/auth/CustomProviderApi.d.ts
declare class CustomProviderApi {
/**
* Logs a user in via a custom JWT from another (non-Privy) service
*
* @param token The JWT from the non-Privy service
*/
syncWithToken(token: string, opts?: LoginOptions, mode?: 'login-or-sign-up' | 'no-signup'): Promise<Omit<import("@privy-io/api-types").AuthenticatedUser, "session_update_action">>;
/**
* Links a custom JWT account to an existing logged-in user
*
* @param token The JWT from the non-Privy service
*/
linkWithToken(token: string): Promise<{
user: import("@privy-io/api-types").User;
identity_token: string | undefined;
}>;
}
//#endregion
//#region src/client/auth/EmailApi.d.ts
declare class EmailApi {
/**
* Sends a one time login code to a user's email address
*
* @param email The email address to send the one time login code
* @param token A CAPTCHA token
*/
sendCode(email: string, token?: string): Promise<{
success: boolean;
}>;
/**
* Logs a user in via an email address and one time code
*
* @param email The email address that the one time code was sent to
* @param code The one time code
* @param mode Optional Whether or not to block sign ups (only allow existing users to log in).
*/
loginWithCode(email: string, code: string, mode?: 'login-or-sign-up' | 'no-signup', opts?: LoginOptions): Promise<Omit<import("@privy-io/api-types").AuthenticatedUser, "session_update_action">>;
/**
* Links an email address to an existing user
*
* @param email The email address that the one time code was sent to
* @param code The one time code
*/
linkWithCode(email: string, code: string): Promise<{
user: import("@privy-io/api-types").User;
identity_token: string | undefined;
}>;
/**
* Updates an email address on an existing user
*
* @param input.oldEmailAddress The currently linked email address, that will be removed
* @param input.newEmailAddress The email address the user will be updated to
* @param input.code The one time code received on the `newEmailAddress`
*/
updateEmail({ oldEmailAddress, newEmailAddress, code }: {
oldEmailAddress: string;
newEmailAddress: string;
code: string;
}): Promise<{
user: import("@privy-io/api-types").User;
identity_token: string | undefined;
}>;
unlink(email: string): Promise<{
user: import("@privy-io/api-types").User;
identity_token: string | undefined;
}>;
}
//#endregion
//#region src/client/auth/FarcasterApi.d.ts
declare class FarcasterApi {
/**
* Begin a login / link flow with a farcaster.
*/
initializeAuth({ relyingParty, redirectUrl, token }: {
relyingParty?: string;
redirectUrl?: string;
token?: string;
}): Promise<import("@privy-io/api-types").FarcasterConnectInitResponseBody>;
/**
* Get the status of a user's SIWF request.
*/
getFarcasterStatus({ channel_token }: {
channel_token: string;
}): Promise<NonNullable<import("@privy-io/api-types").FarcasterConnectStatusCompletedResponseBody | import("@privy-io/api-types").FarcasterConnectStatusPendingResponseBody | undefined>>;
/**
* Authenticate with Privy via the Sign-In With Farcaster spec [FIP-11: Sign in with Farcaster](https://github.com/farcasterxyz/protocol/discussions/110).
*/
authenticate({ channel_token, message, signature, fid, mode }: {
channel_token: string;
message: string;
signature: string;
fid: number;
mode?: 'login-or-sign-up' | 'no-signup';
}, opts?: LoginOptions): Promise<Omit<import("@privy-io/api-types").AuthenticatedUser, "session_update_action">>;
/**
* Link with Privy via the Sign-In With Farcaster spec [FIP-11: Sign in with Farcaster](https://github.com/farcasterxyz/protocol/discussions/110).
*/
link({ channel_token, message, signature, fid }: {
channel_token: string;
message: string;
signature: string;
fid: number;
}): Promise<{
user: import("@privy-io/api-types").User;
identity_token: string | undefined;
}>;
/**
* Unlink with Privy via the Sign-In With Farcaster spec.
*/
unlink({ fid }: {
fid: number;
}): Promise<{
user: import("@privy-io/api-types").User;
identity_token: string | undefined;
}>;
}
//#endregion
//#region src/client/auth/FarcasterV2Api.d.ts
declare class FarcasterV2Api {
/**
* Begin a login / link flow with a farcaster.
*/
initializeAuth(): Promise<import("@privy-io/api-types").FarcasterV2InitResponseBody>;
/**
* Authenticate