@mocanetwork/airkit 0.5.0-beta.2

package/dist/lib.esm/ws-embed/src/siteMetadata.js

@@ -0,0 +1,75 @@
+/**
+ * Returns whether the given image URL exists
+ * @param url - the url of the image
+ * @returns whether the image exists
+ */
+function imgExists(url) {
+  return new Promise((resolve, reject) => {
+    try {
+      const img = document.createElement("img");
+      img.onload = () => resolve(true);
+      img.onerror = () => resolve(false);
+      img.src = url;
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+/**
+ * Extracts a name for the site from the DOM
+ */
+const getSiteName = window => {
+  const {
+    document
+  } = window;
+  const siteName = document.querySelector('head > meta[property="og:site_name"]');
+  if (siteName) {
+    return siteName.content;
+  }
+  const metaTitle = document.querySelector('head > meta[name="title"]');
+  if (metaTitle) {
+    return metaTitle.content;
+  }
+  if (document.title && document.title.length > 0) {
+    return document.title;
+  }
+  return window.location.hostname;
+};
+
+/**
+ * Extracts an icon for the site from the DOM
+ */
+async function getSiteIcon(window) {
+  try {
+    const {
+      document
+    } = window;
+
+    // Use the site's favicon if it exists
+    let icon = document.querySelector('head > link[rel="shortcut icon"]');
+    if (icon && (await imgExists(icon.href))) {
+      return icon.href;
+    }
+
+    // Search through available icons in no particular order
+    icon = Array.from(document.querySelectorAll('head > link[rel="icon"]')).find(_icon => Boolean(_icon.href));
+    if (icon && (await imgExists(icon.href))) {
+      return icon.href;
+    }
+    return "";
+  } catch (error) {
+    return "";
+  }
+}
+
+/**
+ * Gets site metadata and returns it
+ *
+ */
+const getSiteMetadata = async () => ({
+  name: getSiteName(window),
+  icon: await getSiteIcon(window)
+});
+
+export { getSiteMetadata as default };

package/dist/lib.esm/ws-embed/src/utils.js

@@ -0,0 +1,88 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { rpcErrors } from '@web3auth/auth';
+import { EMBED_BUILD_ENV } from './interfaces.js';
+import log from './loglevel.js';
+
+const AIR_URLS = {
+  [EMBED_BUILD_ENV.TESTING]: {
+    authUrl: "http://localhost:8100",
+    walletUrl: "https://lrc-mocaverse.web3auth.io",
+    logLevel: "debug"
+  },
+  [EMBED_BUILD_ENV.DEVELOPMENT]: {
+    authUrl: "http://localhost:8100",
+    walletUrl: "https://localhost:4050",
+    logLevel: "debug"
+  },
+  [EMBED_BUILD_ENV.STAGING]: {
+    authUrl: "https://login.staging.realmnetwork.io",
+    walletUrl: "https://account.staging.realmnetwork.io",
+    logLevel: "info"
+  },
+  [EMBED_BUILD_ENV.PRODUCTION]: {
+    authUrl: "https://login.realmnetwork.io",
+    walletUrl: "https://account.realmnetwork.io",
+    logLevel: "error"
+  }
+};
+const htmlToElement = html => {
+  const template = window.document.createElement("template");
+  const trimmedHtml = html.trim(); // Never return a text node of whitespace as the result
+  template.innerHTML = trimmedHtml;
+  return template.content.firstChild;
+};
+const isElement = element => element instanceof Element || element instanceof Document;
+
+/**
+ * json-rpc-engine middleware that logs RPC errors and and validates req.method.
+ *
+ * @param log - The logging API to use.
+ * @returns  json-rpc-engine middleware function
+ */
+function createErrorMiddleware() {
+  return (req, res, next) => {
+    // json-rpc-engine will terminate the request when it notices this error
+    if (typeof req.method !== "string" || !req.method) {
+      res.error = rpcErrors.invalidRequest({
+        message: `The request 'method' must be a non-empty string.`,
+        data: _objectSpread(_objectSpread({}, req || {}), {}, {
+          cause: `The request 'method' must be a non-empty string.`
+        })
+      });
+    }
+    next(done => {
+      const {
+        error
+      } = res;
+      if (!error) {
+        return done();
+      }
+      log.error(`Ws-Embed - RPC Error: ${error.message}`, error);
+      return done();
+    });
+  };
+}
+
+/**
+ * Logs a stream disconnection error. Emits an 'error' if given an
+ * EventEmitter that has listeners for the 'error' event.
+ *
+ * @param log - The logging API to use.
+ * @param remoteLabel - The label of the disconnected stream.
+ * @param error - The associated error to log.
+ * @param emitter - The logging API to use.
+ */
+function logStreamDisconnectWarning(remoteLabel, error, emitter) {
+  let warningMsg = `Web3Auth: Lost connection to "${remoteLabel}".`;
+  if (error !== null && error !== void 0 && error.stack) {
+    warningMsg += `\n${error.stack}`;
+  }
+  log.warn(warningMsg);
+  if (emitter && emitter.listenerCount("error") > 0) {
+    emitter.emit("error", warningMsg);
+  }
+}
+const EMITTED_NOTIFICATIONS = ["eth_subscription" // per eth-json-rpc-filters/subscriptionManager
+];
+
+export { AIR_URLS, EMITTED_NOTIFICATIONS, createErrorMiddleware, htmlToElement, isElement, logStreamDisconnectWarning };

package/dist/types/PopupHandler.d.ts

@@ -0,0 +1,24 @@
+import { SafeEventEmitter } from "@web3auth/auth";
+type PopupHandlerEvents = {
+    close: () => void;
+};
+declare class PopupHandler extends SafeEventEmitter<PopupHandlerEvents> {
+    url: URL;
+    target: string;
+    features: string;
+    window: Window;
+    windowTimer: number;
+    iClosedWindow: boolean;
+    timeout: number;
+    constructor({ url, target, features, timeout }: {
+        url: URL;
+        target?: string;
+        features?: string;
+        timeout?: number;
+    });
+    _setupTimer(): void;
+    open(): void;
+    close(): void;
+    redirect(locationReplaceOnRedirect: boolean): void;
+}
+export default PopupHandler;

package/dist/types/airService.d.ts

@@ -0,0 +1,34 @@
+import AirInPageProvider from "./inPageProvider";
+import { AirEmbedConnectResult, AirEmbedLoginResult, AirEventListener, AirLoginResult, AirPartnerUserDetails, AirUserDetails, ClaimAirIdOptions, EMBED_BUILD_ENV_TYPE } from "./interfaces";
+declare class AirService {
+    #private;
+    constructor({ partnerId }: {
+        partnerId: string;
+    });
+    get buildEnv(): EMBED_BUILD_ENV_TYPE;
+    get isAirAuth(): boolean;
+    get isInitialized(): boolean;
+    get isLoggedIn(): boolean;
+    get isWalletLoaded(): boolean;
+    init({ buildEnv, enableLogging, skipRehydration, }: {
+        buildEnv: EMBED_BUILD_ENV_TYPE;
+        enableLogging: boolean;
+        skipRehydration: boolean;
+    }): Promise<AirLoginResult | null>;
+    cleanUp(): Promise<void>;
+    login(options?: {
+        authToken?: string;
+    }): Promise<AirLoginResult>;
+    deploySmartAccount(): Promise<void>;
+    logout(): Promise<void>;
+    getProvider(): Promise<AirInPageProvider>;
+    preloadWallet(): Promise<AirEmbedConnectResult | AirEmbedLoginResult>;
+    claimAirId(options?: ClaimAirIdOptions): Promise<AirEmbedLoginResult | AirEmbedConnectResult>;
+    getUserInfo(): Promise<AirUserDetails>;
+    getPartnerUserInfo(): Promise<AirPartnerUserDetails>;
+    on(listener: AirEventListener): void;
+    off(listener: AirEventListener): void;
+    clearEventListeners(): void;
+    private _showWalletWidget;
+}
+export default AirService;

package/dist/types/baseProvider.d.ts

@@ -0,0 +1,66 @@
+import { JRPCEngine, JRPCRequest, ProviderEvents, RequestArguments, SafeEventEmitter, SafeEventEmitterProvider, SendCallBack } from "@web3auth/auth";
+import type { Duplex } from "readable-stream";
+import { BaseProviderState, Maybe, ProviderOptions, UnValidatedJsonRpcRequest } from "./interfaces";
+/**
+ * @param connectionStream - A Node.js duplex stream
+ * @param opts - An options bag
+ */
+declare abstract class BaseProvider<U extends BaseProviderState, E extends ProviderEvents = ProviderEvents> extends SafeEventEmitter<E> implements SafeEventEmitterProvider<E> {
+    rpcEngine: JRPCEngine;
+    jsonRpcConnectionEvents: SafeEventEmitter;
+    /**
+     * Indicating that this provider is a Web3Auth provider.
+     */
+    readonly isWeb3Auth: true;
+    protected state: U;
+    constructor(connectionStream: Duplex, { maxEventListeners, jsonRpcStreamName }: ProviderOptions);
+    /**
+     * Submits an RPC request for the given method, with the given params.
+     * Resolves with the result of the method call, or rejects on error.
+     *
+     * @param args - The RPC request arguments.
+     * @returns A Promise that resolves with the result of the RPC method,
+     * or rejects if an error is encountered.
+     */
+    request<T, P>(args: RequestArguments<T>): Promise<Maybe<P>>;
+    send<T, V>(req: JRPCRequest<T>, callback: SendCallBack<V>): void;
+    sendAsync<T, V>(req: JRPCRequest<T>): Promise<V>;
+    /**
+     * Called when connection is lost to critical streams.
+     *
+     * emits InpageProvider#disconnect
+     */
+    protected handleStreamDisconnect(streamName: string, error: Error): void;
+    /**
+     * Constructor helper.
+     * Populates initial state by calling 'wallet_getProviderState' and emits
+     * necessary events.
+     */
+    abstract initializeState(...args: unknown[]): Promise<void>;
+    /**
+     * Internal RPC method. Forwards requests to background via the RPC engine.
+     * Also remap ids inbound and outbound
+     */
+    protected abstract rpcRequest(payload: UnValidatedJsonRpcRequest | UnValidatedJsonRpcRequest[], callback: (...args: unknown[]) => void, isInternal?: boolean): void;
+    /**
+     * When the provider becomes connected, updates internal state and emits
+     * required events. Idempotent.
+     *
+     * @param chainId - The ID of the newly connected chain.
+     * emits InPageProvider#connect
+     */
+    protected abstract handleConnect(...args: unknown[]): void;
+    /**
+     * When the provider becomes disconnected, updates internal state and emits
+     * required events. Idempotent with respect to the isRecoverable parameter.
+     *
+     * Error codes per the CloseEvent status codes as required by EIP-1193:
+     * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+     *
+     * @param isRecoverable - Whether the disconnection is recoverable.
+     * @param errorMessage - A custom error message.
+     * emits InpageProvider#disconnect
+     */
+    protected abstract handleDisconnect(isRecoverable: boolean, errorMessage?: string): void;
+}
+export default BaseProvider;

package/dist/types/common/custom.d.ts

@@ -0,0 +1,4 @@
+declare module "*.svg" {
+  const content: any;
+  export default content;
+}

package/dist/types/common/error.d.ts

@@ -0,0 +1,17 @@
+import { Jsonable } from "./types";
+export declare class BaseError<TName extends string> extends Error {
+    readonly name: TName;
+    readonly cause?: Error;
+    readonly context?: Jsonable;
+    constructor(name: TName, message?: string, options?: {
+        cause?: Error;
+        context?: Jsonable;
+    });
+    toJSON(): {
+        name: TName;
+        message: string;
+        context: Jsonable;
+        cause: Error;
+    };
+}
+export declare function ensureError(value: unknown): Error;

package/dist/types/common/realm/error/auth.d.ts

@@ -0,0 +1 @@
+export type AuthErrorName = "USER_CANCELLED" | "CLIENT_ERROR" | "CONFIG_ERROR" | "UNKNOWN_ERROR";

package/dist/types/common/realm/error/types.d.ts

@@ -0,0 +1 @@
+export type AirErrorName = "USER_CANCELLED" | "CONFIG_ERROR" | "SERVER_ERROR" | "CLIENT_ERROR" | "UNKNOWN_ERROR";

package/dist/types/common/realm/messaging/auth.d.ts

@@ -0,0 +1,138 @@
+import { AuthErrorName } from "../error/auth";
+import { AirErrorName } from "../error/types";
+import { AirIdDetails, GlobalId } from "../user/types";
+export declare const AirAuthMessageTypes: {
+    readonly SETUP_COMPLETED: "air_auth_setup_completed";
+    readonly LOGIN_REQUEST: "air_auth_login_request";
+    readonly LOGIN_RESPONSE: "air_auth_login_response";
+    readonly LOGIN_WALLET_RESPONSE: "air_auth_login_wallet_response";
+    readonly USER_INFO_REQUEST: "air_auth_user_info_request";
+    readonly USER_INFO_RESPONSE: "air_auth_user_info_response";
+    readonly PARTNER_USER_INFO_REQUEST: "air_auth_partner_user_info_request";
+    readonly PARTNER_USER_INFO_RESPONSE: "air_auth_partner_user_info_response";
+    readonly REFRESH_TOKEN_REQUEST: "air_auth_refresh_token_request";
+    readonly REFRESH_TOKEN_RESPONSE: "air_auth_refresh_token_response";
+    readonly WALLET_TOKEN_REQUEST: "air_auth_wallet_token_request";
+    readonly WALLET_TOKEN_RESPONSE: "air_auth_wallet_token_response";
+    readonly INITIALIZATION_REQUEST: "air_auth_initialization_request";
+    readonly INITIALIZATION_RESPONSE: "air_auth_initialization_response";
+    readonly INIT_WALLET_COMMUNICATION: "air_auth_init_wallet_communication";
+    readonly IFRAME_VISIBILITY_REQUEST: "air_auth_iframe_visibility_request";
+    readonly SETUP_WALLET_REQUEST: "air_auth_setup_wallet_request";
+    readonly SETUP_WALLET_RESPONSE: "air_auth_setup_wallet_response";
+    readonly SIGN_SIWE_MESSAGE_REQUEST: "air_auth_sign_siwe_message_request";
+    readonly SIGN_SIWE_MESSAGE_RESPONSE: "air_auth_sign_siwe_message_response";
+    readonly LOGOUT_REQUEST: "air_auth_logout_request";
+    readonly LOGOUT_RESPONSE: "air_auth_logout_response";
+};
+export type AirAuthMessageType = (typeof AirAuthMessageTypes)[keyof typeof AirAuthMessageTypes];
+type AirAuthMessageBase<TType extends AirAuthMessageType, TPayload> = {
+    type: TType;
+    payload: TPayload;
+};
+type AirAuthMessageBaseWithoutPayload<TType extends AirAuthMessageType> = {
+    type: TType;
+};
+export type AirAuthError = {
+    success: false;
+    errorName: AuthErrorName;
+    errorMessage?: string;
+};
+export type AirAuthSuccess = {
+    success: true;
+    email?: string;
+    partnerAccessToken: string;
+} & GlobalId;
+export type AirAuthSuccessTokens = {
+    success: true;
+    accessToken: string;
+    partnerAccessToken: string;
+};
+export type AirAuthUserDetailsSuccess = {
+    success: true;
+    email?: string;
+    airIds: AirIdDetails[];
+} & GlobalId;
+export type AirAuthPartnerUserDetailsSuccess = {
+    success: true;
+    partnerId: string;
+    partnerUserId: string;
+    airId?: AirIdDetails;
+};
+export type AirAuthSuccessWithAirIdsAndTokens = AirAuthUserDetailsSuccess & AirAuthSuccessTokens;
+type AirAuthLoginResponseToEmbedPayload = AirAuthSuccess | AirAuthError;
+type AirAuthLoginResponseToWalletPayload = AirAuthSuccessWithAirIdsAndTokens | AirAuthError;
+type AirAuthRefreshTokenResponsePayload = AirAuthSuccessTokens | AirAuthError;
+type AirAuthUserInfoResponsePayload = AirAuthUserDetailsSuccess | AirAuthError;
+type AirAuthPartnerUserInfoResponsePayload = AirAuthPartnerUserDetailsSuccess | AirAuthError;
+type AirAuthWalletTokenRequestPayload = {
+    nonce: string;
+    partnerId: string;
+};
+type AirAuthWalletTokenResponsePayload = {
+    success: true;
+    accessToken: string;
+    walletToken: string;
+} | AirAuthError;
+type AirAuthInitializationResponsePayload = (AirAuthSuccess & {
+    rehydrated: true;
+}) | (Pick<AirAuthSuccess, "success"> & {
+    rehydrated: false;
+}) | AirAuthError;
+type AirAuthLoginRequestPayload = {
+    partnerLoginToken?: string;
+    web3AuthJwt?: string;
+};
+type AirAuthSetupWalletSuccessPayload = {
+    success: true;
+};
+type AirAuthSetupWalletErrorPayload = {
+    success: false;
+    errorName: AuthErrorName;
+    errorMessage: string;
+};
+type AirAuthSetupWalletResponsePayload = AirAuthSetupWalletSuccessPayload | AirAuthSetupWalletErrorPayload;
+type AirAuthSignSiweMessageRequestPayload = {
+    wallet: string;
+};
+export type AirAuthSignSiweMessageSuccessPayload = {
+    success: true;
+    address: string;
+    message: string;
+    signature: string;
+};
+type AirAuthSignSiweMessageErrorPayload = {
+    success: false;
+    errorName: AirErrorName;
+    errorMessage: string;
+};
+type AirAuthSignSiweMessageResponsePayload = AirAuthSignSiweMessageSuccessPayload | AirAuthSignSiweMessageErrorPayload;
+export type AirAuthLoginRequestMessage = AirAuthMessageBase<"air_auth_login_request", AirAuthLoginRequestPayload>;
+export type AirAuthLoginResponseToEmbedMessage = AirAuthMessageBase<"air_auth_login_response", AirAuthLoginResponseToEmbedPayload>;
+export type AirAuthLoginResponseToWalletServiceMessage = AirAuthMessageBase<"air_auth_login_wallet_response", AirAuthLoginResponseToWalletPayload>;
+export type AirAuthUserInfoRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_user_info_request">;
+export type AirAuthUserInfoResponseMessage = AirAuthMessageBase<"air_auth_user_info_response", AirAuthUserInfoResponsePayload>;
+export type AirAuthPartnerUserInfoRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_partner_user_info_request">;
+export type AirAuthPartnerUserInfoResponseMessage = AirAuthMessageBase<"air_auth_partner_user_info_response", AirAuthPartnerUserInfoResponsePayload>;
+export type AirAuthRefreshTokenRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_refresh_token_request">;
+export type AirAuthRefreshTokenResponseMessage = AirAuthMessageBase<"air_auth_refresh_token_response", AirAuthRefreshTokenResponsePayload>;
+export type AirAuthWalletTokenRequestMessage = AirAuthMessageBase<"air_auth_wallet_token_request", AirAuthWalletTokenRequestPayload>;
+export type AirAuthWalletTokenResponseMessage = AirAuthMessageBase<"air_auth_wallet_token_response", AirAuthWalletTokenResponsePayload>;
+export type AirAuthInitializationResponseMessage = AirAuthMessageBase<"air_auth_initialization_response", AirAuthInitializationResponsePayload>;
+export type AirAuthInitializationRequestMessage = AirAuthMessageBase<"air_auth_initialization_request", {
+    partnerId: string;
+    skipRehydration?: boolean;
+}>;
+export type AirAuthSetupCompletedMessage = AirAuthMessageBaseWithoutPayload<"air_auth_setup_completed">;
+export type AirAuthInitWalletCommunicationMessage = AirAuthMessageBaseWithoutPayload<"air_auth_init_wallet_communication">;
+export type AirAuthSetupWalletRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_setup_wallet_request">;
+export type AirAuthSetupWalletResponseMessage = AirAuthMessageBase<"air_auth_setup_wallet_response", AirAuthSetupWalletResponsePayload>;
+export type AirAuthSignSiweMessageRequestMessage = AirAuthMessageBase<"air_auth_sign_siwe_message_request", AirAuthSignSiweMessageRequestPayload>;
+export type AirAuthSignSiweMessageResponseMessage = AirAuthMessageBase<"air_auth_sign_siwe_message_response", AirAuthSignSiweMessageResponsePayload>;
+export type AirAuthLogoutRequestMessage = AirAuthMessageBaseWithoutPayload<"air_auth_logout_request">;
+export type AirAuthLogoutResponseMessage = AirAuthMessageBaseWithoutPayload<"air_auth_logout_response">;
+export type AirAuthIframeVisibilityRequestMessage = AirAuthMessageBase<"air_auth_iframe_visibility_request", {
+    visible: boolean;
+}>;
+export type AirAuthMessage = AirAuthSetupCompletedMessage | AirAuthInitializationRequestMessage | AirAuthInitializationResponseMessage | AirAuthLoginRequestMessage | AirAuthLoginResponseToEmbedMessage | AirAuthLoginResponseToWalletServiceMessage | AirAuthUserInfoRequestMessage | AirAuthUserInfoResponseMessage | AirAuthPartnerUserInfoRequestMessage | AirAuthPartnerUserInfoResponseMessage | AirAuthRefreshTokenRequestMessage | AirAuthRefreshTokenResponseMessage | AirAuthWalletTokenRequestMessage | AirAuthWalletTokenResponseMessage | AirAuthInitWalletCommunicationMessage | AirAuthSetupWalletRequestMessage | AirAuthSetupWalletResponseMessage | AirAuthSignSiweMessageRequestMessage | AirAuthSignSiweMessageResponseMessage | AirAuthLogoutRequestMessage | AirAuthLogoutResponseMessage | AirAuthIframeVisibilityRequestMessage;
+export {};

package/dist/types/common/realm/messaging/types.d.ts

@@ -0,0 +1,95 @@
+import { AirErrorName } from "../error/types";
+export declare const AirMessageTypes: {
+    readonly SERVICE_INITIALIZED: "air_service_initialized";
+    readonly SERVICE_INITIALIZED_ERROR: "air_service_initialized_error";
+    readonly LOGIN_REQUEST: "air_login_request";
+    readonly CLAIM_REQUEST: "air_claim_request";
+    readonly LOGIN_CLAIM_STATE: "air_login_claim_state";
+    readonly CLOSE_MODAL: "air_close_modal";
+    readonly INIT_AUTH_COMMUNICATION: "air_init_auth_communication";
+    readonly DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request";
+    readonly DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response";
+};
+export declare const AirLoginClaimStates: {
+    readonly CONNECTED: "connected";
+    readonly LOGGED_IN: "logged_in";
+    readonly CLAIM_FLOW_STARTED: "claim_flow_started";
+    readonly CLAIM_FLOW_CANCELLED: "claim_flow_cancelled";
+    readonly MINTING_STARTED: "minting_started";
+    readonly MINTING_FAILED: "minting_failed";
+};
+export type AirRehydrationResult = "failed" | "connected" | "logged_in";
+export type RealmRehydrationResult = AirRehydrationResult;
+export type AirMessageType = (typeof AirMessageTypes)[keyof typeof AirMessageTypes];
+type AirMessageBase<TType extends AirMessageType, TPayload> = {
+    type: TType;
+    payload: TPayload;
+};
+type AirMessageBaseWithoutPayload<TType extends AirMessageType> = {
+    type: TType;
+};
+export type AirServiceInitializedMessage = AirMessageBase<"air_service_initialized", {
+    rehydration: AirRehydrationResult;
+    isRehydrationSuccessful: boolean;
+}>;
+export type AirServiceInitializedErrorMessage = AirMessageBase<"air_service_initialized_error", {
+    errorName: AirErrorName;
+    errorMessage?: string;
+}>;
+export type AirLoginRequestMessage = AirMessageBase<"air_login_request", {
+    token?: string;
+    skipClaimFlow: boolean;
+    customAuthToken?: string;
+    isLegacyLogin: boolean;
+}>;
+export type AirClaimRequestMessage = AirMessageBase<"air_claim_request", {
+    token?: string;
+    claimInBackground?: boolean;
+}>;
+export type AirLoginClaimStateLoggedInMessage = {
+    state: typeof AirLoginClaimStates.LOGGED_IN;
+    addresses: {
+        eoa: string;
+        aa: string;
+    };
+    airId: string;
+    token: string;
+    sessionId?: string;
+};
+export type AirLoginClaimStateConnectedMessage = {
+    state: typeof AirLoginClaimStates.CONNECTED;
+    addresses?: {
+        eoa: string;
+    };
+    token?: string;
+    sessionId?: string;
+};
+export type AirLoginClaimStateClaimFlowStartedMessage = {
+    state: typeof AirLoginClaimStates.CLAIM_FLOW_STARTED;
+};
+export type AirLoginClaimStateClaimFlowCancelledMessage = {
+    state: typeof AirLoginClaimStates.CLAIM_FLOW_CANCELLED;
+    errorName: AirErrorName;
+    errorMessage?: string;
+};
+export type AirLoginClaimStateMintingStartedMessage = {
+    state: typeof AirLoginClaimStates.MINTING_STARTED;
+};
+export type AirLoginClaimStateMintingFailedMessage = {
+    state: typeof AirLoginClaimStates.MINTING_FAILED;
+    errorMessage?: string;
+};
+export type AirLoginClaimStateMessage = AirMessageBase<"air_login_claim_state", AirLoginClaimStateLoggedInMessage | AirLoginClaimStateConnectedMessage | AirLoginClaimStateClaimFlowStartedMessage | AirLoginClaimStateClaimFlowCancelledMessage | AirLoginClaimStateMintingStartedMessage | AirLoginClaimStateMintingFailedMessage>;
+export type AirCloseModalMessage = AirMessageBaseWithoutPayload<"air_close_modal">;
+export type AirInitAuthCommunicationMessage = AirMessageBaseWithoutPayload<"air_init_auth_communication">;
+export type AirDeploySmartAccountRequestMessage = AirMessageBaseWithoutPayload<"air_deploy_smart_account_request">;
+export type AirDeploySmartAccountResponseMessage = AirMessageBase<"air_deploy_smart_account_response", {
+    success: true;
+    txHash: string;
+} | {
+    success: false;
+    errorMessage: string;
+}>;
+export type AirMessage = AirServiceInitializedMessage | AirServiceInitializedErrorMessage | AirLoginRequestMessage | AirClaimRequestMessage | AirLoginClaimStateMessage | AirCloseModalMessage | AirInitAuthCommunicationMessage | AirDeploySmartAccountRequestMessage | AirDeploySmartAccountResponseMessage;
+export type AirLoginClaimStatePayload = AirLoginClaimStateMessage["payload"];
+export {};

package/dist/types/common/realm/partner/config.d.ts

@@ -0,0 +1,68 @@
+import { RealmLoginWalletId } from "../wallet";
+export type RealmPartnerConfig = {
+    partnerId: string;
+    node: string;
+    gating: "none" | "jwt" | "invite";
+    apiUrl: string;
+    theme?: string;
+    chainId: string;
+    allowedDomains?: string[];
+    publicKey?: string;
+    jwksUrl?: string;
+    realmIdValidation: RealmIdValidation;
+    allowConnectOnly: boolean;
+    cyberConnectAppId?: string;
+    style?: RealmPartnerConfigStyle;
+    walletLoginMethods?: RealmLoginWalletId[];
+    walletSignupMethods?: RealmLoginWalletId[];
+    recommendedWallets?: RealmLoginWalletId[];
+    defaultLanguage?: string;
+    supportedLocales?: string[];
+    localeUrls?: Record<string, string>;
+    authLocaleUrls?: Record<string, string>;
+    sessionTime?: number;
+    customAuth?: RealmCustomAuthConfig;
+    allowSessionIdLogin?: boolean;
+    loginMethods?: RealmLoginMethod[];
+};
+export type RealmIdValidation = {
+    minLength: number;
+    maxLength: number;
+};
+export type RealmPartnerConfigStyle = {
+    hideCloseIcon?: boolean;
+    hideModalOverlay?: boolean;
+};
+export declare const REALM_LOGIN_PROVIDER: {
+    readonly REALM_CUSTOM_AUTH: "realm_custom_auth";
+    readonly DEMO_CUSTOM_AUTH: "demo_custom_auth";
+    readonly GOOGLE: "google";
+    readonly FACEBOOK: "facebook";
+    readonly REDDIT: "reddit";
+    readonly DISCORD: "discord";
+    readonly TWITCH: "twitch";
+    readonly APPLE: "apple";
+    readonly LINE: "line";
+    readonly GITHUB: "github";
+    readonly KAKAO: "kakao";
+    readonly LINKEDIN: "linkedin";
+    readonly TWITTER: "twitter";
+    readonly WEIBO: "weibo";
+    readonly WECHAT: "wechat";
+    readonly FARCASTER: "farcaster";
+    readonly EMAIL_PASSWORDLESS: "email_passwordless";
+    readonly SMS_PASSWORDLESS: "sms_passwordless";
+    readonly WEBAUTHN: "webauthn";
+    readonly JWT: "jwt";
+    readonly PASSKEYS: "passkeys";
+    readonly AUTHENTICATOR: "authenticator";
+};
+export type REALM_LOGIN_PROVIDER_TYPE = (typeof REALM_LOGIN_PROVIDER)[keyof typeof REALM_LOGIN_PROVIDER];
+export type RealmCustomAuthConfig = {
+    name: REALM_LOGIN_PROVIDER_TYPE;
+    verifier: string;
+    verifierSubIdentifier: string;
+    verifierIdField: string;
+};
+export declare const REALM_LOGIN_METHODS: readonly ["passwordless", "passwordlessToggle", "google", "wallet", "passkey"];
+export type RealmLoginMethod = (typeof REALM_LOGIN_METHODS)[number];