@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/types/services/types/ExternalWalletServiceTypes.d.ts

@@ -0,0 +1,67 @@
+import type { ExternalWalletInfo, TExternalWalletType } from '@getpara/user-management-client';
+import type { Wallet } from '../../types/wallet';
+import type { ConnectExternalWalletParams } from './AuthServiceTypes';
+export type ExternalWallets = Record<string, Wallet>;
+export type ExternalWalletConnectionType = 'NONE' | 'CONNECTION_ONLY' | 'AUTHENTICATED' | 'VERIFICATION';
+export type SetExternalWalletParams = {
+    externalWallet: ExternalWalletInfo[] | ExternalWalletInfo;
+};
+export type SetExternalWalletMethod = (_: SetExternalWalletParams) => Promise<void>;
+export type SetExternalWalletsParams = {
+    externalWallets: Record<string, Wallet> | ((current: Record<string, Wallet>) => Record<string, Wallet>);
+};
+export type SetExternalWalletsMethod = (_: SetExternalWalletsParams) => Promise<void>;
+export type AddExternalWalletsParams = {
+    externalWallets: ExternalWalletInfo[];
+};
+export type AddExternalWalletsMethod = (_: AddExternalWalletsParams) => Promise<void>;
+export interface PerformConnectExternalWalletResponse {
+    externalWallet: ExternalWalletInfo;
+    chainId: string;
+}
+export type PerformConnectExternalWalletMethod = (_: ConnectExternalWalletParams) => Promise<PerformConnectExternalWalletResponse>;
+export interface ExternalWalletInterface {
+    address: string | null;
+}
+export interface WatchWalletChangeCallbackParams {
+    /**
+     * The external wallet information to use for login.
+     */
+    externalWallet: Pick<ExternalWalletInfo, 'address' | 'type' | 'provider' | 'providerId'>;
+}
+export interface BaseExternalWalletProviderInterface {
+    disconnect: () => Promise<void>;
+    getAddress: () => Promise<string | null>;
+    connectParaConnector: () => Promise<void>;
+    signMessage: (_: {
+        message: string;
+        address: string;
+    }) => Promise<Omit<SignMessageResponse, 'address'>>;
+    watchDisconnection: (callback: () => Promise<void>) => () => void;
+    watchWalletChange: (callback: (_: WatchWalletChangeCallbackParams) => void) => () => void;
+}
+export interface InitExternalWalletProviderParams {
+    type: TExternalWalletType;
+    interface: BaseExternalWalletProviderInterface;
+}
+export type InitExternalWalletProviderMethod = (_: InitExternalWalletProviderParams) => Promise<void>;
+export type ExternalSignMessageParams = {
+    type: TExternalWalletType;
+    address: string;
+    message: string;
+};
+export interface SignMessageResponse {
+    address: string;
+    signature: string;
+    cosmosPublicKeyHex?: string;
+    cosmosSigner?: string;
+    addressBech32?: string;
+}
+export type SignMessageMethod = (_: ExternalSignMessageParams) => Promise<SignMessageResponse>;
+export type SwitchExternalWalletParams = WatchWalletChangeCallbackParams;
+export type SwitchExternalWalletMethod = (_: SwitchExternalWalletParams) => Promise<void>;
+export type PerformSwitchExternalWalletParams = WatchWalletChangeCallbackParams;
+export interface PerformSwitchExternalWalletResponse {
+    externalWallet: ExternalWalletInfo;
+}
+export type PerformSwitchExternalWalletMethod = (_: PerformSwitchExternalWalletParams) => Promise<PerformSwitchExternalWalletResponse>;

package/dist/types/services/types/LoginFlowServiceTypes.d.ts

@@ -0,0 +1,19 @@
+import type { PollingCallbacks } from './PollingServiceTypes';
+export type PrepareLoginMethod = () => Promise<string>;
+export interface WaitForLoginParams extends PollingCallbacks {
+    /**
+     * Whether to skip the session refresh
+     */
+    skipSessionRefresh?: boolean;
+}
+export interface WaitForLoginResponse {
+    /**
+     * Whether the signed-in user still needs to create one or more wallets for this application.
+     */
+    needsWallet?: boolean;
+    /**
+     * The partner ID for the current application.
+     */
+    partnerId?: string;
+}
+export type WaitForLoginMethod = (_: WaitForLoginParams) => Promise<WaitForLoginResponse>;

