@coinbase/cdp-core 0.0.98 → 0.0.100

package/dist/types/platform/types.d.ts

@@ -1,71 +1,341 @@
 import { KeyPair } from '../shared/types.js';
 import { OAuthFlowState, TelegramAuthData } from '../types.js';
+/**
+ * Platform-specific cryptographic operations interface.
+ * Provides abstractions for crypto operations that may differ between platforms.
+ */
 export interface PlatformCrypto {
+    /**
+     * Creates a secp256r1 key pair for cryptographic operations.
+     *
+     * @returns A secp256r1 key pair with private key and base64-encoded public key.
+     */
     createKeyPair(): Promise<KeyPair>;
+    /**
+     * Creates an RSA key pair that allows private key export.
+     * Used for operations that require access to the raw private key for encryption/decryption.
+     *
+     * @returns An RSA key pair with exportable private key and base64-encoded public key.
+     */
     createExportKeyPair(): Promise<KeyPair>;
+    /**
+     * Computes a SHA-256 hash of the given data.
+     *
+     * @param data - The data to hash.
+     * @returns Promise that resolves to the hex-encoded hash.
+     */
     hash(data: Uint8Array): Promise<string>;
+    /**
+     * Generates a cryptographically secure random identifier.
+     *
+     * @returns A random string suitable for use as an identifier.
+     */
     generateRandomId(): string;
+    /**
+     * Generates a cryptographically secure random salt.
+     *
+     * @returns A random bigint salt.
+     */
     generateRandomSalt(): bigint;
+    /**
+     * Decrypts data using a private key with RSA-OAEP algorithm.
+     *
+     * @param privateKey - The private key to use for decryption.
+     * @param encryptedData - Base64-encoded encrypted data.
+     * @returns Promise that resolves to the decrypted string.
+     */
     decryptWithPrivateKey(privateKey: CryptoKey, encryptedData: string): Promise<ArrayBuffer>;
 }
+/**
+ * Platform-specific storage operations interface.
+ * Provides abstractions for persistent storage that may differ between platforms.
+ */
 export interface PlatformStorage {
+    /**
+     * Retrieves a value from storage.
+     *
+     * @param key - The storage key.
+     * @returns Promise that resolves to the stored value or null if not found.
+     */
     getItem(key: string): Promise<string | null>;
+    /**
+     * Stores a value in storage.
+     *
+     * @param key - The storage key.
+     * @param value - The value to store.
+     * @returns Promise that resolves when the value is stored.
+     */
     setItem(key: string, value: string): Promise<void>;
+    /**
+     * Removes a value from storage.
+     *
+     * @param key - The storage key.
+     * @returns Promise that resolves when the value is removed.
+     */
     removeItem(key: string): Promise<void>;
+    /**
+     * Clears all values from storage.
+     *
+     * @returns Promise that resolves when storage is cleared.
+     */
     clear(): Promise<void>;
 }
+/**
+ * Platform-specific secure storage operations interface.
+ * Provides abstractions for secure storage that may only be available on certain platforms.
+ * On native platforms, this typically uses the device's secure enclave (e.g., iOS Keychain, Android Keystore).
+ * On web platforms, this is typically unavailable due to browser security limitations.
+ */
 export interface PlatformSecureStorage {
+    /**
+     * Retrieves a value from secure storage.
+     *
+     * @param key - The storage key.
+     * @returns Promise that resolves to the stored value or null if not found.
+     */
     getItem(key: string): Promise<string | null>;
+    /**
+     * Stores a value in secure storage.
+     *
+     * @param key - The storage key.
+     * @param value - The value to store.
+     * @returns Promise that resolves when the value is stored.
+     */
     setItem(key: string, value: string): Promise<void>;
+    /**
+     * Removes a value from secure storage.
+     *
+     * @param key - The storage key.
+     * @returns Promise that resolves when the value is removed.
+     */
     removeItem(key: string): Promise<void>;
+    /**
+     * Clears all values from secure storage.
+     *
+     * @returns Promise that resolves when storage is cleared.
+     */
     clear(): Promise<void>;
 }
+/**
+ * Credential returned by a native Apple Sign In flow.
+ */
 export interface AppleNativeCredential {
+    /** The JSON Web Token (JWT) that securely communicates information about the user. */
     identityToken: string;
+    /** A short-lived token used to interact with Apple's servers. */
     authorizationCode?: string;
+    /** The user's email address, provided only on first sign-in. */
     email?: string | null;
 }
