@privy-io/js-sdk-core 0.28.0 → 0.28.1

package/dist/dts/embedded/types.d.mts

@@ -0,0 +1,385 @@
+/**
+ * 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.
+ */
+import type { TypedMessage, MessageTypes } from '@metamask/eth-sig-util';
+import type { PrivyEthereumEmbeddedWalletAccount } from '@privy-io/public-api';
+export declare const SUPPORTED_JSON_RPC_METHODS: readonly ["eth_sign", "eth_populateTransactionRequest", "eth_signTransaction", "personal_sign", "eth_signTypedData_v4"];
+export type JsonRpcMethodType = (typeof SUPPORTED_JSON_RPC_METHODS)[number];
+export declare const isSupportedRpcMethod: (method: any) => method is JsonRpcMethodType;
+export type Quantity = string | number | bigint;
+export 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;
+};
+/**
+ * {@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`
+ */
+export type UnsignedTransactionRequestWithChainId = UnsignedTransactionRequest & {
+    chainId: number;
+};
+export type TransactionLog = {
+    blockNumber: number;
+    blockHash: string;
+    transactionIndex: number;
+    removed: boolean;
+    address: string;
+    data: string;
+    topics: Array<string>;
+    transactionHash: string;
+    logIndex: number;
+};
+export type TransactionReceipt = {
+    to: string;
+    from: string;
+    contractAddress: string;
+    transactionIndex: number;
+    root?: string;
+    logs: Array<TransactionLog>;
+    logsBloom: string;
+    blockHash: string;
+    transactionHash: string;
+    blockNumber: number;
+    confirmations: number;
+    byzantium: boolean;
+    type: number;
+    status?: number;
+    gasUsed: string;
+    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;
+}
+interface eth_sendTransaction {
+    method: 'eth_sendTransaction';
+    data: string;
+}
+interface eth_signTypedData_v4 extends BaseRpcRequestType {
+    method: 'eth_signTypedData_v4';
+    params: [string, TypedMessage<MessageTypes> | string];
+}
+interface eth_signTypedData_v4Response {
+    method: 'eth_signTypedData_v4';
+    data: string;
+}
+export type RpcRequestType = eth_sendTransaction | eth_signTransaction | eth_populateTransactionRequest | eth_sign | personal_sign | eth_signTypedData_v4;
+export type RpcResponseType = eth_signTransactionResponse | eth_populateTransactionRequestResponse | eth_signResponse | personal_signResponse | eth_signTypedData_v4Response;
+declare const SUPPORTED_SOLANA_RPC_METHODS: readonly ["signMessage"];
+type SolanaRpcMethodType = (typeof SUPPORTED_SOLANA_RPC_METHODS)[number];
+export declare const isSupportedSolanaRpcMethod: (method: any) => method is SolanaRpcMethodType;
+export interface BaseSolanaRpcRequestType {
+    method: SolanaRpcMethodType;
+    params: any;
+}
+export interface SolanaRpcRequestType extends BaseSolanaRpcRequestType {
+    method: 'signMessage';
+    params: {
+        message: string;
+    };
+}
+export interface SolanaRpcResponseType {
+    data: {
+        signature: string;
+    };
+}
+export type PrivyEventType = 'privy:iframe:ready' | 'privy:wallet:create' | 'privy:wallet:connect' | 'privy:wallet:recover' | 'privy:wallet:rpc' | 'privy:wallet:set-recovery' | 'privy:solana-wallet:create' | 'privy:solana-wallet:connect' | 'privy:solana-wallet:recover' | 'privy:solana-wallet:rpc';
+export type IEmbeddedWalletRecoveryOptions = 'privy' | 'user-passcode' | 'google-drive' | 'icloud' | 'icloud-native';
+export type IUserRecoveryMethod = 'user-passcode' | 'google-drive' | 'icloud' | 'icloud-native';
+export type EmbeddedWalletRecoveryOptions = 'privy' | 'user-passcode' | 'google-drive' | 'icloud';
+export type PasswordRecoveryInput = {
+    recoveryMethod: 'user-passcode';
+    password: string;
+};
+export type CloudRecoveryInput = {
+    recoveryMethod: 'google-drive' | 'icloud';
+    recoveryAccessToken: string;
+};
+export type ICloudNativeRecoveryInput = {
+    recoveryMethod: 'icloud-native';
+    recoverySecretOverride: string;
+    iCloudRecordNameOverride: string;
+};
+export type SetRecoveryInput = {
+    wallet: PrivyEthereumEmbeddedWalletAccount;
+} & (PasswordRecoveryInput | CloudRecoveryInput | ICloudNativeRecoveryInput | PrivyRecoveryInput);
+export type IframeReadyRequestDataType = Record<string, never>;
+export type WalletCreateRequestDataType = {
+    accessToken: string;
+    recoveryPassword?: string;
+    recoveryMethod?: IEmbeddedWalletRecoveryOptions;
+    recoveryAccessToken?: string;
+    recoverySecretOverride?: string;
+    iCloudRecordNameOverride?: string;
+};
+export type WalletConnectRequestDataType = {
+    accessToken: string;
+    address: string;
+};
+export type WalletRecoverRequestDataType = {
+    accessToken: string;
+    address: string;
+    recoveryPassword?: string;
+    recoveryMethod?: string;
+    recoveryAccessToken?: string;
+    recoverySecretOverride?: string;
+};
+export type WalletSetRecoveryRequestDataType = {
+    accessToken: string;
+    address: string;
+    recoveryMethod: IUserRecoveryMethod;
+    recoveryPassword?: string;
+    recoveryAccessToken?: string;
+    recoverySecretOverride?: string;
+    iCloudRecordNameOverride?: string;
+};
+export type WalletRpcRequestDataType = {
+    accessToken: string;
+    address: string;
+    request: RpcRequestType;
+};
+export type SolanaWalletCreateRequestDataType = {
+    accessToken: string;
+    /**
+     * The user's existing Ethereum embedded wallet address if they have one. This parameter must be passed
+     * if the user has an Ethereum embedded wallet, otherwise Solana wallet creation will fail.
+     */
+    ethereumAddress?: string;
+};
+export type SolanaWalletConnectRequestDataType = {
+    accessToken: string;
+    publicKey: string;
+};
+export type SolanaWalletRecoverRequestDataType = {
+    accessToken: string;
+    publicKey: string;
+};
+export type SolanaWalletRpcRequestDataType = {
+    accessToken: string;
+    publicKey: string;
+    request: SolanaRpcRequestType;
+};
+export type PrivyRequestDataType = IframeReadyRequestDataType | WalletCreateRequestDataType | WalletConnectRequestDataType | WalletRecoverRequestDataType | WalletRpcRequestDataType | SolanaWalletCreateRequestDataType | SolanaWalletRecoverRequestDataType | SolanaWalletConnectRequestDataType | SolanaWalletRpcRequestDataType;
+export type PrivyErrorResponseDataType = {
+    error: Error;
+};
+export type IframeReadyResponseDataType = Record<string, never>;
+export type WalletCreateResponseDataType = {
+    address: string;
+};
+export type WalletConnectResponseDataType = {
+    address: string;
+};
+export type WalletRecoverResponseDataType = {
+    address: string;
+};
+export type WalletSetRecoveryResponseDataType = {
+    address: string;
+};
+export type WalletRpcResponseDataType = {
+    address: string;
+    response: RpcResponseType;
+};
+export type SolanaWalletCreateResponseDataType = {
+    publicKey: string;
+};
+export type SolanaWalletConnectResponseDataType = {
+    publicKey: string;
+};
+export type SolanaWalletRecoverResponseDataType = {
+    publicKey: string;
+};
+export type SolanaWalletSetRecoveryPasswordResponseDataType = {
+    publicKey: string;
+};
+export type SolanaWalletRpcResponseDataType = {
+    publicKey: string;
+    response: SolanaRpcResponseType;
+};
+export type PrivyResponseDataType = IframeReadyResponseDataType | WalletCreateResponseDataType | WalletConnectResponseDataType | WalletRecoverResponseDataType | WalletSetRecoveryResponseDataType | WalletRpcResponseDataType | SolanaWalletCreateResponseDataType | SolanaWalletConnectResponseDataType | SolanaWalletRecoverResponseDataType | SolanaWalletRpcResponseDataType;
+export declare const PrivyIframeErrorTypes: readonly ["error", "invalid_request_arguments", "wallet_not_on_device", "invalid_recovery_pin", "insufficient_funds"];
+export type PrivyIframeErrorTypesType = (typeof PrivyIframeErrorTypes)[number];
+interface PrivyResponseBaseEventType {
+    id: string;
+    event: PrivyEventType;
+}
+export interface PrivyErrorResponseEventType extends PrivyResponseBaseEventType {
+    error: {
+        type: PrivyIframeErrorTypesType;
+        message: string;
+    };
+}
+interface IframeReadyResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:iframe:ready';
+    data: IframeReadyResponseDataType;
+}
+interface WalletCreateResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:wallet:create';
+    data: WalletCreateResponseDataType;
+}
+interface WalletConnectResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:wallet:connect';
+    data: WalletConnectResponseDataType;
+}
+interface WalletRecoverResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:wallet:recover';
+    data: WalletRecoverResponseDataType;
+}
+interface WalletSetRecoveryResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:wallet:set-recovery';
+    data: WalletSetRecoveryResponseDataType;
+}
+interface WalletRpcResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:wallet:rpc';
+    data: WalletRpcResponseDataType;
+}
+interface SolanaWalletCreateResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:solana-wallet:create';
+    data: SolanaWalletCreateResponseDataType;
+}
+interface SolanaWalletConnectResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:solana-wallet:connect';
+    data: SolanaWalletConnectResponseDataType;
+}
+interface SolanaWalletRecoverResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:solana-wallet:recover';
+    data: SolanaWalletRecoverResponseDataType;
+}
+interface SolanaWalletRpcResponseEventType extends PrivyResponseBaseEventType {
+    event: 'privy:solana-wallet:rpc';
+    data: SolanaWalletRpcResponseDataType;
+}
+export type PrivyResponseEvent = IframeReadyResponseEventType | PrivyErrorResponseEventType | WalletCreateResponseEventType | WalletConnectResponseEventType | WalletRecoverResponseEventType | WalletSetRecoveryResponseEventType | WalletRpcResponseEventType | SolanaWalletCreateResponseEventType | SolanaWalletConnectResponseEventType | SolanaWalletRecoverResponseEventType | SolanaWalletRpcResponseEventType;
+export type IframeReadyResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: IframeReadyResponseDataType) => void;
+};
+export type WalletCreateResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: WalletCreateResponseDataType) => void;
+};
+export type WalletConnectResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: WalletConnectResponseDataType) => void;
+};
+export type WalletRecoverResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: WalletRecoverResponseDataType) => void;
+};
+export type WalletSetRecoveryResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: WalletSetRecoveryResponseDataType) => void;
+};
+export type WalletRpcResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: WalletRpcResponseDataType) => void;
+};
+export type SolanaWalletCreateResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: SolanaWalletCreateResponseDataType) => void;
+};
+export type SolanaWalletConnectResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: SolanaWalletConnectResponseDataType) => void;
+};
+export type SolanaWalletRecoverResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: SolanaWalletRecoverResponseDataType) => void;
+};
+export type SolanaWalletRpcResponseCallbacksType = {
+    reject: (error: Error) => void;
+    resolve: (res: SolanaWalletRpcResponseDataType) => void;
+};
+export type PrivyResponseCallbacksType = IframeReadyResponseCallbacksType | WalletCreateResponseCallbacksType | WalletConnectResponseCallbacksType | WalletRecoverResponseCallbacksType | WalletSetRecoveryResponseCallbacksType | WalletRpcResponseCallbacksType | SolanaWalletCreateResponseCallbacksType | SolanaWalletConnectResponseCallbacksType | SolanaWalletRecoverResponseCallbacksType | SolanaWalletRpcResponseCallbacksType;
+export interface EmbeddedWalletProxy {
+    create: (data: WalletCreateRequestDataType) => Promise<WalletCreateResponseDataType>;
+    connect: (data: WalletConnectRequestDataType) => Promise<WalletConnectResponseDataType>;
+    recover: (data: WalletRecoverRequestDataType) => Promise<WalletRecoverResponseDataType>;
+    rpc: (data: WalletRpcRequestDataType) => Promise<WalletRpcResponseDataType>;
+    createSolana: (data: WalletCreateRequestDataType) => Promise<SolanaWalletCreateResponseDataType>;
+    connectSolana: (data: WalletConnectRequestDataType) => Promise<SolanaWalletConnectResponseDataType>;
+    recoverSolana: (data: WalletRecoverRequestDataType) => Promise<SolanaWalletRecoverResponseDataType>;
+    rpcSolana: (data: WalletRpcRequestDataType) => Promise<SolanaWalletRpcResponseDataType>;
+}
+export type EmbeddedWalletMessagePoster = {
+    postMessage: (message: any, targetOrigin: string, transfer?: Transferable) => void;
+};
+export type PreparedTransactionRequestEIP1559 = UnsignedTransactionRequest & {
+    from: string;
+    to: string;
+    nonce: Quantity;
+    chainId: number;
+    gasLimit: Quantity;
+    type: 2;
+    maxFeePerGas: Quantity;
+};
+export type PreparedTransactionRequestLegacy = UnsignedTransactionRequest & {
+    from: string;
+    to: string;
+    nonce: Quantity;
+    chainId: number;
+    gasLimit: Quantity;
+    type: 0 | 1;
+    gasPrice: Quantity;
+};
+export type PreparedTransactionRequest = PreparedTransactionRequestEIP1559 | PreparedTransactionRequestLegacy;
+export {};