package/dist/types/services/types/PollingServiceTypes.d.ts

@@ -0,0 +1,82 @@
+import type { ServerAuthState, TOAuthMethod } from '@getpara/user-management-client';
+import type { ActorRef } from 'xstate';
+import type { WithCustomTheme, WithUseShortUrls } from '../../types/index.js';
+import { BaseOAuthUrlParams } from './PortalUrlServiceTypes.js';
+import { AuthenticationOutput } from '../../state/types/auth.js';
+import { OAuthRedirectCallbacks } from './AuthServiceTypes.js';
+export type PollingCallbacks = {
+    /**
+     * Callback fired on each poll attempt.
+     */
+    onPoll?: () => void;
+    /**
+     * Callback fired when the polling is canceled.
+     */
+    onCancel?: () => void;
+    /**
+     * Signal to cancel the polling.
+     */
+    isCanceled?: () => boolean;
+};
+export interface PollingConfig<T> extends PollingCallbacks {
+    init?: () => Promise<void>;
+    checkCondition: PollFunction<T>;
+    maxPolls?: number;
+    intervalMs?: number;
+    timeoutMs?: number;
+    id?: string;
+}
+export type PollingResult<T> = {
+    type: 'COMPLETE';
+    data: T;
+} | {
+    type: 'CANCEL';
+} | {
+    type: 'ERROR';
+    error: 'TIMEOUT' | 'MAX_POLLS_EXCEEDED' | 'INITIALIZATION_FAILED';
+};
+export type PollFunction<T> = () => Promise<{
+    finished: boolean;
+    data?: T;
+}>;
+export interface WaitForOAuthEventParams extends WithCustomTheme, WithUseShortUrls, OAuthRedirectCallbacks {
+    method: Extract<TOAuthMethod, 'FARCASTER' | 'TELEGRAM'>;
+    isCanceled?: PollingCallbacks['isCanceled'];
+    appScheme?: BaseOAuthUrlParams['appScheme'];
+}
+export type WaitForOAuthEventResponse = AuthenticationOutput;
+export type WaitForOAuthEventMethod = (_: WaitForOAuthEventParams) => Promise<WaitForOAuthEventResponse>;
+export interface WaitForTelegramEventParams extends WaitForOAuthEventParams {
+}
+export type WaitForTelegramEventResponse = AuthenticationOutput;
+export type WaitForTelegramEventMethod = (_: WaitForTelegramEventParams) => Promise<WaitForTelegramEventResponse>;
+export interface WaitForFarcasterEventParams extends WaitForOAuthEventParams {
+}
+export type WaitForFarcasterEventResponse = AuthenticationOutput;
+export type WaitForFarcasterEventMethod = (_: WaitForFarcasterEventParams) => Promise<WaitForFarcasterEventResponse>;
+export interface InitOAuthPollingParams extends WithCustomTheme, WithUseShortUrls, BaseOAuthUrlParams, OAuthRedirectCallbacks {
+}
+export interface InitOAuthPollingResponse {
+    sessionLookupId: string;
+}
+export type InitOAuthPollingMethod = (_: InitOAuthPollingParams) => Promise<InitOAuthPollingResponse>;
+export interface WaitForFarcasterAuthParams {
+    onSuccess: (serverAuthState: ServerAuthState) => void;
+}
+export type WaitForFarcasterAuthMethod = (_: WaitForFarcasterAuthParams) => PollFunction<null>;
+export interface WaitForOAuthParams {
+    onSuccess: (serverAuthState: ServerAuthState) => void;
+}
+export type WaitForOAuthMethod = (_: WaitForOAuthParams) => PollFunction<null>;
+export interface WaitForWalletsParams {
+    parent: ActorRef<any, any>;
+}
+export type WaitForWalletsMethod = (_: WaitForWalletsParams) => PollFunction<null>;
+export interface WaitForWalletAddressParams {
+    walletId: string;
+}
+export type WaitForWalletAddressMethod = (_: WaitForWalletAddressParams) => PollFunction<null>;
+export interface WaitForPregenWalletAddressParams {
+    walletId: string;
+}
+export type WaitForPregenWalletAddressMethod = (_: WaitForPregenWalletAddressParams) => PollFunction<null>;

package/dist/types/services/types/PortalUrlServiceTypes.d.ts