+/**
+ * Platform-specific OAuth operations interface.
+ * Provides abstractions for OAuth operations that may differ between platforms.
+ */
 export interface PlatformOAuth {
     initiateOAuthFlow(authUrl: string): void;
     getRedirectUrl(): string;
     getOAuthParams(url?: string): OAuthFlowState | null;
     cleanupOAuthParams(): void;
     openTelegramOAuthPopup?(authUrl: string): Promise<TelegramAuthData | null>;
+    /** Triggers a native Apple Sign In sheet (iOS only). */
     signInWithAppleNative?(): Promise<AppleNativeCredential>;
 }
+/**
+ * Result of an attestation operation.
+ */
 export interface AttestationResult {
+    /** Base64-encoded attestation object (iOS) or integrity token (Android) */
     attestation: string;
+    /** Platform identifier (bundle ID for iOS, package name for Android) */
     appIdentifier: string;
+    /** Platform type: "ios" or "android" */
     platform: "ios" | "android";
+    /** Key ID (iOS only - generated by DCAppAttestService) */
     keyId?: string;
 }
+/**
+ * Result of an assertion generation operation.
+ */
 export interface AssertionResult {
+    /** Base64-encoded assertion */
     assertion: string;
+    /** Key ID used to generate the assertion (iOS) */
     keyId?: string;
 }
+/**
+ * Configuration for attestation operations.
+ */
 export interface AttestationConfig {
+    /** Google Cloud project number for Android Play Integrity. */
     cloudProjectNumber?: string;
+    /**
+     * Whether to force re-attestation even if a key is already registered.
+     * Clears the existing key and performs fresh attestation.
+     * Useful for testing or recovering from an invalid key state.
+     *
+     * @default false
+     */
     force?: boolean;
 }
+/**
+ * Platform-specific device attestation operations interface.
+ * Provides abstractions for iOS App Attest and Android Play Integrity APIs.
+ *
+ * This is optional and only available on native mobile platforms (iOS 14+, Android 6.0+).
+ * Allows apps to prove they are legitimate instances running on genuine devices.
+ *
+ * iOS Flow (Assertion-based):
+ * 1. Check if keyId exists locally (getStoredKeyId)
+ * 2. If no keyId: attest(challenge) - Generate key + attestation
+ * 3. Register attestation with backend (stores public key server-side)
+ * 4. storeKeyId() - Persist key ID locally
+ * 5. generateAssertion() - Create signed assertions per-request using keyId
+ *
+ * Android Flow (Play Integrity):
+ * 1. initialize(config) - Required: Set up Play Integrity provider with cloudProjectNumber
+ * 2. generateAssertion() - Generate fresh tokens per-request (no attestation/registration needed)
+ */
 export interface PlatformAttestation {
+    /**
+     * Whether device attestation is enabled for the current project.
+     */
     isEnabled: boolean;
+    /**
+     * Google Cloud project number for Android Play Integrity.
+     */
     cloudProjectNumber?: string;
+    /**
+     * Initialize the attestation service.
+     *
+     * Android: Initializes the Play Integrity token provider (cloudProjectNumber required).
+     * iOS: Performs attestation registration with the CDP backend if not already registered.
+     *   Fetches a challenge, attests the app with Apple, registers the public key, and
+     *   confirms registration locally. Returns early if already registered.
+     *
+     * @param config - Platform-specific configuration (cloudProjectNumber required for Android).
+     * @returns Promise that resolves when initialization is complete.
+     * @throws Error if initialization or iOS registration fails.
+     */
     initialize(config?: AttestationConfig): Promise<void>;
+    /**
+     * Attest a key with a server-provided challenge (iOS only).
+     *
+     * iOS: Generates a key pair in Secure Enclave, creates attestation object
+     * Android: Not used - Android skips attestation and uses Play Integrity tokens directly
+     *
+     * The result should be sent to the CDP backend's /attestation/register
+     * endpoint which verifies the attestation and stores the public key.
+     *
+     * @param challenge - Server-provided challenge (base64-encoded).
+     * @returns Promise that resolves to attestation result.
+     * @throws Error if attestation fails or is not supported.
+     */
     attest(challenge: string): Promise<AttestationResult>;
+    /**
+     * Mark attestation as successfully registered with the backend (iOS only).
+     *
+     * Call this only after the backend confirms the attestation exchange succeeded.
+     * Stores a local flag so the app can avoid re-attesting on subsequent launches.
+     *
+     * @param keyId - The key ID that was registered with the backend.
+     * @returns Promise that resolves when registration is confirmed.
+     */
     confirmRegistration(keyId: string): Promise<void>;
+    /**
+     * Get the registered key ID (iOS only).
+     *
+     * Returns the key ID if attestation was successfully registered with the backend.
+     * Returns null if attestation hasn't been performed or registration wasn't confirmed.
+     *
+     * @returns Promise that resolves to the registered key ID, or null if not found.
+     */
     getRegisteredKeyId(): Promise<string | null>;
+    /**
+     * Clear all attestation state, allowing re-attestation with a new key.
+     *
+     * This should be called when:
+     * - Backend returns "Attestation key not found" (public key lost)
+     * - User explicitly requests re-attestation
+     * - Testing/debugging scenarios
+     *
+     * Important: After clearing, you MUST call initialize() again to perform
+     * fresh attestation. Until then, generateAssertion() will fail on iOS.
+     *
+     * @returns Promise that resolves when attestation state is cleared.
+     * @throws Error if clearing is not supported.
+     */
     clearAttestation(): Promise<void>;
+    /**
+     * Generate an assertion for an API request.
+     *
+     * Returns null if attestation is not yet enabled for this project (i.e. the project
+     * config has not confirmed this app's bundle ID is registered). Callers should skip
+     * adding assertion headers when null is returned.
+     *
+     * iOS: Creates a cryptographic assertion using the attested key
+     * Android: Generates a fresh Play Integrity token
+     *
+     * On failure, retries initialization once (in case no key is registered yet), then
+     * propagates the error if the retry also fails.
+     *
+     * @param clientData - Client data to include in assertion (base64-encoded).
+     * @returns Promise that resolves to assertion result, or null if attestation is disabled.
+     * @throws Error if assertion generation fails after a single retry.
+     */
     generateAssertion(clientData: string): Promise<AssertionResult | null>;
 }