package/dist/dts/embedded/utils/ethers.d.mts

@@ -0,0 +1,7 @@
+import type { BigNumberish } from '@ethersproject/bignumber';
+import { BigNumber } from '@ethersproject/bignumber';
+import type { UnsignedTransaction as EthersUnsignedTransaction } from '@ethersproject/transactions';
+import type { Quantity, UnsignedTransactionRequest } from '../types';
+export declare const QuantityToBigNumber: (quantity: Quantity) => BigNumber;
+export declare function convertBigNumberish(value: BigNumberish): string | number | bigint;
+export declare function toEthersUnsignedTransaction(txRequest: UnsignedTransactionRequest): EthersUnsignedTransaction;

package/dist/dts/embedded/utils/gas.d.mts

@@ -0,0 +1,45 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import type { StaticJsonRpcProvider } from '@ethersproject/providers';
+import type { Quantity, UnsignedTransactionRequestWithChainId } from '../types';
+/**
+ * Defaults the gas parameters for a "generic chain" that we do not have special handling for. This is anything
+ * not in the Polygon, OP Stack, Arbitrum, or BSC families of chains.
+ *
+ * Pre-condition: `from`, `to`, `nonce`, and `gasLimit` are already set
+ *
+ * Post-conditions:
+ * - An undefined `type` gets defaulted to 2.
+ * - If the tx type is 2, we will default `maxFeePerGas` and `maxPriorityFeePerGas`.
+ * - If the tx type is 0, 1, we will default `gasPrice`.
+ *
+ * @param txRequest {UnsignedTransactionRequestWithChainId}
+ * @param provider {StaticJsonRpcProvider}
+ * @returns UnsignedTransactionRequestWithChainId with gas fees defaulted
+ */
+export declare const defaultGasForEvmChain: (txRequest: UnsignedTransactionRequestWithChainId, provider: StaticJsonRpcProvider) => Promise<UnsignedTransactionRequestWithChainId>;
+/**
+ * Calculate the total estimated gas cost from the transaction request. This method assumes
+ * the transaction has already been processed by Privy's `populateTransactionRequest` and that
+ * both a `gasLimit` and one of the `gasPrice` or `maxFeePerGas` have been set.
+ *
+ * If the transaction is on an OP Stack chain, this method will include the L1 execution fee in the returned
+ * `totalGasEstimate` and will also return the execution fee as a separate `l1ExecutionFeeEstimate`. For
+ * non-OP Stack chains, the `l1ExecutionFeeEstimate` will be 0.
+ *
+ * @param txRequest {UnsignedTransactionRequest} the transaction request for which to total estimated gas for
+ * @param provider {StaticJsonRpcProvider} ethers provider
+ * @returns the `totalGasEstimate` and `l1ExecutionFeeEstimate`
+ */
+export declare function calculateTotalGasEstimate(txRequest: UnsignedTransactionRequestWithChainId, provider: StaticJsonRpcProvider): Promise<{
+    totalGasEstimate: BigNumber;
+    l1ExecutionFeeEstimate: BigNumber;
+}>;
+/**
+ * Defaults the `gasLimit` for the transaction if not already set by calling the
+ * `eth_estimateGas` RPC for the network.
+ *
+ * @param txRequest {UnsignedTransactionRequestWithChainId}
+ * @param provider {StaticJsonRpcProvider}
+ * @returns `gasLimit` in gas units as a hexstring `Quantity`
+ */
+export declare function defaultGasLimit(txRequest: UnsignedTransactionRequestWithChainId, provider: StaticJsonRpcProvider): Promise<Quantity>;