@@ -0,0 +1,46 @@
+import type { TAuthMethod, Theme, TOAuthMethod } from '@getpara/user-management-client';
+import type { AccountLinkInProgress, WithAuthMethod, WithCustomTheme, WithSessionId, WithShorten } from '../../types/index.js';
+type Device = {
+    sessionId: string;
+    encryptionKey: string;
+};
+export type PortalUrlType = 'createAuth' | 'createPassword' | 'loginAuth' | 'loginPassword' | 'txReview' | 'onRamp' | 'telegramLogin' | 'createPIN' | 'loginPIN' | 'oAuth' | 'oAuthCallback' | 'loginOTP' | 'telegramLoginVerify' | 'loginFarcaster' | 'switchWallets' | 'addNewCredential' | 'exportPrivateKey' | 'loginExternalWallet' | 'connectExternalWallet';
+export type PortalUrlOptions = {
+    params?: Record<string, string | undefined | null>;
+    isForNewDevice?: boolean;
+    thisDevice?: Device;
+    newDevice?: Device;
+    sessionId?: string;
+    portalTheme?: Theme;
+    pathId?: string;
+    shorten?: boolean;
+    isEmbedded?: boolean;
+    oAuthMethod?: GetOAuthUrlParams['method'];
+    appScheme?: string;
+    encryptionKey?: string;
+    addNewCredentialType?: TAuthMethod;
+    addNewCredentialPasswordId?: string;
+    addNewCredentialPasskeyId?: string;
+    useLegacyUrl?: boolean;
+};
+export type ConstructPortalUrlMethod = (type: PortalUrlType, opts?: PortalUrlOptions) => Promise<string>;
+export type GetLoginUrlParams = WithAuthMethod & WithCustomTheme & WithShorten & WithSessionId;
+export type GetLoginUrlMethod = (_: GetLoginUrlParams) => Promise<string>;
+export type BaseOAuthUrlParams = {
+    /**
+     * The third-party OAuth service.
+     */
+    method: Exclude<TOAuthMethod, 'TELEGRAM' | 'FARCASTER'>;
+    /**
+     * The app scheme to redirect to after OAuth is complete.
+     */
+    appScheme?: string;
+};
+export interface GetOAuthUrlParams extends BaseOAuthUrlParams {
+    sessionLookupId?: string;
+    encryptionKey?: string;
+    portalCallbackParams?: Record<string, string>;
+    accountLinkInProgress?: AccountLinkInProgress;
+}
+export type GetOAuthUrlMethod = (_: GetOAuthUrlParams) => Promise<string>;
+export {};

package/dist/types/services/types/PregenWalletServiceTypes.d.ts

