@getpara/core-sdk 1.12.0 → 2.0.0-alpha.5

package/dist/types/PlatformUtils.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { BackupKitEmailProps, TPregenIdentifierType, WalletType, SDKType } 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;
@@ -15,7 +15,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,5 +1,6 @@
 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;
@@ -15,4 +16,5 @@ export declare const LOCAL_STORAGE_SESSION_COOKIE: string;
 export declare const SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR: string;
 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";

package/dist/types/external/userManagementClient.d.ts

@@ -6,7 +6,7 @@ export declare function getBaseMPCNetworkUrl(env: Environment, useWebsocket?: bo
 export declare function initClient({ env, version, apiKey, partnerId, useFetchAdapter, retrieveSessionCookie, persistSessionCookie, }: {
     env: Environment;
     version?: string;
-    apiKey?: string;
+    apiKey: string;
     partnerId?: string;
     useFetchAdapter?: boolean;
     retrieveSessionCookie?: () => string;

package/dist/types/index.d.ts

@@ -1,9 +1,10 @@
 import { ParaCore } from './ParaCore.js';
-export { AuthMethod, type CurrentWalletIds, EmailTheme, type PartnerEntity, type WalletEntity, Network, WalletType, WalletScheme, OnRampAsset, OnRampPurchaseType, OnRampProvider, OnRampPurchaseStatus, type OnRampConfig, type OnRampAllowedAssets, type OnRampPurchase, OAuthMethod, type TPregenIdentifierType, type PregenIds, NON_ED25519, PREGEN_IDENTIFIER_TYPES, } from '@getpara/user-management-client';
-export { OnRampMethod, PopupType, PregenIdentifierType, RecoveryStatus, type ProviderAssetInfo, type SignatureRes, type FullSignatureRes, type SuccessfulSignatureRes, type DeniedSignatureRes, type DeniedSignatureResWithUrl, type OnRampAssetInfo, type Theme, type Wallet, type GetWalletBalanceParams, type CreateGuestWalletsParams, } from './types/index.js';
+export { type AuthInfo, type PrimaryAuthInfo, type VerifiedAuthInfo, AuthMethod, type AuthExtras, type CurrentWalletIds, EmailTheme, type PartnerEntity, type WalletEntity, Network, type TWalletType, type TWalletScheme, OnRampAsset, OnRampPurchaseType, OnRampProvider, OnRampPurchaseStatus, type OnRampConfig, type OnRampAllowedAssets, type OnRampPurchase, type TOAuthMethod, type SupportedWalletTypes, type TPregenIdentifierType, type PregenIds, NON_ED25519, PREGEN_IDENTIFIER_TYPES, WALLET_TYPES, WALLET_SCHEMES, OAUTH_METHODS, } 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, } from './types/index.js';
+export * from './types/coreApi.js';
 export * from './types/events.js';
 export * from './types/config.js';
-export { getPortalDomain, stringToPhoneNumber, 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';
@@ -16,6 +17,7 @@ export * from './external/userManagementClient.js';
 export * from './errors.js';
 export * from './utils/formatting.js';
 export * from './utils/polling.js';
+export * from './utils/phone.js';
 export { isWalletSupported } from './utils/wallet.js';
 export { getNetworkPrefix, getOnRampAssets, getOnRampNetworks, toAssetInfoArray } from './utils/onRamps.js';
 export { getPortalBaseURL } from './utils/url.js';

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, TWalletScheme, TWalletType } from '@getpara/user-management-client';
 import { Theme } from './theme.js';
 export declare enum Environment {
     DEV = "DEV",
@@ -11,7 +11,7 @@ export declare enum Environment {
 }
 export interface Ctx {
     env: Environment;
-    apiKey?: string;
+    apiKey: string;
     client: Client;
     disableWorkers?: boolean;
     offloadMPCComputationURL?: string;
@@ -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 = {
@@ -57,17 +55,6 @@ export type deprecated__OnRampConfig = {
 export type SupportedWalletTypeConfig = {
     optional?: boolean;
 };
-export type deprecated__SupportedWalletTypesOpt = {
-    [WalletType.EVM]?: boolean | SupportedWalletTypeConfig;
-    [WalletType.SOLANA]?: boolean | SupportedWalletTypeConfig;
-    [WalletType.COSMOS]?: boolean | (SupportedWalletTypeConfig & {
-        prefix?: string;
-    });
-};
-export type SupportedWalletTypes = {
-    type: WalletType;
-    optional?: boolean;
-}[];
 export interface ConstructorOpts {
     externalWalletConnectionOnly?: boolean;
     useStorageOverrides?: boolean;
@@ -145,13 +132,6 @@ export interface ConstructorOpts {
      * @deprecated configure this through the developer portal
      */
     homepageUrl?: string;
-    /**
-     * Which type of wallet your application supports, in the form `{ [WalletType]: true }`. Currently allowed values for `WalletType` are `'EVM'`, `'SOLANA'`, or `'COSMOS'`.
-     *
-     * To specify which prefix to use for new Cosmos wallets, pass `{ COSMOS: { prefix: 'your-prefix' } }`. Defaults to `'cosmos'`.
-     * @deprecated Configure your app's supported wallet types in the Para Developer Portal.
-     */
-    supportedWalletTypes?: deprecated__SupportedWalletTypesOpt;
     /**
      * If `true`, the SDK will use the device's temporary session storage instead of saving user and wallet data to local storage.
      */

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

@@ -0,0 +1,475 @@
+import { BackupKitEmailProps, CurrentWalletIds, ExternalWalletInfo, OnRampPurchase, OnRampPurchaseCreateParams, PregenAuth, Setup2faResponse, TelegramAuthResponse, VerifiedAuth, VerifyExternalWalletParams, WalletEntity, WalletParams, TWalletType } from '@getpara/user-management-client';
+import { AuthStateLogin, AuthStateVerify, OAuthResponse, AuthStateBaseParams, WithCustomTheme, WithUseShortUrls, Verify2faResponse, AuthStateSignup, AuthStateVerifyOrLogin, OAuthUrlParams, StorageType, PollParams, CoreAuthInfo, GetWalletBalanceParams, GetWalletBalanceResponse } from './methods.js';
+import { ParaCore } from '../ParaCore.js';
+import { FullSignatureRes, Wallet } from './wallet.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"];
+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 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> = 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 CoreMethods = Record<CoreMethodName, {
+    params?: unknown;
+    response?: unknown;
+    sync?: 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 & OAuthUrlParams & PollParams & {
+            /**
+             * A function returning a boolean, indicating whether the OAuth process should be cancelled.
+             */
+            isCanceled?: () => boolean;
+            /**
+             * A callback function that will be invoked with the OAuth URL when it is available.
+             * For example, you can use this to open the URL in a new window or tab.
+             */
+            onOAuthUrl?: (url: string) => void;
+        };
+        response: OAuthResponse;
+    };
+    getFarcasterConnectUri: {
+        params: void;
+        response: string;
+    };
+    verifyFarcaster: {
+        params: AuthStateBaseParams & PollParams & {
+            /**
+             * A function returning a boolean, indicating whether the Farcaster login process should be cancelled.
+             */
+            isCanceled?: () => boolean;
+            /**
+             * 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;
+        };
+        response: OAuthResponse;
+    };
+    verifyTelegram: {
+        params: AuthStateBaseParams & {
+            /**
+             * The response received from the Telegram login bot.
+             */
+            telegramAuthResponse: TelegramAuthResponse;
+        };
+        response: OAuthResponse;
+    };
+    loginExternalWallet: {
+        params: AuthStateBaseParams & {
+            /**
+             * The external wallet information to use for login.
+             */
+            externalWallet: ExternalWalletInfo;
+        };
+        response: AuthStateVerifyOrLogin;
+    };
+    verifyExternalWallet: {
+        params: AuthStateBaseParams & VerifyExternalWalletParams;
+        response: AuthStateSignup;
+    };
+    resendVerificationCode: {
+        params: void;
+        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;
+    };
+};
+export type CoreInterface = {
+    [key in keyof CoreMethods]: CoreMethod<key>;
+};

package/dist/types/types/events.d.ts

@@ -1,6 +1,7 @@
 import { CurrentWalletIds } from '@getpara/user-management-client';
 import { FullSignatureRes } from './wallet.js';
 import { Wallet } from './wallet.js';
+import { CoreMethodResponse } from './coreApi.js';
 export declare enum ParaEvent {
     LOGIN_EVENT = "paraLogin",
     ACCOUNT_CREATION_EVENT = "paraAccountCreation",
@@ -11,7 +12,8 @@ export declare enum ParaEvent {
     EXTERNAL_WALLET_CHANGE_EVENT = "paraExternalWalletChange",
     WALLETS_CHANGE_EVENT = "paraWalletsChange",
     WALLET_CREATED = "paraWalletCreated",
-    PREGEN_WALLET_CLAIMED = "paraPregenWalletClaimed"
+    PREGEN_WALLET_CLAIMED = "paraPregenWalletClaimed",
+    GUEST_WALLETS_CREATED = "paraGuestWalletsCreated"
 }
 export type BaseEvent<T> = {
     data: T;
@@ -45,3 +47,4 @@ export type PregenWalletClaimedResponse = {
     recoverySecret?: string;
 };
 export type PregenWalletClaimedEvent = CustomEventInit<BaseEvent<WalletCreatedResponse>>;
+export type GuestWalletsCreatedEvent = CustomEventInit<BaseEvent<CoreMethodResponse<'createGuestWallets'>>>;

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

@@ -1,6 +1,7 @@
 export * from './config.js';
+export * from './coreApi.js';
 export * from './wallet.js';
-export * from './params.js';
+export * from './methods.js';
 export * from './theme.js';
 export * from './onRamps.js';
 export * from './popup.js';