package/dist/dts/embedded/utils/index.d.mts

@@ -0,0 +1,36 @@
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import type { Chain, RpcConfig } from '../../chains';
+import type { EmbeddedWalletRecoveryOptions, PreparedTransactionRequest, UnsignedTransactionRequest, UnsignedTransactionRequestWithChainId, IEmbeddedWalletRecoveryOptions } from '../types';
+/**
+ * Build a JSON RPC provider for a given chainId if it is one of our
+ * supported chains.
+ */
+export declare const getJsonRpcProvider: (chainId: number, chains: Chain[], rpcConfig: RpcConfig, options: {
+    appId: string;
+}) => StaticJsonRpcProvider;
+export declare function validateTransactionRequest(txRequest: UnsignedTransactionRequest): void;
+/**
+ * This method takes the `UnsignedTransactionRequestWithChainId` provided by the app
+ * and ensures that the following parameters are set, or at least defaulted by Privy;
+ * `from`, `chainId`, `nonce`, `gasLimit`, `type`, `gasPrice` OR `maxFeePerGas`.
+ * These values must be set before sending the transaction to the network.
+ *
+ * This method will NOT throw an error if the user does not have sufficient funds
+ * to cover gas costs - that must be explicitly checked elsewhere with `getAndCheckBalance`.
+ *
+ * @param address {string} wallet address sending the transaction
+ * @param txRequest {UnsignedTransactionRequestWithChainId} the transaction request from the app
+ * @param provider {StaticJsonRpcProvider} a provider connected to the chain of the transaction
+ * @returns {UnsignedTransactionRequestWithChainId} the transaction request with the necessary defaults set
+ */
+export declare function populateTransactionRequest(address: string, txRequest: UnsignedTransactionRequestWithChainId, provider: StaticJsonRpcProvider): Promise<PreparedTransactionRequest>;
+/**
+ * Ensure that the recovery upgrade path is valid.
+ *
+ * @param currentRecoveryType The existing wallet's recovery type
+ * @param upgradeToRecoveryType The desired recovery type
+ */
+export declare function throwIfInvalidRecoveryUpgradePath({ currentRecoveryMethod, upgradeToRecoveryMethod, }: {
+    currentRecoveryMethod: EmbeddedWalletRecoveryOptions;
+    upgradeToRecoveryMethod: IEmbeddedWalletRecoveryOptions;
+}): boolean;