@@ -0,0 +1,73 @@
+import type { CurrentWalletIds, PregenAuth, PregenOrGuestAuth, ServerAuthState, TWalletType, WalletEntity } from '@getpara/user-management-client';
+import type { Wallet } from '../../types';
+export interface FetchPregenWalletsFromOverrideParams {
+    authInfo: ServerAuthState['auth'];
+}
+export type FetchPregenWalletsFromOverrideMethod = (_: FetchPregenWalletsFromOverrideParams) => Promise<void>;
+export interface ClaimPregenWalletsParams {
+    /**
+     * The pregen identifier for the wallet to claim. If not provided, will attempt to claim all wallets in storage.
+     */
+    pregenId?: PregenAuth;
+}
+export type ClaimPregenWalletsResponse = string | undefined;
+export type ClaimPregenWalletsMethod = (_?: ClaimPregenWalletsParams) => Promise<ClaimPregenWalletsResponse>;
+export interface PerformClaimPregenWalletsResponse {
+    walletIds: CurrentWalletIds;
+    recoverySecret: string | undefined;
+}
+export type PerformClaimPregenWalletsMethod = () => Promise<PerformClaimPregenWalletsResponse>;
+export interface GetPregenWalletsParams {
+    /**
+     * The pregen ID for the wallets to fetch. If not provided, all available wallets will be retrieved.
+     */
+    pregenId?: PregenAuth;
+}
+export type GetPregenWalletsResponse = WalletEntity[];
+export type GetPregenWalletsMethod = (_?: GetPregenWalletsParams) => Promise<GetPregenWalletsResponse>;
+export interface CreatePregenWalletParams {
+    /**
+     * The type of wallet to create, 'EVM' | 'SOLANA' | 'COSMOS'
+     */
+    type: TWalletType;
+    /**
+     * The pregen identifier for the wallet, in the form: `{ email: string } | { phone: string } | { telegramUserId: string } | { farcasterUsername: string } | { xUsername: string } | { discordUsername: string } | { customId: string }`
+     */
+    pregenId: PregenOrGuestAuth;
+}
+export type CreatePregenWalletResponse = Wallet;
+export type CreatePregenWalletMethod = (_: CreatePregenWalletParams) => Promise<CreatePregenWalletResponse>;
+export interface CreatePregenWalletPerTypeParams {
+    /**
+     * The wallet types to create. If not provided, defaults to your application's `supportedWalletTypes` setting.
+     */
+    types?: TWalletType[];
+    /**
+     * The pregen identifier for the wallets, in the form: `{ email: string } | { phone: string } | { telegramUserId: string } | { farcasterUsername: string } | { xUsername: string } | { discordUsername: string } | { customId: string }`
+     */
+    pregenId: PregenAuth;
+}
+export type CreatePregenWalletPerTypeResponse = Wallet[];
+export type CreatePregenWalletPerTypeMethod = (_: CreatePregenWalletPerTypeParams) => Promise<CreatePregenWalletPerTypeResponse>;
+export interface UpdatePregenWalletIdentifierParams {
+    /**
+     * The ID of the pregen wallet to update.
+     */
+    walletId: string;
+    /**
+     * The new identifier for the wallet.
+     */
+    newPregenId: PregenAuth;
+}
+export type UpdatePregenWalletIdentifierMethod = (_: UpdatePregenWalletIdentifierParams) => Promise<void>;
+export interface HasPregenWalletParams {
+    /**
+     * The pregen ID for the wallet to check.
+     */
+    pregenId: PregenAuth;
+}
+export type HasPregenWalletMethod = (_: HasPregenWalletParams) => Promise<boolean>;
+export type CreateGuestWalletsResponse = Wallet[];
+export type CreateGuestWalletsMethod = () => Promise<CreateGuestWalletsResponse>;
+export type PerformCreateGuestWalletsResponse = Wallet[];
+export type PerformCreateGuestWalletsMethod = () => Promise<PerformCreateGuestWalletsResponse>;

package/dist/types/services/types/SessionManagementServiceTypes.d.ts

@@ -0,0 +1,27 @@
+import { SessionInfo } from '@getpara/user-management-client';
+export type TouchSessionMethod = (_?: boolean) => Promise<SessionInfo>;
+export type IsSessionActiveMethod = () => Promise<boolean>;
+export type IsFullyLoggedInMethod = () => Promise<boolean>;
+export interface RefreshSessionParams {
+    shouldOpenPopup?: boolean;
+}
+export type RefreshSessionMethod = (_?: RefreshSessionParams) => Promise<string>;
+export type KeepSessionAliveMethod = () => Promise<boolean>;
+export type GetVerificationTokenMethod = () => Promise<string>;
+export interface IssueJwtParams {
+    /**
+     * The index of the Para RSA keypair to use for signing the JWT. Defaults to `0`.
+     */
+    keyIndex?: number;
+}
+export interface IssueJwtResponse {
+    /**
+     * The Para JWT token.
+     */
+    token: string;
+    /**
+     * The `keyid`` / `kid` of the keypair used to sign the JWT.
+     */
+    keyId: string;
+}
+export type IssueJwtMethod = (_?: IssueJwtParams) => Promise<IssueJwtResponse>;

package/dist/types/services/types/SignupFlowServiceTypes.d.ts

@@ -0,0 +1,18 @@
+import type { CurrentWalletIds } from '@getpara/user-management-client';
+import type { PollingCallbacks } from './PollingServiceTypes';
+export interface WaitForSignupParams extends PollingCallbacks {
+}
+export type WaitForSignupMethod = (_: WaitForSignupParams) => Promise<true>;
+export interface WaitForWalletCreationParams extends PollingCallbacks {
+}
+export interface WaitForWalletCreationResponse {
+    /**
+     * The IDs of the newly created wallets.
+     */
+    walletIds: CurrentWalletIds;
+    /**
+     * The recovery secret for the new wallets, if available.
+     */
+    recoverySecret?: string;
+}
+export type WaitForWalletCreationMethod = (_?: WaitForWalletCreationParams) => Promise<WaitForWalletCreationResponse>;

