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

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 AuthInfo, type PrimaryAuthInfo, type VerifiedAuthInfo, AuthMethod, type AuthExtras, 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 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, } 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';

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

@@ -0,0 +1,437 @@
+import { BackupKitEmailProps, CurrentWalletIds, ExternalWalletInfo, OnRampPurchase, OnRampPurchaseCreateParams, PregenAuth, Setup2faResponse, TelegramAuthResponse, VerifiedAuth, VerifyExternalWalletParams, WalletEntity, WalletParams, WalletType } from '@getpara/user-management-client';
+import { AuthStateLogin, AuthStateVerify, OAuthResponse, AuthStateBaseParams, WithCustomTheme, WithUseShortUrls, Verify2faResponse, AuthStateSignup, AuthStateVerifyOrLogin, OAuthUrlParams, StorageType, PollParams } from './methods.js';
+import { ParaCore } from '../ParaCore.js';
+import { FullSignatureRes, Wallet } from './wallet.js';
+export declare const PARA_CORE_METHODS: readonly ["signUpOrLogInV2", "verifyNewAccountV2", "waitForLoginV2", "waitForSignupV2", "waitForWalletCreationV2", "verifyOAuthV2", "verifyFarcasterV2", "verifyTelegramV2", "resendVerificationCode", "loginExternalWalletV2", "verifyExternalWalletV2", "setup2faV2", "enable2faV2", "verify2faV2", "logout", "clearStorage", "isSessionActive", "isFullyLoggedIn", "refreshSession", "keepSessionAlive", "exportSession", "importSession", "getVerificationToken", "fetchWallets", "createWallet", "createWalletPerType", "getPregenWalletsV2", "hasPregenWalletV2", "updatePregenWalletIdentifierV2", "createPregenWalletV2", "createPregenWalletPerTypeV2", "claimPregenWalletsV2", "distributeNewWalletShare", "getUserShare", "setUserShare", "refreshShare", "signMessage", "signTransaction", "initiateOnRampTransaction"];
+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;
+}> & {
+    signUpOrLogInV2: {
+        params: WithCustomTheme & WithUseShortUrls & {
+            /**
+             * The user's email address or phone number, in the form `{ email: '...' } | { phone: '+1...' }`}
+             */
+            auth: VerifiedAuth;
+        };
+        response: AuthStateVerify | AuthStateLogin;
+    };
+    verifyNewAccountV2: {
+        params: WithCustomTheme & WithUseShortUrls & {
+            /**
+             * The verification code entered by the user.
+             */
+            verificationCode: string;
+        };
+        response: AuthStateSignup;
+    };
+    waitForLoginV2: {
+        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;
+        };
+    };
+    waitForSignupV2: {
+        params: PollParams & {
+            /**
+             * A function returning a boolean, indicating whether the signup process should be cancelled.
+             */
+            isCanceled?: () => boolean;
+        };
+        response: true;
+    };
+    waitForWalletCreationV2: {
+        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;
+        };
+    };
+    verifyOAuthV2: {
+        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;
+    };
+    verifyFarcasterV2: {
+        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;
+    };
+    verifyTelegramV2: {
+        params: AuthStateBaseParams & {
+            /**
+             * The response received from the Telegram login bot.
+             */
+            telegramAuthResponse: TelegramAuthResponse;
+        };
+        response: OAuthResponse;
+    };
+    loginExternalWalletV2: {
+        params: AuthStateBaseParams & {
+            /**
+             * The external wallet information to use for login.
+             */
+            externalWallet: ExternalWalletInfo;
+        };
+        response: AuthStateVerifyOrLogin;
+    };
+    verifyExternalWalletV2: {
+        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: void;
+        response: string;
+        sync: true;
+    };
+    importSession: {
+        params: string;
+        response: void;
+    };
+    getVerificationToken: {
+        params: void;
+        response: string;
+    };
+    setup2faV2: {
+        params: void;
+        response: Setup2faResponse;
+    };
+    enable2faV2: {
+        params: {
+            /**
+             * The two-factor authentication code entered by the user.
+             */
+            verificationCode: string;
+        };
+        response: void;
+    };
+    verify2faV2: {
+        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;
+    };
+    fetchWallets: {
+        params: void;
+        response: WalletEntity[];
+    };
+    createWallet: {
+        params: {
+            type?: Uppercase<WalletType>;
+            skipDistribute?: boolean;
+        };
+        response: [Wallet, string | undefined];
+    };
+    createWalletPerType: {
+        params: {
+            /**
+             * Array of the wallet types to create
+             */
+            types?: Uppercase<WalletType>[];
+            /**
+             * 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;
+        };
+    };
+    getPregenWalletsV2: {
+        params: {
+            /**
+             * The pregen ID for the wallets to fetch. If not provided, all available wallets will be retrieved.
+             */
+            pregenId?: PregenAuth;
+        };
+        response: WalletEntity[];
+    };
+    updatePregenWalletIdentifierV2: {
+        params: {
+            /**
+             * The ID of the pregen wallet to update.
+             */
+            walletId: string;
+            /**
+             * The new identifer for the wallet.
+             */
+            newPregenId: PregenAuth;
+        };
+        response: void;
+    };
+    hasPregenWalletV2: {
+        params: {
+            /**
+             * The pregen ID for the wallet to check.
+             */
+            pregenId: PregenAuth;
+        };
+        response: boolean;
+    };
+    createPregenWalletV2: {
+        params: {
+            /**
+             * The type of wallet to create, 'EVM' | 'SOLANA' | 'COSMOS'
+             */
+            type: WalletType;
+            /**
+             * 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;
+    };
+    createPregenWalletPerTypeV2: {
+        params: {
+            /**
+             * The wallet types to create. If not provided, defaults to your application's `supportedWalletTypes` setting.
+             */
+            types?: WalletType[];
+            /**
+             * 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[];
+    };
+    claimPregenWalletsV2: {
+        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;
+    };
+    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;
+        };
+    };
+};
+export type CoreInterface = {
+    [key in keyof CoreMethods]: CoreMethod<key>;
+};

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

@@ -1,4 +1,5 @@
 export * from './config.js';
+export * from './coreApi.js';
 export * from './wallet.js';
 export * from './methods.js';
 export * from './theme.js';

package/dist/types/types/methods.d.ts

@@ -1,20 +1,20 @@
-import { AuthType, PrimaryAuthInfo, WalletType } from '@getpara/user-management-client';
+import { AuthType, PrimaryAuthInfo, ServerAuthStateLogin, ServerAuthStateSignup, AuthMethod, ServerAuthStateVerify, VerifiedAuth, AuthExtras, OAuthMethod, WalletType } from '@getpara/user-management-client';
 import { Theme } from './theme.js';
+import { RecoveryStatus } from './recovery.js';
+import { Wallet } from './wallet.js';
+type Device = {
+    sessionId: string;
+    encryptionKey: string;
+};
 export type EmbeddedWalletType = Exclude<WalletType, never>;
 export type ExternalWalletType = Exclude<WalletType, never>;
-export type ExternalWalletInfo = {
-    address: string;
-    type: ExternalWalletType;
-    provider?: string;
-    addressBech32?: string;
-    withFullParaAuth?: boolean;
-};
-export type VerifyExternalWallet = {
+export type VerifyExternalWalletV1 = {
     address: string;
     signedMessage: string;
     cosmosPublicKeyHex?: string;
     cosmosSigner?: string;
 };
+export type PortalUrlType = 'createAuth' | 'createPassword' | 'loginAuth' | 'loginPassword' | 'txReview' | 'onRamp';
 export type PortalUrlOptions = {
     params?: Record<string, string | undefined | null>;
     authType?: AuthType;
@@ -29,19 +29,15 @@ export type PortalUrlOptions = {
     displayName?: string;
     pfpUrl?: string;
 };
-export type AuthExtras = {
-    /**
-     * The current user's third-party username.
-     */
-    username?: string;
-    /**
-     * The current user's third-party display name.
-     */
-    displayName?: string;
-    /**
-     * The current user's third-party profile picture URL.
-     */
-    pfpUrl?: string;
+export type PortalUrlOptionsV2 = {
+    params?: Record<string, string | undefined | null>;
+    isForNewDevice?: boolean;
+    thisDevice?: Device;
+    newDevice?: Device;
+    sessionId?: string;
+    portalTheme?: Theme;
+    pathId?: string;
+    shorten?: boolean;
 };
 export type GetWebAuthUrlForLoginParams = {
     /**
@@ -77,4 +73,119 @@ export type GetWebAuthUrlForLoginParams = {
      */
     pfpUrl?: string;
 };
+export type WithAuthMethod = {
+    /**
+     * Which authorization method to use for the URL, either `'passkey'` or `'passwprd'`.
+     */
+    authMethod?: Uppercase<AuthMethod>;
+};
+export type WithCustomTheme = {
+    /**
+     * The theme to apply to generated URLs, if different from your configured theme.
+     */
+    portalTheme?: Theme;
+};
+export type WithUseShortUrls = {
+    /**
+     * Whether to shorten generated URLs. This may correct any issues with generated QR codes. Defaults to `false`.
+     */
+    useShortUrls?: boolean;
+};
+export type WithShorten = {
+    /**
+     * Whether to shorten the generated URL. This may correct any issues with generated QR codes. Defaults to `false`.
+     */
+    shorten?: boolean;
+};
+export type PollParams = {
+    /**
+     * A callback function that will be invoked on each method poll.
+     */
+    onPoll?: () => void;
+    /**
+     * A callback function that will be invoked if the method call is canceled.
+     */
+    onCancel?: () => void;
+};
+export type LoginUrlParams = WithAuthMethod & WithCustomTheme & WithShorten & {
+    sessionId?: string;
+};
+export type NewCredentialUrlParams = WithAuthMethod & WithCustomTheme & WithShorten & {
+    /**
+     * Whether the URL is meant to add a passkey for a previous user on a new device. Defaults to `false`.
+     */
+    isForNewDevice?: boolean;
+};
+export type OAuthUrlParams = {
+    /**
+     * The third-party OAuth service.
+     */
+    method: Exclude<OAuthMethod, 'TELEGRAM' | 'FARCASTER'>;
+    /**
+     * The deeplink URL to redirect to after OAuth is complete.
+     */
+    deeplinkUrl?: string;
+};
+export type AuthStateBaseParams = WithCustomTheme & WithUseShortUrls;
+export type AuthStateVerify = ServerAuthStateVerify;
+export type AuthStateLogin = Omit<ServerAuthStateLogin, 'loginAuthMethods'> & {
+    /**
+     * A Para Portal URL for logging in via a WebAuth passkey. For best compatibility, you should open this URL in a new window or tab.
+     */
+    passkeyUrl?: string;
+    /**
+     * A Para Portal URL for authorizing a new device using a WebAuth passkey located elsewhere, to be visited using that other device.
+     */
+    passkeyKnownDeviceUrl?: string;
+    /**
+     * A Para Portal URL for logging in via a password.
+     */
+    passwordUrl?: string;
+};
+export type AuthStateSignup = Omit<ServerAuthStateSignup, 'signupAuthMethods'> & {
+    /**
+     * A Para Portal URL for creating a new WebAuth passkey.
+     */
+    passkeyUrl?: string;
+    /**
+     * A Para Portal URL for creating a new user password.
+     */
+    passwordUrl?: string;
+    /**
+     * The Para system ID for the newly generated passkey.
+     */
+    passkeyId?: string;
+    /**
+     * The Para system ID for the newly generated password.
+     */
+    passwordId?: string;
+};
+export type AuthStateVerifyOrLogin = AuthStateVerify | AuthStateLogin;
+export type AuthStateSignupOrLogin = AuthStateSignup | AuthStateLogin;
+export type OAuthResponse = AuthStateSignupOrLogin;
+export type AuthState = AuthStateVerify | AuthStateLogin | AuthStateSignup;
+export type Verify2faParams = {
+    auth: VerifiedAuth;
+    verificationCode: string;
+};
+export type Verify2faResponse = {
+    /**
+     * When the 2FA verification code was sent.
+     */
+    initiatedAt?: Date;
+    /**
+     * The status for the 2FA process.
+     */
+    status?: RecoveryStatus;
+    /**
+     * The matched user ID.
+     */
+    userId: string;
+    /**
+     * The wallets protected by this 2FA instance.
+     */
+    wallets: Pick<Wallet, 'address' | 'id'>[];
+};
 export type CoreAuthInfo = PrimaryAuthInfo & AuthExtras;
+export type StorageType = 'local' | 'session' | 'secure' | 'all';
+export {};

package/dist/types/types/wallet.d.ts

@@ -1,5 +1,4 @@
-import { PartnerEntity, TPregenIdentifierType, WalletScheme } from '@getpara/user-management-client';
-import { EmbeddedWalletType, ExternalWalletType } from './methods.js';
+import { EmbeddedWalletType, ExternalWalletType, PartnerEntity, TPregenIdentifierType, WalletScheme } from '@getpara/user-management-client';
 export interface Wallet {
     createdAt?: string;
     id: string;

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

@@ -6,5 +6,6 @@ export * from './listeners.js';
 export * from './onRamps.js';
 export * from './phone.js';
 export * from './polling.js';
+export * from './types.js';
 export * from './url.js';
 export * from './wallet.js';

package/dist/types/utils/phone.d.ts

@@ -1,7 +1,7 @@
-export declare function formatPhoneNumber(phone: string | undefined, countryCode?: string | undefined, opts?: {
+export declare function formatPhoneNumber(phone: string, countryCode?: string | undefined, opts?: {
     forDisplay: undefined | false;
 }): `+${number}` | null;
-export declare function formatPhoneNumber(phone: string | undefined, countryCode: string | undefined, opts: {
+export declare function formatPhoneNumber(phone: string, countryCode: string | undefined, opts: {
     forDisplay: true;
 }): string | null;
 export declare function displayPhoneNumber(phone: string, countryCode?: string): string;

package/dist/types/utils/types.d.ts

@@ -0,0 +1,2 @@
+import { ServerAuthState } from '@getpara/user-management-client';
+export declare function isServerAuthState(obj: ServerAuthState | Record<string, never>): obj is ServerAuthState;

package/dist/types/utils/url.d.ts

@@ -1,4 +1,4 @@
-import { Environment } from '../types/index.js';
+import { Ctx, Environment } from '../types/index.js';
 export declare function getPortalDomain(env: Environment, isE2E?: boolean): "localhost" | "app.sandbox.usecapsule.com" | "app.beta.usecapsule.com" | "app.usecapsule.com";
 export declare function getPortalBaseURL({ env, isE2E }: {
     env: Environment;
@@ -13,3 +13,4 @@ export declare function constructUrl({ base, path, params, }: {
     path: string;
     params?: Record<string, string | undefined | null>;
 }): string;
+export declare function shortenUrl(ctx: Ctx, url: string): Promise<string>;

package/dist/types/utils/wallet.d.ts

@@ -1,4 +1,4 @@
-import { SupportedWalletTypes, TPregenIdentifierType, WalletEntity, WalletScheme, WalletType } from '@getpara/user-management-client';
+import { CurrentWalletIds, SupportedWalletTypes, TPregenIdentifierType, WalletEntity, WalletScheme, WalletType } from '@getpara/user-management-client';
 import { Wallet, WalletTypeProp } from '../types/index.js';
 export declare const WalletSchemeTypeMap: Record<WalletScheme, Partial<Record<WalletType, true>>>;
 export declare function isPregenIdentifierMatch(a: string | null | undefined, b: string | null | undefined, type: TPregenIdentifierType): boolean;
@@ -9,3 +9,4 @@ export declare function getEquivalentTypes(types: WalletTypeProp[] | WalletTypeP
 export declare function entityToWallet(w: WalletEntity): Omit<Wallet, 'signer'>;
 export declare function migrateWallet(obj: Record<string, unknown>): Wallet;
 export declare function supportedWalletTypesEq(a: SupportedWalletTypes, b: SupportedWalletTypes): boolean;
+export declare function mergeCurrentWalletIds(original: CurrentWalletIds, additional: CurrentWalletIds): CurrentWalletIds;