package/dist/dts/index.d.mts

@@ -0,0 +1,16 @@
+import Privy from './Privy';
+export type { OAuthProviderType } from '@privy-io/public-api';
+export type { default as Storage } from './storage/Storage';
+export { LocalStorage } from './storage/LocalStorage';
+export { InMemoryCache } from './storage/InMemoryStorage';
+export { PrivyApiError, PrivyClientError } from './Error';
+export { PrivyEmbeddedWalletErrorCode, errorIndicatesRecoveryIsNeeded, ProviderErrors, PrivyProviderRpcError, PrivyConnectorError, EmbeddedProviderError, } from './embedded/errors';
+export { getUserEmbeddedWallet } from './utils/getUserEmbeddedWallet';
+export { getUserEmbeddedSolanaWallet } from './utils/getUserEmbeddedSolanaWallet';
+export { toObjectKeys } from './utils/toObjectKeys';
+export { populateTransactionRequest, throwIfInvalidRecoveryUpgradePath } from './embedded/utils';
+export { calculateTotalGasEstimate } from './embedded/utils/gas';
+export { QuantityToBigNumber, convertBigNumberish, toEthersUnsignedTransaction, } from './embedded/utils/ethers';
+export * from './types';
+export * from './chains';
+export default Privy;

package/dist/dts/pkce.d.mts

