@getpara/core-sdk 1.8.0 → 2.0.0-alpha.3

package/dist/types/ParaCore.d.ts

@@ -1,17 +1,19 @@
-import Client, { AuthMethod, BackupKitEmailProps, CurrentWalletIds, EmailTheme, WalletEntity, WalletType, WalletParams, OAuthMethod, OnRampPurchaseCreateParams, OnRampPurchase, TPregenIdentifierType, PregenIds, BiometricLocationHint, TelegramAuthResponse, VerifyTelegramRes, Auth, ExternalWalletLoginRes, AccountMetadata } from '@getpara/user-management-client';
+import { AuthMethod, AuthExtras, CurrentWalletIds, EmailTheme, WalletType, PregenIds, BiometricLocationHint, Auth, SupportedWalletTypes, AuthIdentifier, AuthType, ExternalWalletInfo, PrimaryAuthInfo, SessionInfo, PrimaryAuth, PrimaryAuthType } from '@getpara/user-management-client';
 import type { pki as pkiType } from 'node-forge';
-import { Ctx, Environment, Theme, FullSignatureRes, ExternalWalletInfo, GetWebAuthUrlForLoginParams, AccountSetupResponse, LoginResponse, WalletFilters, WalletTypeProp, Wallet, SupportedWalletTypes, PortalUrlOptions, ConstructorOpts, RecoveryStatus, GetWalletBalanceParams } from './types/index.js';
+import { Ctx, Environment, Theme, WalletFilters, WalletTypeProp, Wallet, PortalUrlOptions, ConstructorOpts, CoreAuthInfo, PortalUrlType, CoreMethodParams, CoreMethodResponse, OAuthUrlParams, NewCredentialUrlParams, LoginUrlParams, CoreInterface, ExternalWalletConnectionType } from './types/index.js';
 import { PlatformUtils } from './PlatformUtils.js';