+/**
+ * Platform-specific device information operations interface.
+ * Provides abstractions for device information that may differ between platforms.
+ */
 export interface PlatformDeviceInfo {
+    /**
+     * Returns the app bundle ID (iOS) or package name (Android) for the running app.
+     * Used to match against project config attestation entries.
+     * Optional — only provided on native platforms.
+     */
     getAppBundleId?(): string | undefined;
+    /**
+     * Returns the current platform ("ios" or "android").
+     * Used to populate the User-Agent header on native platforms.
+     * Optional — only provided on native platforms.
+     */
     getPlatform?(): "ios" | "android" | undefined;
 }
+/**
+ * Combined interface for all platform-specific services.
+ * This is the main interface that platform implementations must provide.
+ */
 export interface PlatformServices {
+    /**
+     * Cryptographic operations for the platform.
+     */
     crypto: PlatformCrypto;
+    /**
+     * Storage operations for the platform.
+     */
     storage: PlatformStorage;
+    /**
+     * Secure storage operations for the platform.
+     * This is optional and may not be available on all platforms (e.g., web browsers).
+     * When available, it provides access to platform-specific secure storage mechanisms
+     * such as iOS Keychain or Android Keystore.
+     */
     secureStorage?: PlatformSecureStorage;
+    /**
+     * OAuth operations for the platform.
+     */
     oauth: PlatformOAuth;
+    /**
+     * Device attestation operations for the platform.
+     * This is optional and only available on native mobile platforms (iOS 14+, Android 6.0+).
+     * Provides access to iOS App Attest and Android Play Integrity APIs for proving
+     * that requests come from legitimate app instances on genuine devices.
+     */
     attestation?: PlatformAttestation;
+    /**
+     * Device information for the platform.
+     * Optional — only provided on native platforms.
+     */
     deviceInfo?: PlatformDeviceInfo;
 }

package/dist/types/platform/web/crypto.d.ts

@@ -1,2 +1,6 @@
 import { PlatformCrypto } from '../types.js';