@@ -0,0 +1,33 @@
+/** This module is a port of the PKCE implementation in react-auth */
+import type { CryptoFns } from './crypto/types';
+export declare const STATE_CODE_KEY = "privy:state_code";
+export declare const CODE_VERIFIER_KEY = "privy:code_verifier";
+/** Web compatible method to create a hash buffer, using SHA256 */
+export declare function createHashBuffer(message: string, digest: NonNullable<CryptoFns['digest']>): Promise<Uint8Array>;
+export declare function randomBytes(size: number): Uint8Array;
+/**
+ * Create a cryptographic random string to be used as the code_verifier in PKCE.
+ *
+ * @returns a cryptographic random string to be used as a code_verifier in PKCE
+ */
+export declare function createCodeVerifier(): string;
+/**
+ * Create a state code to be used in the OAuth flow.  State code can be a random set of characers,
+ * or optionally can be used to store state information.  In either case, it is used by the client to verify
+ * that it is communicating with the same server throughout the auth process.
+ *
+ * This same implementation also exists in the backend crypto module.
+ *
+ * @returns a valid state code to be used in PKCE flow
+ */
+export declare function createStateCode(): string;
+/**
+ * Derive the code_challenge from the code verifier, using the specified method.
+ *
+ * @param codeVerifier the code_challenge derived from the provided code verifier
+ */
+export declare function deriveCodeChallengeFromCodeVerifier({ codeVerifier, method, digest, }: {
+    codeVerifier: string;
+    method?: string;
+    digest?: CryptoFns['digest'];
+}): Promise<string>;

