@getpara/core-sdk 2.0.0-dev.0 → 2.0.0-dev.2

package/dist/types/PlatformUtils.d.ts

@@ -1,11 +1,10 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { BackupKitEmailProps, TPregenIdentifierType, WalletType } from '@getpara/user-management-client';
+import { BackupKitEmailProps, TPregenIdentifierType, TWalletType, SDKType } from '@getpara/user-management-client';
 import { Ctx, PopupType, SignatureRes } from './types/index.js';
 import { StorageUtils } from './StorageUtils.js';
 export interface PlatformUtils {
+    sdkType: SDKType;
     getPrivateKey(ctx: Ctx, userId: string, walletId: string, share: string, sessionCookie: string): Promise<string>;
-    keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
+    keygen(ctx: Ctx, userId: string, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
     sessionCookie: string, emailProps?: BackupKitEmailProps): Promise<{
         signer: string;
         walletId: string;
@@ -14,7 +13,7 @@ export interface PlatformUtils {
         signer: string;
         protocolId?: string;
     }>;
-    preKeygen(ctx: Ctx, partnerId: string, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
+    preKeygen(ctx: Ctx, partnerId: string, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
     sessionCookie: string): Promise<{
         signer: string;
         walletId: string;

package/dist/types/constants.d.ts

@@ -1,17 +1,21 @@
 export declare const PARA_CORE_VERSION: string;
 export declare const PREFIX = "@CAPSULE/";
-export declare const LOCAL_STORAGE_AUTH_INFO: string;
-export declare const LOCAL_STORAGE_EMAIL: string;
-export declare const LOCAL_STORAGE_PHONE: string;
-export declare const LOCAL_STORAGE_COUNTRY_CODE: string;
-export declare const LOCAL_STORAGE_FARCASTER_USERNAME: string;
-export declare const LOCAL_STORAGE_TELEGRAM_USER_ID: string;
-export declare const LOCAL_STORAGE_USER_ID: string;
-export declare const LOCAL_STORAGE_ED25519_WALLETS: string;
-export declare const LOCAL_STORAGE_WALLETS: string;
-export declare const LOCAL_STORAGE_EXTERNAL_WALLETS: string;
-export declare const LOCAL_STORAGE_CURRENT_WALLET_IDS: string;
-export declare const LOCAL_STORAGE_SESSION_COOKIE: string;
-export declare const SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR: string;
+export declare const LOCAL_STORAGE_AUTH_INFO = "@CAPSULE/authInfo";
+export declare const LOCAL_STORAGE_EMAIL = "@CAPSULE/e-mail";
+export declare const LOCAL_STORAGE_PHONE = "@CAPSULE/phone";
+export declare const LOCAL_STORAGE_COUNTRY_CODE = "@CAPSULE/countryCode";
+export declare const LOCAL_STORAGE_FARCASTER_USERNAME = "@CAPSULE/farcasterUsername";
+export declare const LOCAL_STORAGE_TELEGRAM_USER_ID = "@CAPSULE/telegramUserId";
+export declare const LOCAL_STORAGE_EXTERNAL_WALLET_USER_ID = "@CAPSULE/externalWalletUserId";
+export declare const LOCAL_STORAGE_USER_ID = "@CAPSULE/userId";
+export declare const LOCAL_STORAGE_ED25519_WALLETS = "@CAPSULE/ed25519Wallets";
+export declare const LOCAL_STORAGE_WALLETS = "@CAPSULE/wallets";
+export declare const LOCAL_STORAGE_EXTERNAL_WALLETS = "@CAPSULE/externalWallets";
+export declare const LOCAL_STORAGE_CURRENT_WALLET_IDS = "@CAPSULE/currentWalletIds";
+export declare const LOCAL_STORAGE_SESSION_COOKIE = "@CAPSULE/sessionCookie";
+export declare const SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR = "@CAPSULE/loginEncryptionKeyPair";
 export declare const POLLING_INTERVAL_MS = 2000;
 export declare const SHORT_POLLING_INTERVAL_MS = 1000;
+export declare const POLLING_TIMEOUT_MS = 300000;
+export declare const EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID = "EXTERNAL_WALLET_CONNECTION_ONLY";
+export declare const ACCOUNT_LINK_CONFLICT = "Account already linked";

package/dist/types/index.d.ts

@@ -1,9 +1,10 @@
 import { ParaCore } from './ParaCore.js';
-export { type AuthInfo, type PrimaryAuthInfo, type VerifiedAuthInfo, AuthMethod, type CurrentWalletIds, EmailTheme, type PartnerEntity, type WalletEntity, Network, WalletType, WalletScheme, OnRampAsset, OnRampPurchaseType, OnRampProvider, OnRampPurchaseStatus, type OnRampConfig, type OnRampAllowedAssets, type OnRampPurchase, OAuthMethod, type SupportedWalletTypes, type TPregenIdentifierType, type PregenIds, NON_ED25519, PREGEN_IDENTIFIER_TYPES, } from '@getpara/user-management-client';
-export { OnRampMethod, PopupType, PregenIdentifierType, RecoveryStatus, type AuthExtras, type CoreAuthInfo, type ProviderAssetInfo, type SignatureRes, type FullSignatureRes, type SuccessfulSignatureRes, type DeniedSignatureRes, type DeniedSignatureResWithUrl, type OnRampAssetInfo, type Theme, type Wallet, } from './types/index.js';
+export { type Auth, type AuthInfo, type PrimaryAuthInfo, type VerifiedAuthInfo, type VerifiedAuth, AuthMethod, type AuthExtras, type CurrentWalletIds, EmailTheme, type PartnerEntity, type WalletEntity, Network, WalletType, type TWalletType, WalletScheme, type TWalletScheme, OnRampAsset, OnRampPurchaseType, OnRampProvider, OnRampPurchaseStatus, type OnRampConfig, type OnRampAllowedAssets, type OnRampPurchase, OAuthMethod, type TOAuthMethod, type TLinkedAccountType, type SupportedAccountLinks, type SupportedWalletTypes, type TPregenIdentifierType, type PregenIds, type LinkedAccount, type LinkedAccounts, type TExternalWallet, type ExternalWalletInfo, type PregenAuth, type Setup2faResponse, type TelegramAuthResponse, type VerifyExternalWalletParams, NON_ED25519, PREGEN_IDENTIFIER_TYPES, WALLET_TYPES, WALLET_SCHEMES, OAUTH_METHODS, LINKED_ACCOUNT_TYPES, EXTERNAL_WALLET_TYPES, EVM_WALLETS, SOLANA_WALLETS, COSMOS_WALLETS, } from '@getpara/user-management-client';
+export { OnRampMethod, PopupType, PregenIdentifierType, RecoveryStatus, type AuthStateSignup, type AuthStateVerify, type AuthStateLogin, type AuthState, type OAuthResponse, type CoreAuthInfo, type ProviderAssetInfo, type SignatureRes, type FullSignatureRes, type SuccessfulSignatureRes, type DeniedSignatureRes, type DeniedSignatureResWithUrl, type OnRampAssetInfo, type Theme, type Wallet, type GetWalletBalanceParams, type AccountLinkInProgress, AccountLinkError, type InternalInterface, } from './types/index.js';
+export * from './types/coreApi.js';
 export * from './types/events.js';
 export * from './types/config.js';
-export { getPortalDomain, entityToWallet } from './utils/index.js';
+export { getPortalDomain, entityToWallet, constructUrl, shortenUrl } from './utils/index.js';
 export { PREFIX as STORAGE_PREFIX } from './constants.js';
 export { distributeNewShare } from './shares/shareDistribution.js';
 export { KeyContainer } from './shares/KeyContainer.js';
@@ -18,7 +19,7 @@ export * from './utils/formatting.js';
 export * from './utils/polling.js';
 export * from './utils/phone.js';
 export { isWalletSupported } from './utils/wallet.js';
-export { getOnRampAssets, getOnRampNetworks, toAssetInfoArray } from './utils/onRamps.js';
+export { getNetworkPrefix, getOnRampAssets, getOnRampNetworks, toAssetInfoArray } from './utils/onRamps.js';
 export { getPortalBaseURL } from './utils/url.js';
 export { retrieve as transmissionUtilsRetrieve } from './transmission/transmissionUtils.js';
 export declare const paraVersion: string;

package/dist/types/shares/KeyContainer.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export declare class KeyContainer {
     walletId: string;
     keyshare: string;

package/dist/types/types/auth.d.ts

@@ -0,0 +1,16 @@
+import { ExternalWalletInfo, TLinkedAccountType } from '@getpara/user-management-client';
+export type AccountLinkInProgress = {
+    id: string;
+    type: TLinkedAccountType;
+    identifier?: string;
+    isComplete: boolean;
+    externalWallet?: ExternalWalletInfo & {
+        signatureVerificationMessage: string;
+    };
+};
+export declare enum AccountLinkError {
+    NotAuthenticated = "No user is currently authenticated",
+    Conflict = "Account already linked",
+    Canceled = "Account linking was canceled",
+    Unknown = "An unknown error occurred"
+}

package/dist/types/types/config.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import Client, { EmailTheme, Network, OnRampAsset, OnRampProvider, WalletScheme, WalletType } from '@getpara/user-management-client';
+import Client, { EmailTheme, Network, OnRampAsset, OnRampProvider, PregenAuth, TWalletScheme, TWalletType } from '@getpara/user-management-client';
 import { Theme } from './theme.js';
 export declare enum Environment {
     DEV = "DEV",
@@ -25,11 +25,9 @@ export interface Ctx {
 }
 export type deprecated__NetworkProp = keyof typeof Network | Network;
 export type deprecated__OnRampProviderProp = keyof typeof OnRampProvider | OnRampProvider;
-export type WalletTypeProp = keyof typeof WalletType | WalletType;
-export type WalletSchemeProp = keyof typeof WalletScheme | WalletScheme;
 export type WalletFilters = {
-    type?: WalletTypeProp[];
-    scheme?: WalletSchemeProp[];
+    type?: TWalletType[];
+    scheme?: TWalletScheme[];
     forbidPregen?: boolean;
 };
 export type deprecated__RampConfig = {
@@ -58,6 +56,7 @@ export type SupportedWalletTypeConfig = {
     optional?: boolean;
 };
 export interface ConstructorOpts {
+    externalWalletConnectionOnly?: boolean;
     useStorageOverrides?: boolean;
     disableWorkers?: boolean;
     offloadMPCComputationURL?: string;
@@ -141,4 +140,12 @@ export interface ConstructorOpts {
      * Partner ID set in the Para Portal to track analytics for legacy SDK versions. This variable is unused outside of the Para Portal.
      */
     portalPartnerId?: string;
+    /**
+     * An optional function that fetches the pregenerated wallets for a given identifier so a user can claim them on account creation.
+     */
+    fetchPregenWalletsOverride?: (opts: {
+        pregenId: PregenAuth;
+    }) => Promise<{
+        userShare?: string;
+    }>;
 }

package/dist/types/types/coreApi.d.ts

@@ -0,0 +1,531 @@
+import { BackupKitEmailProps, CurrentWalletIds, ExternalWalletInfo, OnRampPurchase, OnRampPurchaseCreateParams, PregenAuth, Setup2faResponse, VerifiedAuth, VerifyExternalWalletParams, WalletEntity, WalletParams, TWalletType, IssueJwtParams, IssueJwtResponse, TLinkedAccountType, LinkedAccounts } from '@getpara/user-management-client';
+import { AuthStateLogin, AuthStateVerify, OAuthResponse, AuthStateBaseParams, WithCustomTheme, WithUseShortUrls, Verify2faResponse, AuthStateSignup, AuthStateVerifyOrLogin, OAuthUrlParams, StorageType, PollParams, CoreAuthInfo, GetWalletBalanceParams, GetWalletBalanceResponse, FarcasterParams, TelegramParams, OAuthParams } from './methods.js';
+import { ParaCore } from '../ParaCore.js';
+import { FullSignatureRes, Wallet } from './wallet.js';
+import { AccountLinkInProgress } from './auth.js';
+export declare const PARA_CORE_METHODS: readonly ["getAuthInfo", "signUpOrLogIn", "verifyNewAccount", "waitForLogin", "waitForSignup", "waitForWalletCreation", "getOAuthUrl", "verifyOAuth", "getFarcasterConnectUri", "verifyFarcaster", "verifyTelegram", "resendVerificationCode", "loginExternalWallet", "verifyExternalWallet", "setup2fa", "enable2fa", "verify2fa", "logout", "clearStorage", "isSessionActive", "isFullyLoggedIn", "refreshSession", "keepSessionAlive", "exportSession", "importSession", "getVerificationToken", "getWallets", "getWalletsByType", "fetchWallets", "createWallet", "createWalletPerType", "getPregenWallets", "hasPregenWallet", "updatePregenWalletIdentifier", "createPregenWallet", "createPregenWalletPerType", "claimPregenWallets", "createGuestWallets", "distributeNewWalletShare", "getUserShare", "setUserShare", "refreshShare", "signMessage", "signTransaction", "initiateOnRampTransaction", "getWalletBalance", "issueJwt", "getLinkedAccounts", "accountLinkInProgress"];
+export declare const PARA_INTERNAL_METHODS: readonly ["linkAccount", "unlinkAccount", "verifyEmailOrPhoneLink", "verifyOAuthLink", "verifyFarcasterLink", "verifyTelegramLink", "verifyExternalWalletLink", "accountLinkInProgress"];
+export type CoreMethodName = (typeof PARA_CORE_METHODS)[number];
+export type CoreMethodParams<method extends CoreMethodName & keyof CoreMethods> = CoreMethods[method] extends {
+    params: infer P;
+} ? P : never;
+export type CoreMethodIsGetter<method extends CoreMethodName & keyof CoreMethods> = CoreMethods[method] extends {
+    isGetter: true;
+} ? true : false;
+export type CoreMethodResponse<method extends CoreMethodName & keyof CoreMethods> = CoreMethods[method] extends {
+    response: infer R;
+} ? CoreMethods[method] extends {
+    sync: true;
+} ? R : Promise<R> : void;
+export type CoreMethod<method extends CoreMethodName & keyof CoreMethods> = CoreMethodIsGetter<method> extends true ? Awaited<CoreMethodResponse<method>> : CoreMethodParams<method> extends void | never ? () => CoreMethodResponse<method> : (_?: CoreMethodParams<method>) => CoreMethodResponse<method>;
+export type CoreAction<method extends CoreMethodName & keyof CoreMethods> = CoreMethodParams<method> extends void | never ? (_?: ParaCore) => CoreMethodResponse<method> : (_?: ParaCore, __?: CoreMethodParams<method>) => CoreMethodResponse<method>;
+export type InternalMethodName = (typeof PARA_INTERNAL_METHODS)[number];
+export type InternalMethodParams<method extends InternalMethodName & keyof InternalMethods> = InternalMethods[method] extends {
+    params: infer P;
+} ? P : never;
+export type InternalMethodIsGetter<method extends InternalMethodName & keyof InternalMethods> = InternalMethods[method] extends {
+    isGetter: true;
+} ? true : false;
+export type InternalMethodResponse<method extends InternalMethodName & keyof InternalMethods> = InternalMethods[method] extends {
+    response: infer R;
+} ? InternalMethods[method] extends {
+    sync: true;
+} ? R : Promise<R> : void;
+export type InternalMethod<method extends InternalMethodName & keyof InternalMethods> = InternalMethodIsGetter<method> extends true ? Awaited<InternalMethodResponse<method>> : InternalMethodParams<method> extends void | never ? () => InternalMethodResponse<method> : (_?: InternalMethodParams<method>) => InternalMethodResponse<method>;
+export type InternalAction<method extends InternalMethodName & keyof InternalMethods> = InternalMethodParams<method> extends void | never ? (_?: ParaCore) => InternalMethodResponse<method> : (_?: ParaCore, __?: InternalMethodParams<method>) => InternalMethodResponse<method>;
+export type CoreMethods = Record<CoreMethodName, {
+    params?: unknown;
+    response?: unknown;
+    sync?: true;
+}> & {
+    accountLinkInProgress: {
+        params: never;
+        response: AccountLinkInProgress;
+        isGetter: true;
+    };
+    getAuthInfo: {
+        params: void;
+        response: CoreAuthInfo | undefined;
+        sync: true;
+    };
+    signUpOrLogIn: {
+        params: WithCustomTheme & WithUseShortUrls & {
+            /**
+             * The user's email address or phone number, in the form `{ email: '...' } | { phone: '+1...' }`}
+             */
+            auth: VerifiedAuth;
+        };
+        response: AuthStateVerify | AuthStateLogin;
+    };
+    verifyNewAccount: {
+        params: WithCustomTheme & WithUseShortUrls & {
+            /**
+             * The verification code entered by the user.
+             */
+            verificationCode: string;
+        };
+        response: AuthStateSignup;
+    };
+    waitForLogin: {
+        params: PollParams & {
+            /**
+             * Whether to skip the session refresh
+             */
+            skipSessionRefresh?: boolean;
+            /**
+             * A function returning a boolean, indicating whether the login process should be cancelled.
+             */
+            isCanceled?: () => boolean;
+        };
+        response: {
+            /**
+             * 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;
+        };
+    };
+    waitForSignup: {
+        params: PollParams & {
+            /**
+             * A function returning a boolean, indicating whether the signup process should be cancelled.
+             */
+            isCanceled?: () => boolean;
+        };
+        response: true;
+    };
+    waitForWalletCreation: {
+        params: PollParams & {
+            /**
+             * A function returning a boolean, indicating whether wallet creation should be cancelled.
+             */
+            isCanceled?: () => boolean;
+        };
+        response: {
+            /**
+             * The IDs of the newly created wallets.
+             */
+            walletIds: CurrentWalletIds;
+            /**
+             * The recovery secret for the new wallets, if available.
+             */
+            recoverySecret?: string;
+        };
+    };
+    getOAuthUrl: {
+        params: OAuthUrlParams & {
+            sessionLookupId?: string;
+        };
+        response: string;
+    };
+    verifyOAuth: {
+        params: AuthStateBaseParams & OAuthParams;
+        response: OAuthResponse;
+    };
+    getFarcasterConnectUri: {
+        params: void;
+        response: string;
+    };
+    verifyFarcaster: {
+        params: AuthStateBaseParams & FarcasterParams;
+        response: OAuthResponse;
+    };
+    verifyTelegram: {
+        params: AuthStateBaseParams & TelegramParams;
+        response: OAuthResponse;
+    };
+    loginExternalWallet: {
+        params: AuthStateBaseParams & {
+            /**
+             * The external wallet information to use for login.
+             */
+            externalWallet: ExternalWalletInfo | ExternalWalletInfo[];
+        };
+        response: AuthStateVerifyOrLogin;
+    };
+    verifyExternalWallet: {
+        params: AuthStateBaseParams & VerifyExternalWalletParams;
+        response: AuthStateSignup;
+    };
+    resendVerificationCode: {
+        params: {
+            type?: 'SIGNUP' | 'LINK_ACCOUNT';
+        } | undefined;
+        response: void;
+    };
+    logout: {
+        params: {
+            /**
+             * Whether to remove all pregen wallets from storage.
+             */
+            clearPregenWallets?: boolean;
+        };
+        response: void;
+    };
+    clearStorage: {
+        params: StorageType | undefined;
+        response: void;
+    };
+    isSessionActive: {
+        params: void;
+        response: boolean;
+    };
+    isFullyLoggedIn: {
+        params: void;
+        response: boolean;
+    };
+    refreshSession: {
+        params: {
+            shouldOpenPopup?: boolean;
+        };
+        response: string;
+    };
+    keepSessionAlive: {
+        params: void;
+        response: boolean;
+    };
+    exportSession: {
+        params: {
+            /**
+             * Whether to exclude the wallet signers from the exported session.
+             */
+            excludeSigners?: boolean;
+        };
+        response: string;
+        sync: true;
+    };
+    importSession: {
+        params: string;
+        response: void;
+    };
+    getVerificationToken: {
+        params: void;
+        response: string;
+    };
+    setup2fa: {
+        params: void;
+        response: Setup2faResponse;
+    };
+    enable2fa: {
+        params: {
+            /**
+             * The two-factor authentication code entered by the user.
+             */
+            verificationCode: string;
+        };
+        response: void;
+    };
+    verify2fa: {
+        params: {
+            /**
+             * The email or phone number for the user to verify, in the form `{ email: '...' } | { phone: '+1...' }`
+             */
+            auth: VerifiedAuth;
+            /**
+             * The two-factor authentication code entered by the user.
+             */
+            verificationCode: string;
+        };
+        response: Verify2faResponse;
+    };
+    getWallets: {
+        params: void;
+        response: Record<string, Wallet>;
+        sync: true;
+    };
+    getWalletsByType: {
+        params: TWalletType;
+        response: Wallet[];
+        sync: true;
+    };
+    fetchWallets: {
+        params: void;
+        response: WalletEntity[];
+    };
+    createWallet: {
+        params: {
+            type?: Uppercase<TWalletType>;
+            skipDistribute?: boolean;
+        };
+        response: [Wallet, string | undefined];
+    };
+    createWalletPerType: {
+        params: {
+            /**
+             * Array of the wallet types to create
+             */
+            types?: Uppercase<TWalletType>[];
+            /**
+             * If `true`, skip distributing the new wallets shares.
+             */
+            skipDistribute?: boolean;
+        };
+        response: {
+            /**
+             * 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;
+        };
+    };
+    getPregenWallets: {
+        params: {
+            /**
+             * The pregen ID for the wallets to fetch. If not provided, all available wallets will be retrieved.
+             */
+            pregenId?: PregenAuth;
+        };
+        response: WalletEntity[];
+    };
+    updatePregenWalletIdentifier: {
+        params: {
+            /**
+             * The ID of the pregen wallet to update.
+             */
+            walletId: string;
+            /**
+             * The new identifer for the wallet.
+             */
+            newPregenId: PregenAuth;
+        };
+        response: void;
+    };
+    hasPregenWallet: {
+        params: {
+            /**
+             * The pregen ID for the wallet to check.
+             */
+            pregenId: PregenAuth;
+        };
+        response: boolean;
+    };
+    createPregenWallet: {
+        params: {
+            /**
+             * 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: PregenAuth;
+        };
+        response: Wallet;
+    };
+    createPregenWalletPerType: {
+        params: {
+            /**
+             * 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;
+        };
+        response: Wallet[];
+    };
+    claimPregenWallets: {
+        params: {
+            /**
+             * The pregen identifier for the wallet to claim. If not provided, will attempt to claim all wallets in storage.
+             */
+            pregenId?: PregenAuth;
+        };
+        response: string | undefined;
+    };
+    createGuestWallets: {
+        params: void;
+        response: Wallet[];
+    };
+    distributeNewWalletShare: {
+        params: {
+            /**
+             * 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;
+        };
+        response: string;
+    };
+    getUserShare: {
+        params: void;
+        response: string | null;
+        sync: true;
+    };
+    setUserShare: {
+        params: string | null;
+        response: void;
+    };
+    refreshShare: {
+        params: {
+            walletId: string;
+            share: string;
+            oldPartnerId?: string;
+            newPartnerId?: string;
+            keyShareProtocolId?: string;
+            redistributeBackupEncryptedShares?: boolean;
+            emailProps?: BackupKitEmailProps;
+        };
+        response: {
+            protocolId: string;
+            recoverySecret?: string;
+            signer: string;
+        };
+    };
+    signMessage: {
+        params: PollParams & {
+            /**
+             * The ID of the wallet to use for signing.
+             */
+            walletId: string;
+            /**
+             * The message to sign as a base64-encoded string.
+             */
+            messageBase64: string;
+            /**
+             * The duration in milliseconds to wait before the signing operation times out.
+             */
+            timeoutMs?: number;
+            /**
+             * For Cosmos transactions, the `SignDoc` as a base64-encoded string.
+             */
+            cosmosSignDocBase64?: string;
+            /**
+             * A callback that returns a boolean, indicating whether the signing operation should be cancelled.
+             */
+            isCanceled?: () => boolean;
+        };
+        response: FullSignatureRes;
+    };
+    signTransaction: {
+        params: PollParams & {
+            /**
+             * The ID of the wallet to use for signing.
+             */
+            walletId: string;
+            /**
+             * The transaction to sign as a base64-encoded string.
+             */
+            rlpEncodedTxBase64: string;
+            /**
+             * For EVM transactions, the chain ID.
+             */
+            chainId: string;
+            /**
+             * The duration in milliseconds to wait before the signing operation times out.
+             */
+            timeoutMs?: number;
+            /**
+             * A callback that returns a boolean, indicating whether the signing operation should be cancelled.
+             */
+            isCanceled?: () => boolean;
+        };
+        response: FullSignatureRes;
+    };
+    initiateOnRampTransaction: {
+        params: WalletParams & {
+            /**
+             * The on-ramp transaction options.
+             */
+            params: OnRampPurchaseCreateParams;
+            /**
+             * Whether to open a popup window for the user to complete the transaction.
+             */
+            shouldOpenPopup?: boolean;
+        };
+        response: {
+            /**
+             * The newly created on-ramp transaction.
+             */
+            onRampPurchase: OnRampPurchase;
+            /**
+             * A Para Portal URL for the user to complete the transaction.
+             */
+            portalUrl: string;
+        };
+    };
+    getWalletBalance: {
+        params: GetWalletBalanceParams;
+        response: GetWalletBalanceResponse;
+    };
+    issueJwt: {
+        params: IssueJwtParams;
+        response: IssueJwtResponse;
+    };
+    getLinkedAccounts: {
+        params: {
+            withMetadata?: boolean;
+        };
+        response: LinkedAccounts & {
+            userId: string;
+        };
+    };
+};
+export type InternalMethods = {
+    linkAccount: {
+        params: {
+            auth: VerifiedAuth;
+        } | {
+            externalWallet: ExternalWalletInfo;
+        } | {
+            type: TLinkedAccountType | 'X';
+        };
+        response: AccountLinkInProgress;
+    };
+    unlinkAccount: {
+        params: {
+            linkedAccountId: string;
+        };
+        response: LinkedAccounts;
+    };
+    verifyEmailOrPhoneLink: {
+        params: {
+            verificationCode?: string;
+        };
+        response: LinkedAccounts;
+    };
+    verifyOAuthLink: {
+        params: OAuthParams;
+        response: LinkedAccounts;
+    };
+    verifyFarcasterLink: {
+        params: FarcasterParams;
+        response: LinkedAccounts;
+    };
+    verifyTelegramLink: {
+        params: TelegramParams;
+        response: LinkedAccounts;
+    };
+    verifyExternalWalletLink: {
+        params: Omit<VerifyExternalWalletParams, 'externalWallet'>;
+        response: LinkedAccounts;
+    };
+};
+export type CoreInterface = {
+    [key in keyof CoreMethods]: Partial<CoreMethod<key>>;
+};
+export type InternalInterface = {
+    [key in keyof InternalMethods]: Partial<InternalMethod<key>>;
+};