+/**
+ * Web platform implementation of cryptographic operations.
+ * Uses the Web Crypto API available in modern browsers.
+ */
 export declare const webCrypto: PlatformCrypto;

package/dist/types/platform/web/storage.d.ts

@@ -1,2 +1,6 @@
 import { PlatformStorage } from '../types.js';
+/**
+ * Web platform implementation of storage operations.
+ * Uses localStorage for persistent storage in web browsers.
+ */
 export declare const webStorage: PlatformStorage;

package/dist/types/secureIframe/data.d.ts

@@ -1,11 +1,20 @@
 import { SecureIframeTheme } from './types.js';
+/**
+ * The prefix for the secure iframe event types.
+ */
 export declare const SECURE_IFRAME_EVENT_TYPE_PREFIX = "CDP_WEB_SECURE_IFRAME_";
+/**
+ * The base type of event for the secure iframe.
+ */
 export declare const SECURE_IFRAME_EVENT_TYPE: {
     readonly INIT: "CDP_WEB_SECURE_IFRAME_INIT";
     readonly LISTENING: "CDP_WEB_SECURE_IFRAME_LISTENING";
     readonly STATUS: "CDP_WEB_SECURE_IFRAME_STATUS";
     readonly THEME: "CDP_WEB_SECURE_IFRAME_THEME";
 };