package/dist/dts/storage/InMemoryStorage.d.mts

@@ -0,0 +1,8 @@
+import type Storage from './Storage';
+export declare class InMemoryCache implements Storage {
+    private _cache;
+    get(key: string): unknown;
+    put(key: string, val: unknown): void;
+    del(key: string): void;
+    getKeys(): string[];
+}

package/dist/dts/storage/LocalStorage.d.mts

@@ -0,0 +1,7 @@
+import type Storage from './Storage';
+export declare class LocalStorage implements Storage {
+    get(key: string): Promise<any>;
+    put(key: string, val: unknown): void;
+    del(key: string): void;
+    getKeys(): string[];
+}

package/dist/dts/storage/Storage.d.mts

@@ -0,0 +1,6 @@
+export default 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[]>;
+}

package/dist/dts/toAbortSignalTimeout.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Patch for AbortSignal.timeout since it is not supported in iOS Safari < 16
+ * Adapted from: https://github.com/mo/abortcontroller-polyfill/issues/73#issuecomment-1541180943
+ */
+declare const toAbortSignalTimeout: (duration: number) => AbortSignal;
+export default toAbortSignalTimeout;

package/dist/dts/types.d.mts

@@ -0,0 +1,54 @@
+import type { EmbeddedWalletProvider, EmbeddedSolanaWalletProvider } from './embedded';
+export type PrivyEmbeddedWalletProvider = EmbeddedWalletProvider;
+export type PrivyEmbeddedSolanaWalletProvider = EmbeddedSolanaWalletProvider;
+export type { EmbeddedWalletRecoveryOptions, SetRecoveryInput } from './embedded/types';
+export type LogLevel = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';
+declare const EMBEDDED_WALLET_CLIENT_TYPES: readonly ["privy"];
+export type EmbeddedWalletClientType = (typeof EMBEDDED_WALLET_CLIENT_TYPES)[number];
+declare const INJECTED_WALLET_CLIENT_TYPES: readonly ["metamask", "phantom", "brave_wallet", "rainbow"];
+export type InjectedWalletClientType = (typeof INJECTED_WALLET_CLIENT_TYPES)[number];
+declare const COINBASE_WALLET_CLIENT_TYPES: readonly ["coinbase_wallet"];
+export type CoinbaseWalletClientType = (typeof COINBASE_WALLET_CLIENT_TYPES)[number];
+export type WalletConnectWalletClientType = (typeof WALLET_CONNECT_WALLET_CLIENT_TYPES)[number];
+declare const UNKNOWN_WALLET_CLIENT_TYPES: readonly ["unknown"];
+export type UnknownWalletClientType = (typeof UNKNOWN_WALLET_CLIENT_TYPES)[number];
+export declare const ALL_WALLET_CLIENT_TYPES: ("unknown" | "safe" | "privy" | "metamask" | "phantom" | "brave_wallet" | "rainbow" | "coinbase_wallet" | "trust" | "uniswap" | "zerion" | "argent" | "spot" | "omni" | "cryptocom" | "blockchain" | "safepal" | "bitkeep" | "zengo" | "1inch" | "binance" | "exodus" | "mew_wallet" | "alphawallet" | "keyring_pro" | "mathwallet" | "unstoppable" | "obvious" | "ambire" | "internet_money_wallet" | "coin98" | "abc_wallet" | "arculus_wallet" | "haha" | "cling_wallet" | "broearn" | "copiosa" | "burrito_wallet" | "enjin_wallet" | "plasma_wallet" | "avacus" | "bee" | "pitaka" | "pltwallet" | "minerva" | "kryptogo" | "prema" | "slingshot" | "kriptonio" | "timeless" | "secux" | "bitizen" | "blocto" | "safemoon")[];
+export type WalletClientType = InjectedWalletClientType | CoinbaseWalletClientType | WalletConnectWalletClientType | EmbeddedWalletClientType | UnknownWalletClientType;
+export declare const SUPPORTED_CONNECTOR_TYPES: readonly ["injected", "wallet_connect", "wallet_connect_v2", "coinbase_wallet", "embedded"];
+export type ConnectorType = (typeof SUPPORTED_CONNECTOR_TYPES)[number];
+export type WalletBranding = {
+    /** The display name for the wallet. */
+    name: string;
+    /** Unique identifier for this wallet, can be RDNS or other unique data. */
+    id: string;
+    /** Wallet brand icon url. */
+    icon?: string;
+};
+export type ExternalWalletMetadata = {
+    /** The wallet name (e.g. MetaMask). */
+    name: string;
+    /** The wallet RDNS, falls back to the wallet name if none is available. */
+    id: string;
+    /** The wallet logo */
+    icon?: string;
+};
+/**
+ * Wallet to request a [Sign-In With Ethereum](https://eips.ethereum.org/EIPS/eip-4361) signature from
+ */
+export type ExternalWallet = {
+    /** [EIP-55](https://eips.ethereum.org/EIPS/eip-55) mixed-case checksum-encoded address */
+    address: string;
+    /** [EIP-155](https://eips.ethereum.org/EIPS/eip-155) Chain ID with [CAIP-2](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-2.md) formatting */
+    chainId: string;
+    /**
+     * The wallet client where this key-pair is stored.
+     * e.g. `metamask`, `rainbow`, `coinbase_wallet`, etc.
+     */
+    walletClientType?: WalletClientType;
+    /**
+     * The connector used to initiate the connection with the wallet client.
+     * e.g. `injected`, `wallet_connect`, `coinbase_wallet`, etc.
+     */
+    connectorType?: ConnectorType;
+    meta?: ExternalWalletMetadata;
+};