package/dist/types/services/types/VerificationFlowServiceTypes.d.ts

@@ -0,0 +1,90 @@
+import type { ExternalWalletInfo, ServerAuthState, ServerAuthStateDone, ServerAuthStateLogin, ServerAuthStateSignup, TelegramAuthResponse, VerifyThirdPartyAuth } from '@getpara/user-management-client';
+import type { AuthStateDone, AuthStateLogin, AuthStateSignup, OAuthResponse, WithCustomTheme, WithUseShortUrls } from '../../types';
+import type { PollingCallbacks } from './PollingServiceTypes';
+export interface VerifyNewAccountParams extends WithCustomTheme, WithUseShortUrls {
+    /**
+     * The verification code entered by the user.
+     */
+    verificationCode: string;
+}
+export type VerifyNewAccountResponse = AuthStateSignup;
+export type VerifyNewAccountMethod = (_: VerifyNewAccountParams) => Promise<VerifyNewAccountResponse>;
+export interface PerformVerifyNewAccountParams extends VerifyNewAccountParams {
+}
+interface PerformVerifyNewAccountResponse {
+    authState: ServerAuthStateSignup;
+    opts: WithCustomTheme & WithUseShortUrls;
+}
+export type PerformVerifyNewAccountMethod = (_: PerformVerifyNewAccountParams) => Promise<PerformVerifyNewAccountResponse>;
+export interface BaseVerifyExternalWalletParams {
+    /**
+     * The external wallet information to verify.
+     */
+    externalWallet: ExternalWalletInfo;
+    /**
+     * The signature of the signed verification string.
+     * If not provided, the signing of the `signatureVerificationMessage` message will be triggered.
+     */
+    signedMessage?: string;
+    /**
+     * The message that should be signed to verify ownership of the external wallet.
+     */
+    signatureVerificationMessage?: string;
+    /**
+     * For Cosmos wallets, the wallet's public key as a hex string.
+     */
+    cosmosPublicKeyHex?: string;
+    /**
+     * For Cosmos wallets, the base64 signer string.
+     */
+    cosmosSigner?: string;
+    /**
+     * Session lookup ID used from the Para portal requests to obtain the original user session.
+     */
+    sessionLookupId?: string;
+}
+export type VerifyExternalWalletParams = WithCustomTheme & WithUseShortUrls & ({
+    serverAuthState: ServerAuthStateSignup | ServerAuthStateLogin | ServerAuthStateDone;
+} | ({
+    serverAuthState?: undefined;
+} & BaseVerifyExternalWalletParams));
+export type VerifyExternalWalletResponse = AuthStateSignup | AuthStateLogin | AuthStateDone;
+export type VerifyExternalWalletMethod = (_: VerifyExternalWalletParams) => Promise<VerifyExternalWalletResponse>;
+export type RetryVerifyExternalWalletMethod = () => Promise<VerifyExternalWalletResponse>;
+export interface PerformVerifyExternalWalletResponse {
+    authState: ServerAuthState;
+    opts: WithCustomTheme & WithUseShortUrls;
+    sessionLookupId?: string;
+}
+export type PerformVerifyExternalWalletMethod = (_: VerifyExternalWalletParams) => Promise<PerformVerifyExternalWalletResponse>;
+export interface VerifyTelegramParams extends WithCustomTheme, WithUseShortUrls {
+    /**
+     * The response received from the Telegram login bot.
+     */
+    telegramAuthResponse?: TelegramAuthResponse;
+    serverAuthState?: VerifyThirdPartyAuth;
+}
+export type VerifyTelegramMethod = (_: VerifyTelegramParams) => Promise<OAuthResponse>;
+export interface PerformVerifyTelegramResponse {
+    authState: ServerAuthState;
+    opts: WithCustomTheme & WithUseShortUrls;
+    sessionLookupId?: string;
+}
+export type PerformVerifyTelegramMethod = (_: VerifyTelegramParams) => Promise<PerformVerifyTelegramResponse>;
+export interface VerifyFarcasterParams extends WithCustomTheme, WithUseShortUrls, PollingCallbacks {
+    /**
+     * A callback function that will be invoked with the Farcaster Connect URI when it is available.
+     * You will need to display the URI as a QR code.
+     */
+    onConnectUri?: (uri: string) => void;
+    serverAuthState?: VerifyThirdPartyAuth;
+}
+export type VerifyFarcasterResponse = OAuthResponse;
+export type VerifyFarcasterMethod = (_: VerifyFarcasterParams) => Promise<VerifyFarcasterResponse>;
+export interface PerformVerifyFarcasterResponse {
+    authState?: ServerAuthState;
+    opts: WithCustomTheme & WithUseShortUrls;
+    sessionLookupId?: string;
+}
+export type PerformVerifyFarcasterMethod = (_: VerifyFarcasterParams) => Promise<PerformVerifyFarcasterResponse>;
+export {};