+/**
+ * The type of event for the secure iframe key export.
+ */
 export declare const SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE: {
     readonly GET_PRIVATE_KEY: "CDP_WEB_SECURE_IFRAME_GET_PRIVATE_KEY";
     readonly INIT: "CDP_WEB_SECURE_IFRAME_INIT";
@@ -13,5 +22,11 @@ export declare const SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE: {
     readonly STATUS: "CDP_WEB_SECURE_IFRAME_STATUS";
     readonly THEME: "CDP_WEB_SECURE_IFRAME_THEME";
 };
+/**
+ * The default base path for the secure iframe.
+ */
 export declare const DEFAULT_SECURE_IFRAME_BASE_PATH = "https://secure-wallet.cdp.coinbase.com";
+/**
+ * The default theme for the secure iframe.
+ */
 export declare const DEFAULT_SECURE_IFRAME_THEME: SecureIframeTheme;

package/dist/types/secureIframe/types.d.ts

@@ -1,49 +1,103 @@
 import { SECURE_IFRAME_EVENT_TYPE, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE } from './data.js';
 import { AuthManager } from '../auth/authManager.js';
+/**
+ * The theme for the secure iframe.
+ * Colors should be hex strings (with or without alpha) or the string "transparent".
+ */
 export type SecureIframeTheme = {
+    /** The background color of the page. */
     pageBg: string;
+    /** The background color of the button. */
     buttonBg: string;
+    /** The background color of the button when hovered. */
     buttonBgHover: string;
+    /** The background color of the button when pressed. */
     buttonBgPressed: string;
+    /** The background color of the button when focused. */
     buttonBgFocus: string;
+    /** The border color of the button. */
     buttonBorder: string;
+    /** The border color of the button when hovered. */
     buttonBorderHover: string;
+    /** The border color of the button when pressed. */
     buttonBorderPressed: string;
+    /** The ring color of the button when focused. */
     buttonBorderFocus: string;
+    /** The inner ring color of the button when focused. */
     buttonBorderFocusInset: string;
+    /** The text color of the button. */
     buttonText: string;
+    /** The text color of the button when hovered. */
     buttonTextHover: string;
+    /** The text color of the button when pressed. */
     buttonTextPressed: string;
+    /** The text color of the button when focused. */
     buttonTextFocus: string;
+    /** The border radius of the button. */
     buttonBorderRadius: number;
+    /** The font size of the button. */
     buttonFontSize: number;
+    /** The font weight of the button. */
     buttonFontWeight: number;
+    /** The size of the button. */
     buttonSize: "xs" | "sm" | "md" | "lg";
+    /** The URL of the font to use for the button. Must be a google webfont URL. */
     fontUrl: string;
+    /** The font family to use for the button. */
     fontFamily: string;
 };
+/**
+ * The authentication state for the secure iframe. This is provided by the parent window.
+ */
 export type SecureIframeAuthState = Parameters<AuthManager["setAuthState"]>[0];
+/**
+ * The type of account/chain for the secure iframe operations.
+ */
 export type SecureIframeChainType = "evm" | "solana";
+/**
+ * Shared context data required for secure iframe operations.
+ */
 export type SecureIframeContext = {
     authState: SecureIframeAuthState;
     theme?: SecureIframeTheme;
 };
+/**
+ * The type of event for the secure iframe.
+ */
 export type SecureIframeEventType = typeof SECURE_IFRAME_EVENT_TYPE;
+/**
+ * The message sent to the secure iframe to initialize it.
+ */
 export type SecureIframeInitMessage = {
     type: SecureIframeEventType["INIT"];
     payload: SecureIframeContext;
 };
+/**
+ * The message sent to the secure iframe to update the theme.
+ */
 export type SecureIframeThemeMessage = {
     type: SecureIframeEventType["THEME"];
     payload: {
         theme: Partial<SecureIframeTheme>;
     };
 };
+/**
+ * The messages sent to the secure iframe from the parent window.
+ */
 export type SecureIframeIncomingMessage = SecureIframeInitMessage | SecureIframeThemeMessage;
+/**
+ * The message sent from the secure iframe to the parent window to indicate that it is ready to receive events.
+ */
 export type SecureIframeListeningMessage = {
     type: SecureIframeEventType["LISTENING"];
 };
+/**
+ * The status of the secure iframe.
+ */
 export type SecureIframeStatus = "ready" | "success" | "error" | "expiring" | "expired";
+/**
+ * The message sent from the secure iframe to the parent window to indicate the status of the private key retrieval.
+ */
 export type SecureIframeStatusMessage = {
     type: SecureIframeEventType["STATUS"];
     payload: {
@@ -51,8 +105,17 @@ export type SecureIframeStatusMessage = {
         message?: string;
     };
 };
+/**
+ * The messages sent from the secure iframe to the parent window.
+ */
 export type SecureIframeOutgoingMessage = SecureIframeListeningMessage | SecureIframeStatusMessage;
+/**
+ * The type of event for the secure iframe key export.
+ */
 export type SecureIframeKeyExportEventType = typeof SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE;
+/**
+ * The message sent to the secure iframe to trigger fetching the private key.
+ */
 export type SecureIframeGetPrivateKeyMessage = {
     type: SecureIframeKeyExportEventType["GET_PRIVATE_KEY"];
     payload: SecureIframeContext & {
@@ -60,5 +123,11 @@ export type SecureIframeGetPrivateKeyMessage = {
         type: SecureIframeChainType;
     };
 };
+/**
+ * The messages sent to the secure iframe from the parent window for key export.
+ */
 export type SecureIframeKeyExportIncomingMessage = SecureIframeIncomingMessage | SecureIframeGetPrivateKeyMessage;
+/**
+ * The messages sent from the secure iframe to the parent window for key export.
+ */
 export type SecureIframeKeyExportOutgoingMessage = SecureIframeOutgoingMessage;

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

@@ -1,15 +1,81 @@
 import { SecureIframeKeyExportIncomingMessage, SecureIframeKeyExportOutgoingMessage, SecureIframeTheme } from './types.js';
+/**
+ * Options for building a key export iframe URL.
+ */
 export interface BuildKeyExportIframeUrlOptions {
+    /**
+     * The project ID for authentication.
+     */
     projectId: string;
+    /**
+     * The base path of the secure iframe.
+     *
+     * @default "https://secure-wallet.cdp.coinbase.com"
+     */
     basePath?: string;
+    /**
+     * The label for the button displayed in the iframe.
+     */
     label?: string;
+    /**
+     * The label to display when the key is copied successfully.
+     */
     copiedLabel?: string;
+    /**
+     * Whether to show an icon in the button.
+     *
+     * @default true
+     */
     icon?: boolean;
 }
+/**
+ * Validates that the function is called in a browser environment.
+ *
+ * @throws Error if the function is not called in a browser environment.
+ */
 export declare function validateSecureIframeEnvironment(): void;
+/**
+ * Builds the URL for the key export secure iframe with query parameters.
+ *
+ * @param options - The options for building the URL.
+ * @returns The complete iframe URL.
+ */
 export declare function buildKeyExportIframeUrl(options: BuildKeyExportIframeUrlOptions): string;
+/**
+ * Sends a message to the secure iframe.
+ *
+ * @param iframe - The iframe element to send the message to.
+ * @param message - The message to send.
+ */
 export declare function sendSecureIframeMessage(iframe: HTMLIFrameElement | null, message: SecureIframeKeyExportIncomingMessage): void;
+/**
+ * Extracts the origin from a URL string.
+ *
+ * @param url - The URL to extract the origin from.
+ * @returns The origin string, or empty string if parsing fails.
+ */
 export declare function getSecureIframeOrigin(url: string): string;
+/**
+ * Creates an iframe element inside the target container.
+ *
+ * @param target - Either a CSS selector string or an HTMLElement container.
+ *   If a string, will query for an element and create an iframe inside it.
+ *   If an HTMLElement, will create an iframe inside it.
+ * @returns The iframe element.
+ * @throws InputValidationError if target is an iframe element, selector resolves to an iframe, or selector doesn't match any element.
+ */
 export declare function createIframe(target: string | HTMLElement): HTMLIFrameElement;
+/**
+ * Calculates the height of the secure iframe based on button size and font size.
+ *
+ * @param theme - Optional theme with buttonSize and buttonFontSize.
+ * @returns The calculated height in pixels.
+ */
 export declare function calculateSecureIframeHeight(theme?: Partial<SecureIframeTheme>): number;
+/**
+ * Checks if the message is a key export message.
+ *
+ * @param {unknown} message - The message to check.
+ * @returns {boolean} True if the message is a key export message, false otherwise.
+ */
 export declare const isSecureIframeKeyExportMessage: (message: unknown) => message is SecureIframeKeyExportIncomingMessage | SecureIframeKeyExportOutgoingMessage;

package/dist/types/shared/base64.d.ts

@@ -1,2 +1,16 @@
+/**
+ * Platform-agnostic base64 encoding function.
+ * Uses native btoa() when available, falls back to manual implementation.
+ *
+ * @param data - The Uint8Array to encode.
+ * @returns The base64-encoded string.
+ */
 export declare function encodeBase64(data: Uint8Array): string;
+/**
+ * Platform-agnostic base64 decoding function.
+ * Uses native atob() when available, falls back to manual implementation.
+ *
+ * @param base64 - The base64-encoded string to decode.
+ * @returns The decoded Uint8Array.
+ */
 export declare function decodeBase64(base64: string): Uint8Array;

package/dist/types/shared/completeAuthFlow.d.ts

@@ -1,4 +1,13 @@
 import { EndUser } from '@coinbase/cdp-api-client';
+/**
+ * Completes the authentication flow after a successful auth response.
+ * Sets the auth state and creates any accounts configured for auto-creation on login.
+ *
+ * @param authResponse - The authentication response containing access token, expiry, and end user.
+ * @param authResponse.accessToken - The access token.
+ * @param authResponse.validUntil - The expiry date of the access token in ISO 8601 format.
+ * @param authResponse.endUser - The authenticated end user.
+ */
 export declare const completeAuthFlow: (authResponse: {
     accessToken: string;
     validUntil: string;

package/dist/types/shared/createEvmAccountIfNeeded.d.ts

@@ -1,2 +1,11 @@
 import { AuthState } from '../auth/types.js';
+/**
+ * Creates an EVM account if needed based on configuration.
+ *
+ * @param authState - The current authentication state
+ * @param accessToken - The access token or custom auth JWT
+ * @param validUntil - The valid until date and time
+ * @param accountType - The type of EVM account to create ("eoa" or "smart")
+ * @returns The updated authentication state
+ */
 export declare const createEvmAccountIfNeeded: (authState: AuthState, accessToken: string, validUntil: string, accountType: "eoa" | "smart") => Promise<AuthState>;

package/dist/types/shared/createSolanaAccountIfNeeded.d.ts

@@ -1,2 +1,10 @@
 import { AuthState } from '../auth/types.js';
+/**
+ * Creates a Solana account if needed based on configuration.
+ *
+ * @param authState - The current authentication state
+ * @param accessToken - The access token or custom auth JWT
+ * @param validUntil - The valid until date and time
+ * @returns The updated authentication state
+ */
 export declare const createSolanaAccountIfNeeded: (authState: AuthState, accessToken: string, validUntil: string) => Promise<AuthState>;