package/dist/dts/utils/NonEmptyArray.d.mts

@@ -0,0 +1 @@
+export type NonEmptyArray<T> = [T, ...T[]];

package/dist/dts/utils/getUserEmbeddedSolanaWallet.d.mts

@@ -0,0 +1,12 @@
+import type { PrivyUser, PrivySolanaEmbeddedWalletAccount } from '@privy-io/public-api';
+/**
+ * @description Finds the embedded Solana wallet account (if it exists) for a given user.
+ *
+ * @param user A privy user object
+ *
+ * @returns The user's embedded wallet account
+ *
+ * @example
+ * const account = getUserEmbeddedSolanaWallet(user)
+ */
+export declare const getUserEmbeddedSolanaWallet: (user: PrivyUser | null) => PrivySolanaEmbeddedWalletAccount | null;

package/dist/dts/utils/getUserEmbeddedWallet.d.mts

@@ -0,0 +1,13 @@
+import type { PrivyUser, PrivyEthereumEmbeddedWalletAccount } from '@privy-io/public-api';
+/**
+ * @description Finds the embedded wallet account (if it exists) for a given user.
+ *
+ * @param user A privy user object
+ *
+ * @returns The user's embedded wallet account
+ *
+ * @example
+ * const account = getUserEmbeddedWallet(user)
+ * console.log(account.address)
+ */
+export declare const getUserEmbeddedWallet: (user: PrivyUser | null) => PrivyEthereumEmbeddedWalletAccount | null;