package/dist/types/services/types/WalletServiceTypes.d.ts

@@ -0,0 +1,109 @@
+import type { BackupKitEmailProps, CurrentWalletIds, TWalletType, WalletEntity } from '@getpara/user-management-client';
+import type { Wallet, WalletFilters, WalletNoSigner } from '../../types';
+export type SetWalletsParams = Record<string, Wallet>;
+export type SetWalletsMethod = (_: SetWalletsParams) => Promise<void>;
+export interface RefreshShareParams {
+    walletId: string;
+    share: string;
+    oldPartnerId?: string;
+    newPartnerId?: string;
+    keyShareProtocolId?: string;
+    redistributeBackupEncryptedShares?: boolean;
+    emailProps?: BackupKitEmailProps;
+}
+export interface RefreshShareResponse {
+    protocolId: string;
+    recoverySecret?: string;
+    signer: string;
+}
+export type RefreshShareMethod = (_: RefreshShareParams) => Promise<RefreshShareResponse>;
+export type GetTypesToCreateMethod = (_?: Uppercase<TWalletType>[]) => Promise<TWalletType[]>;
+interface SetCurrentWalletIdsOptions {
+    needsWallet?: boolean;
+    sessionLookupId?: string;
+    newDeviceSessionLookupId?: string;
+}
+export type SetCurrentWalletIdsParams = [CurrentWalletIds, SetCurrentWalletIdsOptions?];
+export type SetCurrentWalletIdsMethod = (...params: SetCurrentWalletIdsParams) => Promise<void>;
+export interface CreateWalletParams {
+    type?: Uppercase<TWalletType>;
+    skipDistribute?: boolean;
+}
+export type CreateWalletResponse = [Wallet, string | undefined];
+export type CreateWalletMethod = (_?: CreateWalletParams) => Promise<CreateWalletResponse>;
+export interface CreateWalletPerTypeParams {
+    /**
+     * Array of the wallet types to create
+     */
+    types?: Uppercase<TWalletType>[];
+    /**
+     * If `true`, skip distributing the new wallets shares.
+     */
+    skipDistribute?: boolean;
+}
+export interface CreateWalletPerTypeResponse {
+    /**
+     * Array of the created wallets
+     */
+    wallets: Wallet[];
+    /**
+     * The `CurrentWalletIds` value for the new wallets
+     */
+    walletIds: CurrentWalletIds;
+    /**
+     * The recovery secret for the new wallets, if available.
+     */
+    recoverySecret?: string;
+}
+export type CreateWalletPerTypeMethod = (_?: CreateWalletPerTypeParams) => Promise<CreateWalletPerTypeResponse>;
+export type FindWalletIdParams = [string?, WalletFilters?];
+export type FindWalletIdMethod = (...params: FindWalletIdParams) => string;
+export type FindWalletByAddressParams = [string?, WalletFilters?];
+export type FindWalletByAddressMethod = (...params: FindWalletByAddressParams) => Wallet | undefined;
+export type FindWalletParams = [string?, TWalletType?, WalletFilters?];
+export type FindWalletMethod = (...params: FindWalletParams) => WalletNoSigner | undefined;
+interface GetDisplayAddressOptions {
+    truncate?: boolean;
+    addressType?: TWalletType | undefined;
+    cosmosPrefix?: string;
+    targetLength?: number;
+}
+export type GetDisplayAddressParams = [string, GetDisplayAddressOptions?];
+export type GetDisplayAddressMethod = (...params: GetDisplayAddressParams) => string;
+export type GetIdenticonHashParams = [string, TWalletType?];
+export type GetIdenticonHashMethod = (...params: GetIdenticonHashParams) => string | undefined;
+export type IsWalletSupportedMethod = (_: WalletNoSigner) => boolean;
+export type IsWalletOwnedMethod = (_: Wallet) => boolean;
+export type IsWalletUsableMethod = (_: string, __?: WalletFilters, ___?: boolean) => boolean;
+export type GetWalletsByTypeParams = TWalletType;
+export type GetWalletsByTypeMethod = (_: GetWalletsByTypeParams) => Wallet[];
+export type AssertIsValidWalletIdMethod = (_: string, __?: WalletFilters) => void;
+export type AssertIsValidWalletTypeMethod = (_: string, __?: TWalletType[]) => Promise<TWalletType>;
+export type FetchWalletsMethod = () => Promise<WalletEntity[]>;
+export interface GetWalletBalanceParams {
+    walletId: string;
+    rpcUrl?: string;
+}
+export type GetWalletBalanceMethod = (_: GetWalletBalanceParams) => Promise<string>;
+export type GetUserShareMethod = () => string | null;
+export type SetUserShareMethod = (_: string | null) => Promise<void>;
+export interface DistributeNewWalletShareParams {
+    /**
+     * The ID of the wallet whose share to distribute.
+     */
+    walletId: string;
+    /**
+     * The user share string.
+     */
+    userShare?: string;
+    /**
+     * If `true`, skip biometric share creation.
+     */
+    skipBiometricShareCreation?: boolean;
+    /**
+     * If `true`, force a session refresh.
+     */
+    forceRefresh?: boolean;
+}
+export type DistributeNewWalletShareMethod = (_: DistributeNewWalletShareParams) => Promise<string>;
+export {};

