@getpara/core-sdk 2.0.0-alpha.3 → 2.0.0-dev.1

package/dist/types/ParaCore.d.ts

@@ -1,6 +1,6 @@
-import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, WalletType, PregenIds, BiometricLocationHint, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletInfo, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType } from '@getpara/user-management-client';
+import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, WalletEntity, WalletType, OAuthMethod, TPregenIdentifierType, PregenIds, BiometricLocationHint, TelegramAuthResponse, VerifyTelegramRes, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletLoginRes, ExternalWalletInfo, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType } from '@getpara/user-management-client';
 import type { pki as pkiType } from 'node-forge';
-import { Ctx, Environment, Theme, WalletFilters, WalletTypeProp, Wallet, PortalUrlOptions, ConstructorOpts, CoreAuthInfo, PortalUrlType, CoreMethodParams, CoreMethodResponse, OAuthUrlParams, NewCredentialUrlParams, LoginUrlParams, CoreInterface, ExternalWalletConnectionType } from './types/index.js';
+import { Ctx, Environment, Theme, FullSignatureRes, GetWebAuthUrlForLoginParams, AccountSetupResponse, LoginResponse, WalletFilters, WalletTypeProp, Wallet, PortalUrlOptions, ConstructorOpts, RecoveryStatus, CoreAuthInfo, PortalUrlType, PortalUrlOptionsV2, CoreMethodParams, CoreMethodResponse, OAuthUrlParams, NewCredentialUrlParams, LoginUrlParams, CoreInterface, VerifyExternalWalletV1, ExternalWalletConnectionType } from './types/index.js';
 import { PlatformUtils } from './PlatformUtils.js';
 export declare abstract class ParaCore implements CoreInterface {
     #private;
@@ -164,7 +164,8 @@ export declare abstract class ParaCore implements CoreInterface {
     getWallets(): Record<string, Wallet>;
     getAddress(walletId?: string): string | undefined;
     protected abstract getPlatformUtils(): PlatformUtils;
-    protected constructPortalUrl(type: PortalUrlType, opts?: PortalUrlOptions): Promise<string>;
+    protected constructPortalUrlV2(type: PortalUrlType, opts?: PortalUrlOptionsV2): Promise<string>;
+    private constructPortalUrl;
     /**
      * Constructs a new `ParaCore` instance.
      * @param env - `Environment` to use.
@@ -196,7 +197,6 @@ export declare abstract class ParaCore implements CoreInterface {
     }): Promise<typeof this.authInfo>;
     protected assertUserId(): string;
     protected assertIsAuthSet(allowed?: AuthType[]): PrimaryAuthInfo;
-    assertIsUser: any;
     /**
      * Sets the email associated with the `ParaCore` instance.
      * @param email - Email to set.
@@ -212,7 +212,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param phone - Phone number to set.
      * @param countryCode - Country Code to set.
      */
-    setPhone(phone: `+${number}` | string, countryCode?: string): Promise<void>;
+    setPhoneNumber(phone: `+${number}` | string, countryCode?: string): Promise<void>;
     /**
      * Sets the farcaster username associated with the `ParaCore` instance.
      * @param farcasterUsername - Farcaster Username to set.
@@ -305,6 +305,31 @@ export declare abstract class ParaCore implements CoreInterface {
      * @returns - portal URL
      */
     protected getPortalURL(): Promise<string>;
+    private getWebAuthURLForCreate;
+    private getPasswordURLForCreate;
+    private getShortUrl;
+    shortenLoginLink(link: string): Promise<string>;
+    /**
+     * Generates a URL for registering a new WebAuth passkey.
+     * @deprecated
+     * @param {GetWebAuthUrlForLoginParams} opts the options object
+     * @returns - the URL for creating a new passkey
+     */
+    getWebAuthURLForLogin(opts: GetWebAuthUrlForLoginParams): Promise<string>;
+    /**
+     * Generates a URL for registering a new user password.
+     * @deprecated
+     * @param {GetWebAuthUrlForLoginParams} opts the options object
+     * @returns - the URL for creating a new password
+     */
+    getPasswordURLForLogin(opts: GetWebAuthUrlForLoginParams): Promise<string>;
+    /**
+     * Generates a URL for registering a new WebAuth passkey for a phone number.
+     * @deprecated
+     * @param {Omit<GetWebAuthUrlForLoginParams, 'authType'>} opts the options object
+     * @returns - web auth url
+     */
+    getWebAuthURLForLoginForPhone(opts: Omit<GetWebAuthUrlForLoginParams, 'authType'>): Promise<string>;
     /**
      * Gets the private key for the given wallet.
      * @param {string } [walletId] id of the wallet to get the private key for. Will default to the first wallet if not provided.
@@ -318,10 +343,174 @@ export declare abstract class ParaCore implements CoreInterface {
     fetchWallets(): CoreMethodResponse<'fetchWallets'>;
     private populateWalletAddresses;
     private populatePregenWalletAddresses;
+    /**
+     * Checks if a user exists for an email address.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.email the email to check.
+     * @returns true if user exists, false otherwise.
+     */
+    checkIfUserExists({ email }: {
+        email: string;
+    }): Promise<boolean>;
+    /**
+     * Checks if a user exists for a phone number.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.phone - phone number to check.
+     * @param {string} opts.countryCode - the country code.
+     * @returns true if user exists, false otherwise.
+     */
+    checkIfUserExistsByPhone(auth: Auth<'phone'>): Promise<boolean>;
+    /**
+     * Creates a new user.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.email the email to use.
+     */
+    createUser({ email }: Auth<'email'>): Promise<void>;
+    /**
+     * Creates a new user with a phone number.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.phone - the phone number to use for creating the user.
+     * @param {string} opts.countryCode - the country code to use for creating the user.
+     */
+    createUserByPhone(auth: Auth<'phone'>): Promise<void>;
+    /**
+     * Logs in or creates a new user using an external wallet address.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.address the external wallet address to use for identification.
+     * @param {WalletType} opts.type type of external wallet to use for identification.
+     * @param {string} opts.provider the name of the provider for the external wallet.
+     */
+    externalWalletLogin(wallet: ExternalWalletInfo): Promise<ExternalWalletLoginRes>;
+    /**
+     * Passes the email code obtained from the user for verification.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} verificationCode the six-digit code to check
+     * @returns {string} the web auth url for creating a new credential
+     */
+    verifyEmail({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<string>;
+    /** @deprecated */
+    verifyExternalWallet({ address, signedMessage, cosmosPublicKeyHex, cosmosSigner, }: VerifyExternalWalletV1): Promise<string>;
+    /**
+     * Passes the phone code obtained from the user for verification.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} verificationCode the six-digit code to check
+     * @returns {string} the web auth url for creating a new credential
+     */
+    verifyPhone({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<string>;
+    /**
+     * Validates the response received from an attempted Telegram login for authenticity, then
+     * creates or retrieves the corresponding Para user and prepares the Para instance to sign in with that user.
+     * @deprecated
+     * @param authResponse - the response JSON object received from the Telegram widget.
+     * @returns `{ isValid: boolean; telegramUserId?: string; userId?: string; isNewUser?: boolean; supportedAuthMethods?: AuthMethod[]; biometricHints?: BiometricLocationHint[] }`
+     */
+    verifyTelegram(authObject: TelegramAuthResponse): Promise<VerifyTelegramRes>;
+    /**
+     * Performs 2FA verification.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.email the email to use for performing a 2FA verification.
+     * @param {string} opts.verificationCode the verification code to received via 2FA.
+     * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
+     */
+    verify2FA({ email, verificationCode }: {
+        email: string;
+        verificationCode: string;
+    }): Promise<{
+        initiatedAt?: Date;
+        status?: RecoveryStatus;
+        userId: string;
+        wallets: Pick<Wallet, 'address' | 'id'>[];
+    }>;
+    /**
+     * Performs 2FA verification.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.phone the phone number
+     * @param {string} opts.countryCode - the country code
+     * @param {string} opts.verificationCode - verification code to received via 2FA.
+     * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
+     */
+    verify2FAForPhone({ phone, verificationCode, }: Auth<'phone'> & {
+        verificationCode: string;
+    }): Promise<{
+        initiatedAt?: Date;
+        status?: RecoveryStatus;
+        userId: string;
+        wallets: Pick<Wallet, 'address' | 'id'>[];
+    }>;
+    /**
+     * Sets up two-factor authentication for the current user.
+     * @deprecated
+     * @returns {string} uri - uri to use for setting up 2FA
+     * */
+    setup2FA(): Promise<{
+        uri?: string;
+    }>;
+    /**
+     * Enables 2FA.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.verificationCode - the verification code received via 2FA.
+     */
+    enable2FA({ verificationCode }: {
+        verificationCode: string;
+    }): Promise<void>;
+    /**
+     * Determines if 2FA has been set up.
+     * @deprecated
+     * @returns {Object} `{ isSetup: boolean }` - true if 2FA is setup, false otherwise
+     */
+    check2FAStatus(): Promise<{
+        isSetup: boolean;
+    }>;
     /**
      * Resend a verification email for the current user.
      */
     resendVerificationCode(): CoreMethodResponse<'resendVerificationCode'>;
+    /**
+     * Resend a verification SMS for the current user.
+     * @deprecated
+     */
+    resendVerificationCodeByPhone(): Promise<void>;
+    /**
+     * Returns a URL for setting up a new WebAuth passkey.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.authType - the auth type to use
+     * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+     * @returns {string} the URL
+     */
+    getSetUpBiometricsURL({ authType, isForNewDevice, }?: Pick<PortalUrlOptions, 'authType' | 'isForNewDevice'>): Promise<string>;
+    /**
+     * Returns a URL for setting up a new WebAuth passkey for a phone number.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+     * @returns {string} the URL
+     */
+    getSetUpBiometricsURLForPhone({ isForNewDevice, }?: Pick<PortalUrlOptions, 'isForNewDevice'>): Promise<string>;
+    /**
+     * Returns a URL for setting up a new password.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {string} opts.authType - the auth type to use
+     * @param {boolean} opts.isForNewDevice whether the passkey is for a new device of an existing user
+     * @param {Theme} [opts.theme] the portal theme to use in place of the partner's default
+     * @returns {string} the URL
+     */
+    getSetupPasswordURL({ authType, isForNewDevice, theme, }?: Pick<PortalUrlOptions, 'authType' | 'isForNewDevice' | 'theme'>): Promise<string>;
     /**
      * Checks if the current session is active.
      * @returns `true` if active, `false` otherwise
@@ -332,6 +521,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @returns `true` if active, `false` otherwise
      **/
     isFullyLoggedIn(): CoreMethodResponse<'isFullyLoggedIn'>;
+    /** @deprecated */
     protected supportedAuthMethods(auth: Auth<PrimaryAuthType | 'userId'>): Promise<Set<AuthMethod>>;
     /**
      * Get hints associated with the users stored biometrics.
@@ -339,6 +529,107 @@ export declare abstract class ParaCore implements CoreInterface {
      * @returns Array containing useragents and AAGuids for stored biometrics
      */
     protected getUserBiometricLocationHints(): Promise<BiometricLocationHint[]>;
+    /**
+     * Initiates a login.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {String} opts.email - the email to login with
+     * @param {boolean} opts.useShortURL - whether to shorten the link
+     * @returns - the WebAuth URL for logging in
+     **/
+    initiateUserLogin({ useShortUrl, ...auth }: PrimaryAuth & {
+        useShortUrl?: boolean;
+    }): Promise<string>;
+    /**
+     * Initiates a login.
+     * @deprecated
+     * @param email - the email to login with
+     * @returns - a set of supported auth methods for the user
+     **/
+    initiateUserLoginV2(auth: PrimaryAuth): Promise<Set<AuthMethod>>;
+    /**
+     * Initiates a login.
+     * @deprecated
+     * @param opts the options object
+     * @param opts.phone the phone number
+     * @param opts.countryCode the country code
+     * @param opts.useShortURL - whether to shorten the link
+     * @returns - the WebAuth URL for logging in
+     **/
+    initiateUserLoginForPhone({ useShortUrl, ...auth }: Auth<'phone'> & {
+        useShortUrl?: boolean;
+    }): Promise<string>;
+    /**
+     * @deprecated
+     * Waits for the session to be active.
+     **/
+    waitForAccountCreation({ popupWindow }?: {
+        popupWindow?: Window | null;
+    }): Promise<boolean>;
+    /**
+     * @deprecated
+     */
+    waitForPasskeyAndCreateWallet({ popupWindow, }?: {
+        popupWindow?: Window;
+    }): Promise<AccountSetupResponse>;
+    /**
+     * Initiates a Farcaster login attempt and return the URI for the user to connect.
+     * You can create a QR code with this URI that works with Farcaster's mobile app.
+     * @deprecated
+     * @return {string} the Farcaster connect URI
+     */
+    getFarcasterConnectURL(): Promise<string>;
+    /**
+     * Awaits the response from a user's attempt to log in with Farcaster.
+     * If successful, this returns the user's Farcaster username and profile picture and indicates whether the user already exists.
+     * @deprecated
+     * @return {Object} `{userExists: boolean; username: string; pfpUrl?: string | null }` - the user's information and whether the user already exists.
+     */
+    waitForFarcasterStatus(): Promise<{
+        userId: string;
+        userExists: boolean;
+        username: string;
+        pfpUrl?: string | null;
+    }>;
+    /**
+     * Generates a URL for the user to log in with OAuth using a desire method.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {OAuthMethod} opts.method the third-party service to use for OAuth.
+     * @param {string} [opts.deeplinkUrl] the deeplink to redirect to after the OAuth flow. This is for mobile only.
+     * @returns {string} the URL for the user to log in with OAuth.
+     */
+    getOAuthURL({ method, deeplinkUrl }: {
+        method: OAuthMethod;
+        deeplinkUrl?: string;
+    }): Promise<string>;
+    /**
+     * Awaits the response from a user's attempt to log in with OAuth.
+     * If successful, this returns the user's email address and indicates whether the user already exists.
+     * @deprecated
+     * @param {Object} opts the options object.
+     * @param {Window} [opts.popupWindow] the popup window being used for login.
+     * @return {Object} `{ email?: string; isError?: boolean; userExists: boolean; }` the result data
+     */
+    waitForOAuth({ popupWindow }?: {
+        popupWindow?: Window | null;
+    }): Promise<{
+        email?: string;
+        isError?: boolean;
+        userExists: boolean;
+    }>;
+    /**
+     * Waits for the session to be active and sets up the user.
+     * @deprecated
+     * @param {Object} opts the options object
+     * @param {Window} [opts.popupWindow] the popup window being used for login.
+     * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
+     * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
+     **/
+    waitForLoginAndSetup({ popupWindow, skipSessionRefresh, }?: {
+        popupWindow?: Window | null;
+        skipSessionRefresh?: boolean;
+    }): Promise<LoginResponse>;
     /**
      * Updates the session with the user management server, possibly
      * opening a popup to refresh the session.
@@ -434,6 +725,85 @@ export declare abstract class ParaCore implements CoreInterface {
      * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
      **/
     createWallet({ type: _type, skipDistribute, }?: CoreMethodParams<'createWallet'>): CoreMethodResponse<'createWallet'>;
+    /**
+     * Creates a new pregenerated wallet.
+     * @deprecated
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier the identifier associated with the new wallet.
+     * @param {TPregenIdentifierType} [opts.pregenIdentifierType] the identifier type. Defaults to `EMAIL`.
+     * @param {WalletType} [opts.type] the type of wallet to create. Defaults to the first non-optional type in the instance's `supportedWalletTypes` array.
+     * @returns {Wallet} the created wallet.
+     **/
+    createPregenWallet(opts: {
+        type: WalletType;
+        pregenIdentifier: string;
+        pregenIdentifierType: TPregenIdentifierType;
+    }): Promise<Wallet>;
+    /**
+     * Creates new pregenerated wallets for each desired type.
+     * If no types are provided, this method will create one for each of the non-optional types
+     * specified in the instance's `supportedWalletTypes` array that are not already present.
+     * @deprecated
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier the identifier to associate each wallet with.
+     * @param {TPregenIdentifierType} opts.pregenIdentifierType - either `'EMAIL'` or `'PHONE'`.
+     * @param {WalletType[]} [opts.types] the wallet types to create. Defaults to any types the instance supports that are not already present.
+     * @returns {Wallet[]} an array containing the created wallets.
+     **/
+    createPregenWalletPerType({ types, pregenIdentifier, pregenIdentifierType, }: {
+        pregenIdentifier: string;
+        pregenIdentifierType: TPregenIdentifierType;
+        types?: WalletType[];
+    }): Promise<Wallet[]>;
+    /**
+     * Claims a pregenerated wallet.
+     * @deprecated
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier string the identifier of the user claiming the wallet
+     * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the identifier of the user claiming the wallet
+     * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
+     **/
+    claimPregenWallets({ pregenIdentifier, pregenIdentifierType, }?: {
+        pregenIdentifier?: string;
+        pregenIdentifierType?: TPregenIdentifierType;
+    }): Promise<string | undefined>;
+    /**
+     * Updates the identifier for a pregen wallet.
+     * @deprecated
+     * @param {Object} opts the options object.
+     * @param {string} opts.walletId the pregen wallet ID
+     * @param {string} opts.newPregenIdentifier the new identtifier
+     * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
+     **/
+    updatePregenWalletIdentifier({ walletId, newPregenIdentifier, newPregenIdentifierType, }: {
+        walletId: string;
+        newPregenIdentifier: string;
+        newPregenIdentifierType: TPregenIdentifierType;
+    }): Promise<void>;
+    /**
+     * Checks if a pregen Wallet exists for the given identifier with the current partner.
+     * @deprecated
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier string the identifier of the user claiming the wallet
+     * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the string of the identifier of the user claiming the wallet
+     * @returns {boolean} whether the pregen wallet exists
+     **/
+    hasPregenWallet({ pregenIdentifier, pregenIdentifierType, }: {
+        pregenIdentifier: string;
+        pregenIdentifierType: TPregenIdentifierType;
+    }): Promise<boolean>;
+    /**
+     * Get pregen wallets for the given identifier.
+     * @deprecated
+     * @param {Object} opts the options object.
+     * @param {string} opts.pregenIdentifier - the identifier of the user claiming the wallet
+     * @param {TPregenIdentifierType} opts.pregenIdentifierType - type of the identifier of the user claiming the wallet
+     * @returns {Promise<WalletEntity[]>} the array of found wallets
+     **/
+    getPregenWallets({ pregenIdentifier, pregenIdentifierType, }?: {
+        pregenIdentifier?: string;
+        pregenIdentifierType?: TPregenIdentifierType;
+    }): Promise<WalletEntity[]>;
     private encodeWalletBase64;
     /**
      * Encodes the current wallets encoded in Base 64.
@@ -469,6 +839,18 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {number} [opts.timeoutMs] the amount of time to wait for the user to sign the transaction, in milliseconds
      **/
     signTransaction({ walletId, rlpEncodedTxBase64, chainId, timeoutMs, isCanceled, onCancel, onPoll, }: CoreMethodParams<'signTransaction'>): CoreMethodResponse<'signTransaction'>;
+    /**
+     * @deprecated
+     * Sends a transaction.
+     * @param walletId - id of the wallet to send the transaction from.
+     * @param rlpEncodedTxBase64 - rlp encoded tx as base64 string
+     * @param chainId - chain id of the chain the transaction is being sent on.
+     **/
+    sendTransaction({ walletId, rlpEncodedTxBase64, chainId, }: {
+        walletId: string;
+        rlpEncodedTxBase64: string;
+        chainId: string;
+    }): Promise<FullSignatureRes>;
     protected isProviderModalDisabled(): boolean;
     /**
      * Starts a on-ramp or off-ramp transaction and returns the Para Portal link for the user to finalize and complete it.
@@ -496,18 +878,23 @@ export declare abstract class ParaCore implements CoreInterface {
     /**
      * @deprecated
      */
+    protected exitAccountCreation(): void;
     /**
      * @deprecated
      */
+    protected exitLogin(): void;
     /**
      * @deprecated
      */
+    protected exitFarcaster(): void;
     /**
      * @deprecated
      */
+    protected exitOAuth(): void;
     /**
      * @deprecated
      */
+    protected exitLoops(): void;
     /**
      * Retrieves a token to verify the current session.
      * @returns {Promise<string>} the ID
@@ -530,31 +917,23 @@ export declare abstract class ParaCore implements CoreInterface {
      **/
     toString(): string;
     /** NEW METHODS */
-    protected getNewCredentialAndUrl({ authMethod, isForNewDevice, portalTheme, shorten, }?: NewCredentialUrlParams): Promise<{
+    protected getNewCredentialAndUrl({ authMethod, isForNewDevice, portalTheme, shorten, }: NewCredentialUrlParams): Promise<{
         credentialId: string;
         url: string;
     }>;
-    /**
-     * Returns a Para Portal URL for logging in with a WebAuth passkey or a password.
-     * @param {Object} opts the options object
-     * @param {String} opts.auth - the user auth to sign up or log in with, in the form ` { email: string } | { phone: `+${number}` } `
-     * @param {boolean} opts.useShortUrls - whether to shorten the generated portal URLs
-     * @param {Theme} opts.portalTheme the Para Portal theme to apply to the password creation URL, if other than the default theme
-     * @returns {SignUpOrLogInResponse} an object in the form of either: `{ stage: 'verify' }` or `{ stage: 'login'; passkeyUrl?: string; passwordUrl?: string; biometricHints?: BiometricLocationHint[] }`
-     */
-    protected getLoginUrl({ authMethod, shorten, portalTheme, sessionId, }: LoginUrlParams): Promise<string>;
-    protected getOAuthUrl({ method, deeplinkUrl }: OAuthUrlParams): Promise<string>;
-    signUpOrLogIn({ auth, ...urlOptions }: CoreMethodParams<'signUpOrLogIn'>): CoreMethodResponse<'signUpOrLogIn'>;
-    verifyNewAccount({ verificationCode, ...urlOptions }: CoreMethodParams<'verifyNewAccount'>): CoreMethodResponse<'verifyNewAccount'>;
-    verifyOAuth({ method, deeplinkUrl, isCanceled, onCancel, onPoll, onOAuthUrl, ...urlOptions }: CoreMethodParams<'verifyOAuth'>): CoreMethodResponse<'verifyOAuth'>;
-    verifyFarcaster({ isCanceled, onConnectUri, onCancel, onPoll, ...urlOptions }: CoreMethodParams<'verifyFarcaster'>): CoreMethodResponse<'verifyFarcaster'>;
+    protected getLoginUrlV2({ authMethod, shorten, portalTheme, sessionId, }: LoginUrlParams): Promise<string>;
+    protected getOAuthUrlV2({ method, deeplinkUrl }: OAuthUrlParams): Promise<string>;
+    signUpOrLogInV2({ auth, ...urlOptions }: CoreMethodParams<'signUpOrLogInV2'>): CoreMethodResponse<'signUpOrLogInV2'>;
+    verifyNewAccountV2({ verificationCode, ...urlOptions }: CoreMethodParams<'verifyNewAccountV2'>): CoreMethodResponse<'verifyNewAccountV2'>;
+    verifyOAuthV2({ method, deeplinkUrl, isCanceled, onCancel, onPoll, onOAuthUrl, ...urlOptions }: CoreMethodParams<'verifyOAuthV2'>): CoreMethodResponse<'verifyOAuthV2'>;
+    verifyFarcasterV2({ isCanceled, onConnectUri, onCancel, onPoll, ...urlOptions }: CoreMethodParams<'verifyFarcasterV2'>): CoreMethodResponse<'verifyFarcasterV2'>;
     /**
      * Validates the response received from an attempted Telegram login for authenticity, then
      * creates or retrieves the corresponding Para user and prepares the Para instance to sign in with that user.
      * @param authResponse - the response JSON object received from the Telegram widget.
      * @returns `{ isValid: boolean; telegramUserId?: string; userId?: string; isNewUser?: boolean; supportedAuthMethods?: AuthMethod[]; biometricHints?: BiometricLocationHint[] }`
      */
-    verifyTelegram({ telegramAuthResponse, ...urlOptions }: CoreMethodParams<'verifyTelegram'>): CoreMethodResponse<'verifyTelegram'>;
+    verifyTelegramV2({ telegramAuthResponse, ...urlOptions }: CoreMethodParams<'verifyTelegramV2'>): CoreMethodResponse<'verifyTelegramV2'>;
     /**
      * Waits for the session to be active and sets up the user.
      *
@@ -563,11 +942,11 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {boolean} [opts.skipSessionRefresh] whether to skip refreshing the session.
      * @returns {Object} `{ isComplete: boolean; isError: boolean; needsWallet: boolean; partnerId: string; }` the result data
      **/
-    waitForLogin({ isCanceled, onCancel, onPoll, skipSessionRefresh, }?: CoreMethodParams<'waitForLogin'>): CoreMethodResponse<'waitForLogin'>;
-    waitForSignup({ isCanceled, onCancel, onPoll, }: CoreMethodParams<'waitForSignup'>): CoreMethodResponse<'waitForSignup'>;
-    waitForWalletCreation({ isCanceled, onCancel, }?: CoreMethodParams<'waitForWalletCreation'>): CoreMethodResponse<'waitForWalletCreation'>;
-    loginExternalWallet({ externalWallet, ...urlOptions }: CoreMethodParams<'loginExternalWallet'>): CoreMethodResponse<'loginExternalWallet'>;
-    verifyExternalWallet({ externalWallet, signedMessage, cosmosPublicKeyHex, cosmosSigner, ...urlOptions }: CoreMethodParams<'verifyExternalWallet'>): CoreMethodResponse<'verifyExternalWallet'>;
+    waitForLoginV2({ isCanceled, onCancel, onPoll, skipSessionRefresh, }?: CoreMethodParams<'waitForLoginV2'>): CoreMethodResponse<'waitForLoginV2'>;
+    waitForSignupV2({ isCanceled, onCancel, onPoll, }: CoreMethodParams<'waitForSignupV2'>): CoreMethodResponse<'waitForSignupV2'>;
+    waitForWalletCreationV2({ isCanceled, onCancel, }?: CoreMethodParams<'waitForWalletCreationV2'>): CoreMethodResponse<'waitForWalletCreationV2'>;
+    loginExternalWalletV2({ externalWallet, ...urlOptions }: CoreMethodParams<'loginExternalWalletV2'>): CoreMethodResponse<'loginExternalWalletV2'>;
+    verifyExternalWalletV2({ externalWallet, signedMessage, cosmosPublicKeyHex, cosmosSigner, ...urlOptions }: CoreMethodParams<'verifyExternalWalletV2'>): CoreMethodResponse<'verifyExternalWalletV2'>;
     /**
      * Performs 2FA verification.
      * @param {Object} opts the options object
@@ -575,18 +954,18 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {string} opts.verificationCode the verification code to received via 2FA.
      * @returns {Object} `{ address, initiatedAt, status, userId, walletId }`
      */
-    verify2fa({ auth, verificationCode }: CoreMethodParams<'verify2fa'>): CoreMethodResponse<'verify2fa'>;
+    verify2faV2({ auth, verificationCode }: CoreMethodParams<'verify2faV2'>): CoreMethodResponse<'verify2faV2'>;
     /**
      * Sets up two-factor authentication for the current user.
      * @returns {string} uri - uri to use for setting up 2FA
      * */
-    setup2fa(): CoreMethodResponse<'setup2fa'>;
+    setup2faV2(): CoreMethodResponse<'setup2faV2'>;
     /**
      * Enables 2FA.
      * @param {Object} opts the options object
      * @param {string} opts.verificationCode - the verification code received via 2FA.
      */
-    enable2fa({ verificationCode }: CoreMethodParams<'enable2fa'>): CoreMethodResponse<'enable2fa'>;
+    enable2faV2({ verificationCode }: CoreMethodParams<'enable2faV2'>): CoreMethodResponse<'enable2faV2'>;
     /**
      * Creates a new pregenerated wallet.
      *
@@ -596,7 +975,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {WalletType} [opts.type] the type of wallet to create. Defaults to the first non-optional type in the instance's `supportedWalletTypes` array.
      * @returns {Wallet} the created wallet.
      **/
-    createPregenWallet(opts: CoreMethodParams<'createPregenWallet'>): CoreMethodResponse<'createPregenWallet'>;
+    createPregenWalletV2(opts: CoreMethodParams<'createPregenWalletV2'>): CoreMethodResponse<'createPregenWalletV2'>;
     /**
      * Creates new pregenerated wallets for each desired type.
      * If no types are provided, this method will create one for each of the non-optional types
@@ -607,7 +986,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {WalletType[]} [opts.types] the wallet types to create. Defaults to any types the instance supports that are not already present.
      * @returns {Wallet[]} an array containing the created wallets.
      **/
-    createPregenWalletPerType({ types, pregenId, }: CoreMethodParams<'createPregenWalletPerType'>): CoreMethodResponse<'createPregenWalletPerType'>;
+    createPregenWalletPerTypeV2({ types, pregenId, }: CoreMethodParams<'createPregenWalletPerTypeV2'>): CoreMethodResponse<'createPregenWalletPerTypeV2'>;
     /**
      * Claims a pregenerated wallet.
      * @param {Object} opts the options object.
@@ -615,7 +994,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the identifier of the user claiming the wallet
      * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
      **/
-    claimPregenWallets({ pregenId, }?: CoreMethodParams<'claimPregenWallets'>): CoreMethodResponse<'claimPregenWallets'>;
+    claimPregenWalletsV2({ pregenId, }?: CoreMethodParams<'claimPregenWalletsV2'>): CoreMethodResponse<'claimPregenWalletsV2'>;
     /**
      * Updates the identifier for a pregen wallet.
      * @param {Object} opts the options object.
@@ -623,7 +1002,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {string} opts.newPregenIdentifier the new identtifier
      * @param {TPregenIdentifierType} opts.newPregenIdentifierType: the new identifier type
      **/
-    updatePregenWalletIdentifier({ walletId, newPregenId, }: CoreMethodParams<'updatePregenWalletIdentifier'>): CoreMethodResponse<'updatePregenWalletIdentifier'>;
+    updatePregenWalletIdentifierV2({ walletId, newPregenId, }: CoreMethodParams<'updatePregenWalletIdentifierV2'>): CoreMethodResponse<'updatePregenWalletIdentifierV2'>;
     /**
      * Checks if a pregen Wallet exists for the given identifier with the current partner.
      * @param {Object} opts the options object.
@@ -631,7 +1010,7 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TPregenIdentifierType} opts.pregenIdentifierType type of the string of the identifier of the user claiming the wallet
      * @returns {boolean} whether the pregen wallet exists
      **/
-    hasPregenWallet({ pregenId }: CoreMethodParams<'hasPregenWallet'>): CoreMethodResponse<'hasPregenWallet'>;
+    hasPregenWalletV2({ pregenId }: CoreMethodParams<'hasPregenWalletV2'>): CoreMethodResponse<'hasPregenWalletV2'>;
     /**
      * Get pregen wallets for the given identifier.
      * @param {Object} opts the options object.
@@ -639,5 +1018,5 @@ export declare abstract class ParaCore implements CoreInterface {
      * @param {TPregenIdentifierType} opts.pregenIdentifierType - type of the identifier of the user claiming the wallet
      * @returns {Promise<WalletEntity[]>} the array of found wallets
      **/
-    getPregenWallets({ pregenId }?: CoreMethodParams<'getPregenWallets'>): CoreMethodResponse<'getPregenWallets'>;
+    getPregenWalletsV2({ pregenId, }?: CoreMethodParams<'getPregenWalletsV2'>): CoreMethodResponse<'getPregenWalletsV2'>;
 }