package/dist/dts/utils/toObjectKeys.d.mts

@@ -0,0 +1,4 @@
+/**
+ * Given an array, convert it into an object with a supplied value per key
+ */
+export declare const toObjectKeys: <TArray extends Array<string>, TValue = true>(array: TArray, value?: TValue) => Record<TArray[number], TValue>;

package/dist/esm/AuthApi.mjs

@@ -0,0 +1 @@
+import{Logout as r}from"@privy-io/public-api";import t from"./CustomProviderApi.mjs";import i from"./EmailApi.mjs";import s from"./FarcasterApi.mjs";import e from"./GuestApi.mjs";import o from"./OAuthApi.mjs";import n from"./PasskeyApi.mjs";import a from"./PhoneApi.mjs";import p from"./SiweApi.mjs";import"./Error.mjs";import"./pkce.mjs";import"jose";class m{_privyInternal;customProvider;phone;email;oauth;siwe;passkey;farcaster;guest;constructor(r,m,l){this._privyInternal=r,this.customProvider=new t(this._privyInternal),this.phone=new a(this._privyInternal),this.email=new i(this._privyInternal),this.oauth=new o(this._privyInternal,m,l),this.guest=new e(this._privyInternal),this.siwe=new p(this._privyInternal),this.passkey=new n(this._privyInternal),this.farcaster=new s(this._privyInternal)}async logout(){try{const t=await this._privyInternal.session.getRefreshToken()??void 0;await this._privyInternal.fetch(r,{body:{refresh_token:t}})}catch(r){console.warn("Error destroying session")}await Promise.all([this._privyInternal.session.destroyLocalState({reason:"logout"}),this._privyInternal.destroyClientAnalyticsId()]),this._privyInternal.callbacks?.setUser?.(null)}}export{m as default};

package/dist/{CustomProviderApi.js → esm/CustomProviderApi.mjs}

@@ -1,2 +1 @@
 import{CustomJWTAuthenticate as t}from"@privy-io/public-api";class s{_privyInternal;constructor(t){this._privyInternal=t}async syncWithToken(s){const n=await this._privyInternal.fetch(t,{body:{token:s}});return await this._privyInternal.session.updateWithTokensResponse(n),this._privyInternal.callbacks?.setUser?.(n.user),n}}export{s as default};
-//# sourceMappingURL=CustomProviderApi.js.map