package/dist/types/services/types/index.d.ts

@@ -0,0 +1,11 @@
+export type * from './AuthServiceTypes';
+export type * from './BaseAuthFlowServiceTypes';
+export type * from './ExternalWalletServiceTypes';
+export type * from './LoginFlowServiceTypes';
+export type * from './PollingServiceTypes';
+export type * from './PortalUrlServiceTypes';
+export type * from './PregenWalletServiceTypes';
+export type * from './SessionManagementServiceTypes';
+export type * from './SignupFlowServiceTypes';
+export type * from './VerificationFlowServiceTypes';
+export type * from './WalletServiceTypes';

package/dist/types/state/CoreStateManager.d.ts

@@ -0,0 +1,36 @@
+import { ParaCore } from '../ParaCore.js';
+import { CoreEvents, CoreState } from './types/core.js';
+import { AuthEvents } from './types/auth.js';
+import { WalletEvents } from './types/wallet.js';
+export declare class CoreStateManager {
+    private service;
+    private listeners;
+    private childSubscriptions;
+    private currentAuthRefId;
+    private currentWalletRefId;
+    private lastNotifiedState;
+    private devLog;
+    constructor(paraCore: ParaCore);
+    private subscribeToChildMachines;
+    private subscribeToChildRef;
+    start(): void;
+    stop(): void;
+    send(event: CoreEvents | AuthEvents | WalletEvents): void;
+    getSnapshot(): CoreState;
+    onStateChange(listener: (state: CoreState) => void): () => void;
+    private getAuthMachineState;
+    private getWalletMachineState;
+    /**
+     * Computes AuthStateInfo from the auth machine context.
+     * Extracts all data needed by UI consumers from authStateResult.
+     */
+    private computeAuthStateInfo;
+    private mapXStateToCoreState;
+    private static readonly CORE_LOADING_STATES;
+    private static readonly AUTH_LOADING_STATES;
+    private static readonly WALLET_LOADING_STATES;
+    private isLoadingState;
+    private notifyListeners;
+    private statesEqual;
+    private authStateInfoEqual;
+}

package/dist/types/state/actors/authenticateWithEmailOrPhone.d.ts

@@ -0,0 +1,8 @@
+import { WithCustomTheme, WithUseShortUrls } from '../../types/index.js';
+import { ServerAuthState } from '@getpara/user-management-client';
+import { AuthService } from '../../services/AuthService.js';
+import { SignUpOrLogInParams } from '../../services/types/AuthServiceTypes.js';
+export declare const createAuthenticateWithEmailOrPhoneActor: (authService: AuthService) => import("xstate").PromiseActorLogic<{
+    authState: ServerAuthState;
+    opts: WithCustomTheme & WithUseShortUrls;
+}, SignUpOrLogInParams, import("xstate").EventObject>;

package/dist/types/state/actors/authenticateWithExternalWallet.d.ts