-import { CountryCallingCode } from 'libphonenumber-js';
-export declare abstract class ParaCore {
+export declare abstract class ParaCore implements CoreInterface {
     #private;
     static version?: string;
     ctx: Ctx;
-    email?: string;
-    phone?: string;
-    countryCode?: CountryCallingCode;
-    farcasterUsername?: string;
-    telegramUserId?: string;
+    protected isNativePasskey: boolean;
+    get authInfo(): CoreAuthInfo | undefined;
+    get email(): AuthIdentifier<'email'> | undefined;
+    get phone(): AuthIdentifier<'phone'> | undefined;
+    get farcasterUsername(): AuthIdentifier<'farcaster'> | undefined;
+    get telegramUserId(): AuthIdentifier<'telegram'> | undefined;
+    get externalWalletWithParaAuth(): Wallet | undefined;
+    get externalWalletConnectionType(): ExternalWalletConnectionType;
     userId?: string;
     private sessionCookie?;
     private isAwaitingAccountCreation;
@@ -22,8 +24,8 @@ export declare abstract class ParaCore {
     get isPhone(): boolean;
     get isFarcaster(): boolean;
     get isTelegram(): boolean;
-    get externalWalletWithParaAuth(): Wallet | undefined;
     get isExternalWalletAuth(): boolean;
+    get partnerId(): string | undefined;
     /**
      * The IDs of the currently active wallets, for each supported wallet type. Any signer integrations will default to the first viable wallet ID in this dictionary.
      */
@@ -114,10 +116,12 @@ export declare abstract class ParaCore {
     portalTheme?: Theme;
     private disableProviderModal?;
     get supportedWalletTypes(): SupportedWalletTypes;
+    get cosmosPrefix(): string | undefined;
     get isWalletTypeEnabled(): Partial<Record<WalletType, boolean>>;
     private platformUtils;
     private localStorageGetItem;
     private localStorageSetItem;
+    private localStorageRemoveItem;
     private sessionStorageGetItem;
     private sessionStorageSetItem;
     private sessionStorageRemoveItem;
@@ -127,7 +131,7 @@ export declare abstract class ParaCore {
      * Remove all local storage and prefixed session storage.
      * @param {'local' | 'session' | 'secure' | 'all'} type - Type of storage to clear. Defaults to 'all'.
      */
-    clearStorage: (type?: 'local' | 'session' | 'secure' | 'all') => Promise<void>;
+    clearStorage: (type?: CoreMethodParams<'clearStorage'>) => CoreMethodResponse<'clearStorage'>;
     private convertBigInt;
     private convertEncryptionKeyPair;
     private isPortal;
@@ -160,7 +164,7 @@ export declare abstract class ParaCore {
     getWallets(): Record<string, Wallet>;
     getAddress(walletId?: string): string | undefined;
     protected abstract getPlatformUtils(): PlatformUtils;
-    private constructPortalUrl;
+    protected constructPortalUrl(type: PortalUrlType, opts?: PortalUrlOptions): Promise<string>;
     /**
      * Constructs a new `ParaCore` instance.
      * @param env - `Environment` to use.
@@ -168,20 +172,16 @@ export declare abstract class ParaCore {
      * @param opts - Additional constructor options; see `ConstructorOpts`.
      * @returns - A new ParaCore instance.
      */
-    constructor(env: Environment, apiKey?: string, opts?: ConstructorOpts);
+    constructor(env: Environment, apiKey: string, opts?: ConstructorOpts);
     private initializeFromStorage;
-    private updateTelegramUserIdFromStorage;
+    private updateAuthInfoFromStorage;
     private updateUserIdFromStorage;
-    private updatePhoneFromStorage;
-    private updateCountryCodeFromStorage;
-    private updateEmailFromStorage;
     private updateWalletsFromStorage;
     private updateWalletIdsFromStorage;
     private updateSessionCookieFromStorage;
     private updateLoginEncryptionKeyPairFromStorage;
     private updateExternalWalletsFromStorage;
-    touchSession(regenerate?: boolean): Promise<Awaited<ReturnType<Client['touchSession']>>>;
-    private setSupportedWalletTypes;
+    touchSession(regenerate?: boolean): Promise<SessionInfo>;
     private getVerificationEmailProps;
     private getBackupKitEmailProps;
     /**
@@ -190,6 +190,13 @@ export declare abstract class ParaCore {
      * Init only needs to be called for storage that is async.
      */
     init(): Promise<void>;
+    protected setAuth(auth: PrimaryAuth, { extras, userId }?: {
+        extras?: AuthExtras;
+        userId?: string;
+    }): 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.
@@ -205,7 +212,7 @@ export declare abstract class ParaCore {
      * @param phone - Phone number to set.
      * @param countryCode - Country Code to set.
      */
-    setPhoneNumber(phone: string, countryCode: CountryCallingCode): Promise<void>;
+    setPhone(phone: `+${number}` | string, countryCode?: string): Promise<void>;
     /**
      * Sets the farcaster username associated with the `ParaCore` instance.
      * @param farcasterUsername - Farcaster Username to set.
@@ -248,19 +255,11 @@ export declare abstract class ParaCore {
      * @returns - email associated with the `ParaCore` instance.
      */
     getEmail(): string | undefined;
-    /**
-     * Gets the phone object associated with the `ParaCore` instance.
-     * @returns - phone object with phone number and country code associated with the `ParaCore` instance.
-     */
-    getPhone(): {
-        phone?: string;
-        countryCode?: string;
-    };
     /**
      * Gets the formatted phone number associated with the `ParaCore` instance.
      * @returns - formatted phone number associated with the `ParaCore` instance.
      */
-    getPhoneNumber(): string | undefined;
+    getPhoneNumber(): `+${number}` | undefined;
     /**
      * Gets the farcaster username associated with the `ParaCore` instance.
      * @returns - farcaster username associated with the `ParaCore` instance.
@@ -271,16 +270,6 @@ export declare abstract class ParaCore {
         sessionLookupId?: string;
         newDeviceSessionLookupId?: string;
     }): Promise<void>;
-    /**
-     * Fetches the most recent OAuth account metadata for the signed-in user.
-     * If applicable, this will include the user's most recent metadata from their Google, Apple, Facebook, X, Discord, Farcaster, or Telegram account, the last time they signed in to your app.
-     * @returns {Promise<AccountMetadata>} the user's account metadata.
-     */
-    getAccountMetadata(): Promise<AccountMetadata>;
-    /**
-     * The prefix for the instance's managed Cosmos wallets. Defaults to `'cosmos'`.
-     */
-    cosmosPrefix?: string;
     /**
      * Validates that a wallet ID is present on the instance, usable, and matches the desired filters.
      * If no ID is passed, this will instead return the first valid, usable wallet ID that matches the filters.
@@ -315,29 +304,7 @@ export declare abstract class ParaCore {
      * @param partnerId: string - id of the partner to get the portal URL for
      * @returns - portal URL
      */
-    protected getPortalURL(partnerId?: string): Promise<string>;
-    private getWebAuthURLForCreate;
-    private getPasswordURLForCreate;
-    private getShortUrl;
-    shortenLoginLink(link: string): Promise<string>;
-    /**
-     * Generates a URL for registering a new WebAuth passkey.
-     * @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.
-     * @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.
-     * @param {Omit<GetWebAuthUrlForLoginParams, 'authType'>} opts the options object
-     * @returns - web auth url
-     */
-    getWebAuthURLForLoginForPhone(opts: Omit<GetWebAuthUrlForLoginParams, 'authType'>): Promise<string>;
+    protected getPortalURL(): 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.
@@ -348,281 +315,30 @@ export declare abstract class ParaCore {
      * Fetches the wallets associated with the user.
      * @returns {WalletEntity[]} wallets that were fetched.
      */
-    fetchWallets(): Promise<WalletEntity[]>;
+    fetchWallets(): CoreMethodResponse<'fetchWallets'>;
     private populateWalletAddresses;
     private populatePregenWalletAddresses;
-    /**
-     * Checks if a user exists for an email address.
-     * @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.
-     * @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({ phone, countryCode }: {
-        phone: string;
-        countryCode: string;
-    }): Promise<boolean>;
-    /**
-     * Creates a new user.
-     * @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.
-     * @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({ phone, countryCode }: Auth<'phone'>): Promise<void>;
-    /**
-     * Logs in or creates a new user using an external wallet address.
-     * @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>;
-    /**
-     * Returns whether or not the user is connected with only an external wallet, not an external wallet with Para auth.
-     */
-    protected isUsingExternalWallet(): boolean;
-    /**
-     * Passes the email code obtained from the user for verification.
-     * @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>;
-    verifyExternalWallet({ address, signedMessage, cosmosPublicKeyHex, cosmosSigner, }: {
-        address: string;
-        signedMessage: string;
-        cosmosPublicKeyHex?: string;
-        cosmosSigner?: string;
-    }): Promise<string>;
-    /**
-     * Passes the phone code obtained from the user for verification.
-     * @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.
-     * @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.
-     * @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.
-     * @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, countryCode, verificationCode, }: {
-        phone: string;
-        countryCode: string;
-        verificationCode: string;
-    }): Promise<{
-        initiatedAt?: Date;
-        status?: RecoveryStatus;
-        userId: string;
-        wallets: Pick<Wallet, 'address' | 'id'>[];
-    }>;
-    /**
-     * Sets up two-factor authentication for the current user.
-     * @returns {string} uri - uri to use for setting up 2FA
-     * */
-    setup2FA(): Promise<{
-        uri?: string;
-    }>;
-    /**
-     * Enables 2FA.
-     * @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.
-     * @returns {Object} `{ isSetup: boolean }` - true if 2FA is setup, false otherwise
-     */
-    check2FAStatus(): Promise<{
-        isSetup: boolean;
-    }>;
     /**
      * Resend a verification email for the current user.
      */
-    resendVerificationCode(): Promise<void>;
-    /**
-     * Resend a verification SMS for the current user.
-     */
-    resendVerificationCodeByPhone(): Promise<void>;
-    /**
-     * Returns a URL for setting up a new WebAuth passkey.
-     * @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.
-     * @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.
-     * @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>;
+    resendVerificationCode(): CoreMethodResponse<'resendVerificationCode'>;
     /**
      * Checks if the current session is active.
      * @returns `true` if active, `false` otherwise
      */
-    isSessionActive(): Promise<boolean>;
+    isSessionActive(): CoreMethodResponse<'isSessionActive'>;
     /**
      * Checks if a session is active and a wallet exists.
      * @returns `true` if active, `false` otherwise
      **/
-    isFullyLoggedIn(): Promise<boolean>;
-    protected supportedAuthMethods(auth: Auth): Promise<Set<AuthMethod>>;
+    isFullyLoggedIn(): CoreMethodResponse<'isFullyLoggedIn'>;
+    protected supportedAuthMethods(auth: Auth<PrimaryAuthType | 'userId'>): Promise<Set<AuthMethod>>;
     /**
      * Get hints associated with the users stored biometrics.
+     * @deprecated
      * @returns Array containing useragents and AAGuids for stored biometrics
      */
     protected getUserBiometricLocationHints(): Promise<BiometricLocationHint[]>;
-    private setAuth;
-    /**
-     * Initiates a login.
-     * @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 }: Auth & {
-        useShortUrl?: boolean;
-    }): Promise<string>;
-    /**
-     * Initiates a login.
-     * @param email - the email to login with
-     * @returns - a set of supported auth methods for the user
-     **/
-    initiateUserLoginV2(auth: Auth): Promise<Set<AuthMethod>>;
-    /**
-     * Initiates a login.
-     * @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>;
-    /**
-     * Waits for the session to be active.
-     **/
-    waitForAccountCreation({ popupWindow }?: {
-        popupWindow?: Window;
-    }): Promise<boolean>;
-    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.
-     * @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.
-     * @return {Object} `{userExists: boolean; username: string; pfpUrl?: string | null }` - the user's information and whether the user already exists.
-     */
-    waitForFarcasterStatus(): Promise<{
-        userExists: boolean;
-        username: string;
-        pfpUrl?: string | null;
-    }>;
-    /**
-     * Generates a URL for the user to log in with OAuth using a desire method.
-     *
-     * @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.
-     *
-     * @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;
-    }): Promise<{
-        email?: string;
-        isError?: boolean;
-        userExists: boolean;
-    }>;
-    /**
-     * Waits for the session to be active and sets up the user.
-     *
-     * @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;
-        skipSessionRefresh?: boolean;
-    }): Promise<LoginResponse>;
     /**
      * Updates the session with the user management server, possibly
      * opening a popup to refresh the session.
@@ -631,20 +347,12 @@ export declare abstract class ParaCore {
      * @param {boolean} [shouldOpenPopup] - if `true`, the running device will open a popup to reauthenticate the user.
      * @returns a URL for the user to reauthenticate.
      **/
-    refreshSession({ shouldOpenPopup }?: {
-        shouldOpenPopup?: boolean;
-    }): Promise<string>;
+    refreshSession({ shouldOpenPopup, }?: CoreMethodParams<'refreshSession'>): CoreMethodResponse<'refreshSession'>;
     /**
      * Call this method after login to ensure that the user ID is set
      * internally.
      **/
-    protected userSetupAfterLogin(): Promise<{
-        data: {
-            partnerId?: string;
-            needsWallet?: boolean;
-            sessionLookupId: string;
-        };
-    }>;
+    protected userSetupAfterLogin(): Promise<SessionInfo>;
     /**
      * Get transmission shares associated with session.
      * @param {Object} opts the options object.
@@ -660,7 +368,7 @@ export declare abstract class ParaCore {
      * @param {any[]} opts.temporaryShares optional temporary shares to use for decryption.
      * @param {boolean} [opts.skipSessionRefresh] - whether or not to skip refreshing the session.
      **/
-    setupAfterLogin({ temporaryShares, skipSessionRefresh, }?: {
+    protected setupAfterLogin({ temporaryShares, skipSessionRefresh, }?: {
         temporaryShares?: any[];
         skipSessionRefresh?: boolean;
     }): Promise<void>;
@@ -673,12 +381,7 @@ export declare abstract class ParaCore {
      * @param {boolean} opts.forceRefreshRecovery whether or not to force recovery secret regeneration. Used when regenerating recovery shares.
      * @returns {string} the recovery share.
      **/
-    distributeNewWalletShare({ walletId, userShare, skipBiometricShareCreation, forceRefresh, }: {
-        walletId: string;
-        userShare?: string;
-        skipBiometricShareCreation?: boolean;
-        forceRefresh?: boolean;
-    }): Promise<string>;
+    distributeNewWalletShare({ walletId, userShare, skipBiometricShareCreation, forceRefresh, }: CoreMethodParams<'distributeNewWalletShare'>): CoreMethodResponse<'distributeNewWalletShare'>;
     private waitForWalletAddress;
     /**
      * Waits for a pregen wallet address to be created.
@@ -697,14 +400,7 @@ export declare abstract class ParaCore {
      *
      * @deprecated alias for `createWalletPerType`
      **/
-    createWalletPerMissingType: ({ skipDistribute, types, }?: {
-        skipDistribute?: boolean;
-        types?: WalletType[];
-    }) => Promise<{
-        wallets: Wallet[];
-        walletIds: CurrentWalletIds;
-        recoverySecret?: string;
-    }>;
+    createWalletPerMissingType: ({ skipDistribute, types, }?: CoreMethodParams<'createWalletPerType'>) => CoreMethodResponse<'createWalletPerType'>;
     /**
      * Creates several new wallets with the desired types. If no types are provided, this method
      * will create one for each of the non-optional types specified in the instance's `supportedWalletTypes`
@@ -716,14 +412,7 @@ export declare abstract class ParaCore {
      * @param {WalletType[]} [opts.types] the types of wallets to create.
      * @returns {Object} the wallets created, their ids, and the recovery secret.
      **/
-    createWalletPerType({ skipDistribute, types, }?: {
-        skipDistribute?: boolean;
-        types?: WalletType[];
-    }): Promise<{
-        wallets: Wallet[];
-        walletIds: CurrentWalletIds;
-        recoverySecret?: string;
-    }>;
+    createWalletPerType({ skipDistribute, types, }?: CoreMethodParams<'createWalletPerType'>): CoreMethodResponse<'createWalletPerType'>;
     /**
      * Refresh the current user share for a wallet.
      *
@@ -736,19 +425,7 @@ export declare abstract class ParaCore {
      * @param {boolean} [opts.redistributeBackupEncryptedShares] whether or not to redistribute backup encrypted shares.
      * @returns {Object} the new user share and recovery secret.
      **/
-    refreshShare({ walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId, redistributeBackupEncryptedShares, }: {
-        walletId: string;
-        share: string;
-        oldPartnerId?: string;
-        newPartnerId?: string;
-        keyShareProtocolId?: string;
-        redistributeBackupEncryptedShares?: boolean;
-        emailProps?: BackupKitEmailProps;
-    }): Promise<{
-        signer: string;
-        recoverySecret?: string;
-        protocolId: string;
-    }>;
+    refreshShare({ walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId, redistributeBackupEncryptedShares, }: CoreMethodParams<'refreshShare'>): CoreMethodResponse<'refreshShare'>;
     /**
      * Creates a new wallet.
      * @param {Object} opts the options object.
@@ -756,99 +433,20 @@ export declare abstract class ParaCore {
      * @param {boolean} opts.skipDistribute - if true, recovery share will not be distributed.
      * @returns {[Wallet, string | null]} `[wallet, recoveryShare]` - the wallet object and the new recovery share.
      **/
-    createWallet({ type: _type, skipDistribute, }?: {
-        type?: WalletType;
-        skipDistribute?: boolean;
-    }): Promise<[Wallet, string | null]>;
-    /**
-     * Creates a new pregenerated wallet.
-     *
-     * @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.
-     * @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.
-     *
-     * @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.
-     * @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.
-     * @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.
-     * @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[]>;
+    createWallet({ type: _type, skipDistribute, }?: CoreMethodParams<'createWallet'>): CoreMethodResponse<'createWallet'>;
     private encodeWalletBase64;
     /**
      * Encodes the current wallets encoded in Base 64.
      * @returns {string} the encoded wallet string
      **/
-    getUserShare(): string | null;
+    getUserShare(): CoreMethodResponse<'getUserShare'>;
     /**
      * Sets the current wallets from a Base 64 string.
      * @param {string} base64Wallet the encoded wallet string
      **/
-    setUserShare(base64Wallets: string | null): Promise<void>;
+    setUserShare(base64Wallets: CoreMethodParams<'setUserShare'>): CoreMethodResponse<'setUserShare'>;
     private getTransactionReviewUrl;
     private getOnRampTransactionUrl;
-    getWalletBalance: ({ walletId, rpcUrl }: GetWalletBalanceParams) => Promise<string | undefined>;
     /**
      * Signs a message using one of the current wallets.
      *
@@ -860,12 +458,7 @@ export declare abstract class ParaCore {
      * @param {number} [opts.timeout] optional timeout in milliseconds. If not present, defaults to 30 seconds.
      * @param {string} [opts.cosmosSignDocBase64] the Cosmos `SignDoc` in base64, if applicable
      **/
-    signMessage({ walletId, messageBase64, timeoutMs, cosmosSignDocBase64, }: {
-        walletId: string;
-        messageBase64: string;
-        timeoutMs?: number;
-        cosmosSignDocBase64?: string;
-    }): Promise<FullSignatureRes>;
+    signMessage({ walletId, messageBase64, timeoutMs, cosmosSignDocBase64, isCanceled, onCancel, onPoll, }: CoreMethodParams<'signMessage'>): CoreMethodResponse<'signMessage'>;
     private signMessageInner;
     /**
      * Signs a transaction.
@@ -875,24 +468,7 @@ export declare abstract class ParaCore {
      * @param {string} [opts.chainId] the EVM chain id of the chain the transaction is being sent on, if applicable
      * @param {number} [opts.timeoutMs] the amount of time to wait for the user to sign the transaction, in milliseconds
      **/
-    signTransaction({ walletId, rlpEncodedTxBase64, chainId, timeoutMs, }: {
-        walletId: string;
-        rlpEncodedTxBase64: string;
-        chainId: string;
-        timeoutMs?: number;
-    }): Promise<FullSignatureRes>;
-    /**
-     * @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>;
+    signTransaction({ walletId, rlpEncodedTxBase64, chainId, timeoutMs, isCanceled, onCancel, onPoll, }: CoreMethodParams<'signTransaction'>): CoreMethodResponse<'signTransaction'>;
     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.
@@ -902,40 +478,41 @@ export declare abstract class ParaCore {
      * @param {string} opts.walletId the wallet ID to use for the transaction, where funds will be sent or withdrawn.
      * @param {string} opts.externalWalletAddress the external wallet address to send funds to or withdraw funds from, if using an external wallet.
      **/
-    initiateOnRampTransaction(options: WalletParams & {
-        params: OnRampPurchaseCreateParams;
-        shouldOpenPopup?: boolean;
-    }): Promise<{
-        onRampPurchase: OnRampPurchase;
-        portalUrl: string;
-    }>;
+    initiateOnRampTransaction(options: CoreMethodParams<'initiateOnRampTransaction'>): CoreMethodResponse<'initiateOnRampTransaction'>;
     /**
      * Returns `true` if session was successfully kept alive, `false` otherwise.
      **/
     keepSessionAlive(): Promise<boolean>;
     /**
      * Serialize the current session for import by another Para instance.
-     * @param {boolean} excludeSigners - whether or not to exclude the signer from the exported wallets.
      * @returns {string} the serialized session
      */
-    exportSession({ excludeSigners }?: {
-        excludeSigners?: boolean;
-    }): string;
+    exportSession(): CoreMethodResponse<'exportSession'>;
     /**
      * Imports a session serialized by another Para instance.
      * @param {string} serializedInstanceBase64 the serialized session
      */
-    importSession(serializedInstanceBase64: string): Promise<void>;
-    protected exitAccountCreation(): void;
-    protected exitLogin(): void;
-    protected exitFarcaster(): void;
-    protected exitOAuth(): void;
-    protected exitLoops(): void;
+    importSession(serializedInstanceBase64: CoreMethodParams<'importSession'>): CoreMethodResponse<'importSession'>;
+    /**
+     * @deprecated
+     */
+    /**
+     * @deprecated
+     */
+    /**
+     * @deprecated
+     */
+    /**
+     * @deprecated
+     */
+    /**
+     * @deprecated
+     */
     /**
      * Retrieves a token to verify the current session.
      * @returns {Promise<string>} the ID
      **/
-    getVerificationToken(): Promise<string>;
+    getVerificationToken(): CoreMethodResponse<'getVerificationToken'>;
     /**
      * Logs the user out.
      * @param {Object} opts the options object.
@@ -944,6 +521,7 @@ export declare abstract class ParaCore {
     logout({ clearPregenWallets }?: {
         clearPregenWallets?: boolean;
     }): Promise<void>;
+    /** @deprecated */
     protected getSupportedCreateAuthMethods(): Promise<Set<AuthMethod>>;
     /**
      * Converts to a string, removing sensitive data when logging this class.
@@ -951,4 +529,115 @@ export declare abstract class ParaCore {
      * Doesn't work for all types of logging.
      **/
     toString(): string;
+    /** NEW METHODS */
+    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'>;
+    /**
+     * 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'>;
+    /**
+     * Waits for the session to be active and sets up the user.
+     *
+     * @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
+     **/
+    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'>;
+    /**
+     * Performs 2FA verification.
+     * @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({ auth, verificationCode }: CoreMethodParams<'verify2fa'>): CoreMethodResponse<'verify2fa'>;
+    /**
+     * Sets up two-factor authentication for the current user.
+     * @returns {string} uri - uri to use for setting up 2FA
+     * */
+    setup2fa(): CoreMethodResponse<'setup2fa'>;
+    /**
+     * Enables 2FA.
+     * @param {Object} opts the options object
+     * @param {string} opts.verificationCode - the verification code received via 2FA.
+     */
+    enable2fa({ verificationCode }: CoreMethodParams<'enable2fa'>): CoreMethodResponse<'enable2fa'>;
+    /**
+     * Creates a new pregenerated wallet.
+     *
+     * @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: CoreMethodParams<'createPregenWallet'>): CoreMethodResponse<'createPregenWallet'>;
+    /**
+     * 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.
+     * @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, pregenId, }: CoreMethodParams<'createPregenWalletPerType'>): CoreMethodResponse<'createPregenWalletPerType'>;
+    /**
+     * Claims a pregenerated wallet.
+     * @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({ pregenId, }?: CoreMethodParams<'claimPregenWallets'>): CoreMethodResponse<'claimPregenWallets'>;
+    /**
+     * Updates the identifier for a pregen wallet.
+     * @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, newPregenId, }: CoreMethodParams<'updatePregenWalletIdentifier'>): CoreMethodResponse<'updatePregenWalletIdentifier'>;
+    /**
+     * Checks if a pregen Wallet exists for the given identifier with the current partner.
+     * @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({ pregenId }: CoreMethodParams<'hasPregenWallet'>): CoreMethodResponse<'hasPregenWallet'>;
+    /**
+     * Get pregen wallets for the given identifier.
+     * @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({ pregenId }?: CoreMethodParams<'getPregenWallets'>): CoreMethodResponse<'getPregenWallets'>;
 }