@@ -0,0 +1,8 @@
+import { WithCustomTheme, WithUseShortUrls } from '../../types/index.js';
+import { ServerAuthState } from '@getpara/user-management-client';
+import { AuthService } from '../../services/AuthService.js';
+import { LoginExternalWalletParams } from '../../services/types/AuthServiceTypes.js';
+export declare const createAuthenticateWithExternalWalletActor: (authService: AuthService) => import("xstate").PromiseActorLogic<{
+    authState: ServerAuthState;
+    opts: WithCustomTheme & WithUseShortUrls;
+}, LoginExternalWalletParams, import("xstate").EventObject>;

package/dist/types/state/actors/authenticateWithFarcaster.d.ts

@@ -0,0 +1,3 @@
+import { PollingService } from '../../services/PollingService.js';
+import { WaitForFarcasterEventParams } from '../../services/types/PollingServiceTypes.js';
+export declare const createAuthenticateWithFarcasterActor: (pollingService: PollingService) => import("xstate").PromiseActorLogic<import("../types/auth.js").AuthenticationOutput, WaitForFarcasterEventParams, import("xstate").EventObject>;

package/dist/types/state/actors/authenticateWithFarcasterLegacy.d.ts

@@ -0,0 +1,3 @@
+import { AuthService } from '../../services/AuthService.js';
+import { PerformVerifyFarcasterResponse, VerifyFarcasterParams } from '../../services/types/VerificationFlowServiceTypes.js';
+export declare const createAuthenticateWithFarcasterLegacyActor: (authService: AuthService) => import("xstate").PromiseActorLogic<PerformVerifyFarcasterResponse, VerifyFarcasterParams, import("xstate").EventObject>;

package/dist/types/state/actors/authenticateWithTelegram.d.ts

@@ -0,0 +1,3 @@
+import { PollingService } from '../../services/PollingService.js';
+import { WaitForTelegramEventParams } from '../../services/types/PollingServiceTypes.js';
+export declare const createAuthenticateWithTelegramActor: (pollingService: PollingService) => import("xstate").PromiseActorLogic<import("../types/auth.js").AuthenticationOutput, WaitForTelegramEventParams, import("xstate").EventObject>;

package/dist/types/state/actors/authenticateWithTelegramLegacy.d.ts

@@ -0,0 +1,8 @@
+import { WithCustomTheme, WithUseShortUrls } from '../../types/index.js';
+import { ServerAuthState } from '@getpara/user-management-client';
+import { AuthService } from '../../services/AuthService.js';
+import { VerifyTelegramParams } from '../../services/types/VerificationFlowServiceTypes.js';
+export declare const createAuthenticateWithTelegramLegacyActor: (authService: AuthService) => import("xstate").PromiseActorLogic<{
+    authState: ServerAuthState;
+    opts: WithCustomTheme & WithUseShortUrls;
+}, VerifyTelegramParams, import("xstate").EventObject>;

package/dist/types/state/actors/checkUserState.d.ts

@@ -0,0 +1,6 @@
+import { StateMachineInterface } from '../../types/serviceInterfaces.js';
+export declare const createCheckUserStateActor: (paraCoreInterface: StateMachineInterface) => import("xstate").PromiseActorLogic<{
+    isAuthenticated: boolean;
+    isFullyLoggedIn: boolean;
+    isGuestMode: boolean;
+}, {}, import("xstate").EventObject>;

package/dist/types/state/actors/claimWallets.d.ts

@@ -0,0 +1,8 @@
+import { CurrentWalletIds } from '@getpara/user-management-client';
+import { PregenWalletService } from '../../services/PregenWalletService.js';
+export declare const createClaimWalletsActor: (pregenWalletService: PregenWalletService) => import("xstate").PromiseActorLogic<{
+    walletIds: CurrentWalletIds;
+    recoverySecret: string | undefined;
+}, {
+    retryCount?: number;
+}, import("xstate").EventObject>;

package/dist/types/state/actors/connectExternalConnectors.d.ts

@@ -0,0 +1,4 @@
+import { ExternalWalletService } from '../../services/ExternalWalletService.js';
+export declare const createConnectParaConnectorsActor: (externalWalletService: ExternalWalletService) => import("xstate").PromiseActorLogic<void, void | {
+    retryCount?: number;
+}, import("xstate").EventObject>;