@mocanetwork/airkit 0.5.0-beta.2 → 0.5.0

package/dist/lib.cjs/common/src/realm/messaging/types.js

@@ -9,7 +9,13 @@ const AirMessageTypes = {
   CLOSE_MODAL: "air_close_modal",
   INIT_AUTH_COMMUNICATION: "air_init_auth_communication",
   DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
-  DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response"
+  DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response",
+  GRANT_PERMISSIONS_REQUEST: "air_grant_permissions_request",
+  GRANT_PERMISSIONS_RESPONSE: "air_grant_permissions_response",
+  EXECUTE_ACTION_REQUEST: "air_execute_action_request",
+  EXECUTE_ACTION_RESPONSE: "air_execute_action_response",
+  REVOKE_PERMISSIONS_REQUEST: "air_revoke_permissions_request",
+  REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response"
 };
 
 exports.AirMessageTypes = AirMessageTypes;

package/dist/lib.cjs/ws-embed/src/airService.js

@@ -126,7 +126,9 @@ class AirService {
       const authServiceInitialization = messageService.waitForAuthInitialization();
       const result = await Promise.all([initializationPromise, authServiceInitialization]);
       _classPrivateFieldSet(_isInitialized, this, true);
-      _assertClassBrand(_AirService_brand, this, _triggerAirAuthInitialized).call(this);
+      _assertClassBrand(_AirService_brand, this, _triggerAirAuthInitialized).call(this, {
+        rehydrated: result[1].rehydrated
+      });
       _assertClassBrand(_AirService_brand, this, _prepareRealmEmbedListeners).call(this);
 
       // rehydrated auth session
@@ -178,11 +180,42 @@ class AirService {
     }
     throw new error.AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
   }
+
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
   async deploySmartAccount() {
     if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
     await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
     return _classPrivateFieldGet(_realmEmbed, this)._deploySmartAccount();
   }
+
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async grantPermission(policies) {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("AirAuth is not initialized");
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this)._grantPermission(policies);
+  }
+
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async executeAction(params) {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("AirAuth is not initialized");
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this)._executeAction(params);
+  }
+
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async revokePermission(permissionId) {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("AirAuth is not initialized");
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this)._revokePermission(permissionId);
+  }
   async logout() {
     if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
     if (!this.isLoggedIn) throw new Error("No active session to logout");
@@ -310,9 +343,10 @@ async function _triggerEventListeners(data) {
     listener(data);
   });
 }
-async function _triggerAirAuthInitialized() {
+async function _triggerAirAuthInitialized(result) {
   await _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
-    event: "initialized"
+    event: "initialized",
+    result
   });
 }
 async function _triggerAirAuthLoggedIn() {

package/dist/lib.cjs/ws-embed/src/embed.js

@@ -334,6 +334,21 @@ class RealmEmbed {
       throw error.RealmEmbedError.from(error$1);
     }
   }
+  async _grantPermission(policies) {
+    if (!this.isConnected) throw new error.RealmEmbedError("NOT_LOGGED_IN", "User needs to be connected first");
+    try {
+      return await messageService.sendGrantPermissionRequest(_classPrivateFieldGet(_walletIframe, this), policies);
+    } catch (error$1) {
+      throw error.RealmEmbedError.from(error$1);
+    }
+  }
+  async _executeAction(params) {
+    return messageService.sendExecuteActionRequest(_classPrivateFieldGet(_walletIframe, this), params);
+  }
+  async _revokePermission(permissionId) {
+    return messageService.sendRevokePermissionsRequest(_classPrivateFieldGet(_walletIframe, this), permissionId);
+  }
+
   // async loginV2<T extends boolean>(options?: {
   //   skipClaiming: T;
   //   token?: string;

package/dist/lib.cjs/ws-embed/src/messageService.js

@@ -8,7 +8,7 @@ var types = require('../../common/src/realm/messaging/types.js');
 var error = require('./error.js');
 var loglevel = require('./loglevel.js');
 
-const REALM_EMBED_MESSAGES = [types.AirMessageTypes.LOGIN_CLAIM_STATE, types.AirMessageTypes.CLOSE_MODAL, types.AirMessageTypes.SERVICE_INITIALIZED, types.AirMessageTypes.SERVICE_INITIALIZED_ERROR, types.AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE];
+const REALM_EMBED_MESSAGES = [types.AirMessageTypes.LOGIN_CLAIM_STATE, types.AirMessageTypes.CLOSE_MODAL, types.AirMessageTypes.SERVICE_INITIALIZED, types.AirMessageTypes.SERVICE_INITIALIZED_ERROR, types.AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE, types.AirMessageTypes.EXECUTE_ACTION_RESPONSE, types.AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE, types.AirMessageTypes.GRANT_PERMISSIONS_RESPONSE];
 const AUTH_EMBED_MESSAGES = [auth.AirAuthMessageTypes.LOGIN_RESPONSE, auth.AirAuthMessageTypes.USER_INFO_RESPONSE, auth.AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE, auth.AirAuthMessageTypes.REFRESH_TOKEN_RESPONSE, auth.AirAuthMessageTypes.INITIALIZATION_RESPONSE, auth.AirAuthMessageTypes.LOGOUT_RESPONSE, auth.AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST, auth.AirAuthMessageTypes.SETUP_WALLET_REQUEST];
 class AirMessageService {
   constructor() {
@@ -125,6 +125,63 @@ class AirMessageService {
     }, origin);
     return response;
   }
+  async sendGrantPermissionRequest(walletIframe, policies) {
+    const response = rxjs.firstValueFrom(this.messages$.pipe(rxjs.filter(msg => msg.type === types.AirMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: types.AirMessageTypes.GRANT_PERMISSIONS_REQUEST,
+      payload: {
+        policies
+      }
+    }, origin);
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new error.RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.sessionData;
+  }
+  async sendExecuteActionRequest(walletIframe, params) {
+    const response = rxjs.firstValueFrom(this.messages$.pipe(rxjs.filter(msg => msg.type === types.AirMessageTypes.EXECUTE_ACTION_RESPONSE)));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: types.AirMessageTypes.EXECUTE_ACTION_REQUEST,
+      payload: {
+        sessionData: params.sessionData,
+        call: {
+          to: params.call.to,
+          value: params.call.value,
+          data: params.call.data
+        },
+        sessionOwnerPrivateKey: params.sessionOwnerPrivateKey
+      }
+    }, origin);
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new error.RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.txHash;
+  }
+  async sendRevokePermissionsRequest(walletIframe, permissionId) {
+    const response = rxjs.firstValueFrom(this.messages$.pipe(rxjs.filter(msg => msg.type === types.AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE)));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: types.AirMessageTypes.REVOKE_PERMISSIONS_REQUEST,
+      payload: {
+        permissionId
+      }
+    }, origin);
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new error.RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.txHash;
+  }
   sendDeploySmartAccountRequest(walletIframe) {
     const response = rxjs.firstValueFrom(this.messages$.pipe(rxjs.filter(msg => msg.type === types.AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
     const {

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

@@ -17,12 +17,12 @@ const AIR_URLS = {
     logLevel: "debug"
   },
   [interfaces.EMBED_BUILD_ENV.STAGING]: {
-    authUrl: "https://login.staging.realmnetwork.io",
+    authUrl: "https://auth.staging.air3.com",
     walletUrl: "https://account.staging.realmnetwork.io",
     logLevel: "info"
   },
   [interfaces.EMBED_BUILD_ENV.PRODUCTION]: {
-    authUrl: "https://login.realmnetwork.io",
+    authUrl: "https://auth.air3.com",
     walletUrl: "https://account.realmnetwork.io",
     logLevel: "error"
   }

package/dist/lib.esm/common/src/realm/messaging/types.js

@@ -7,7 +7,13 @@ const AirMessageTypes = {
   CLOSE_MODAL: "air_close_modal",
   INIT_AUTH_COMMUNICATION: "air_init_auth_communication",
   DEPLOY_SMART_ACCOUNT_REQUEST: "air_deploy_smart_account_request",
-  DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response"
+  DEPLOY_SMART_ACCOUNT_RESPONSE: "air_deploy_smart_account_response",
+  GRANT_PERMISSIONS_REQUEST: "air_grant_permissions_request",
+  GRANT_PERMISSIONS_RESPONSE: "air_grant_permissions_response",
+  EXECUTE_ACTION_REQUEST: "air_execute_action_request",
+  EXECUTE_ACTION_RESPONSE: "air_execute_action_response",
+  REVOKE_PERMISSIONS_REQUEST: "air_revoke_permissions_request",
+  REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response"
 };
 
 export { AirMessageTypes };

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

@@ -124,7 +124,9 @@ class AirService {
       const authServiceInitialization = AirMessageService.waitForAuthInitialization();
       const result = await Promise.all([initializationPromise, authServiceInitialization]);
       _classPrivateFieldSet(_isInitialized, this, true);
-      _assertClassBrand(_AirService_brand, this, _triggerAirAuthInitialized).call(this);
+      _assertClassBrand(_AirService_brand, this, _triggerAirAuthInitialized).call(this, {
+        rehydrated: result[1].rehydrated
+      });
       _assertClassBrand(_AirService_brand, this, _prepareRealmEmbedListeners).call(this);
 
       // rehydrated auth session
@@ -176,11 +178,42 @@ class AirService {
     }
     throw new AirServiceError("UNKNOWN_ERROR", "Unknown error occurred");
   }
+
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
   async deploySmartAccount() {
     if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
     await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
     return _classPrivateFieldGet(_realmEmbed, this)._deploySmartAccount();
   }
+
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async grantPermission(policies) {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("AirAuth is not initialized");
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this)._grantPermission(policies);
+  }
+
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async executeAction(params) {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("AirAuth is not initialized");
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this)._executeAction(params);
+  }
+
+  /**
+   * @experimental This method is experimental and will change in the future.
+   */
+  async revokePermission(permissionId) {
+    if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("AirAuth is not initialized");
+    await _assertClassBrand(_AirService_brand, this, _ensureWallet).call(this);
+    return _classPrivateFieldGet(_realmEmbed, this)._revokePermission(permissionId);
+  }
   async logout() {
     if (!_classPrivateFieldGet(_isInitialized, this)) throw new Error("Service is not initialized");
     if (!this.isLoggedIn) throw new Error("No active session to logout");
@@ -308,9 +341,10 @@ async function _triggerEventListeners(data) {
     listener(data);
   });
 }
-async function _triggerAirAuthInitialized() {
+async function _triggerAirAuthInitialized(result) {
   await _assertClassBrand(_AirService_brand, this, _triggerEventListeners).call(this, {
-    event: "initialized"
+    event: "initialized",
+    result
   });
 }
 async function _triggerAirAuthLoggedIn() {

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

@@ -330,6 +330,21 @@ class RealmEmbed {
       throw RealmEmbedError.from(error);
     }
   }
+  async _grantPermission(policies) {
+    if (!this.isConnected) throw new RealmEmbedError("NOT_LOGGED_IN", "User needs to be connected first");
+    try {
+      return await AirMessageService.sendGrantPermissionRequest(_classPrivateFieldGet(_walletIframe, this), policies);
+    } catch (error) {
+      throw RealmEmbedError.from(error);
+    }
+  }
+  async _executeAction(params) {
+    return AirMessageService.sendExecuteActionRequest(_classPrivateFieldGet(_walletIframe, this), params);
+  }
+  async _revokePermission(permissionId) {
+    return AirMessageService.sendRevokePermissionsRequest(_classPrivateFieldGet(_walletIframe, this), permissionId);
+  }
+
   // async loginV2<T extends boolean>(options?: {
   //   skipClaiming: T;
   //   token?: string;

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

@@ -6,7 +6,7 @@ import { AirMessageTypes } from '../../common/src/realm/messaging/types.js';
 import { RealmEmbedError } from './error.js';
 import log from './loglevel.js';
 
-const REALM_EMBED_MESSAGES = [AirMessageTypes.LOGIN_CLAIM_STATE, AirMessageTypes.CLOSE_MODAL, AirMessageTypes.SERVICE_INITIALIZED, AirMessageTypes.SERVICE_INITIALIZED_ERROR, AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE];
+const REALM_EMBED_MESSAGES = [AirMessageTypes.LOGIN_CLAIM_STATE, AirMessageTypes.CLOSE_MODAL, AirMessageTypes.SERVICE_INITIALIZED, AirMessageTypes.SERVICE_INITIALIZED_ERROR, AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE, AirMessageTypes.EXECUTE_ACTION_RESPONSE, AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE, AirMessageTypes.GRANT_PERMISSIONS_RESPONSE];
 const AUTH_EMBED_MESSAGES = [AirAuthMessageTypes.LOGIN_RESPONSE, AirAuthMessageTypes.USER_INFO_RESPONSE, AirAuthMessageTypes.PARTNER_USER_INFO_RESPONSE, AirAuthMessageTypes.REFRESH_TOKEN_RESPONSE, AirAuthMessageTypes.INITIALIZATION_RESPONSE, AirAuthMessageTypes.LOGOUT_RESPONSE, AirAuthMessageTypes.IFRAME_VISIBILITY_REQUEST, AirAuthMessageTypes.SETUP_WALLET_REQUEST];
 class AirMessageService {
   constructor() {
@@ -123,6 +123,63 @@ class AirMessageService {
     }, origin);
     return response;
   }
+  async sendGrantPermissionRequest(walletIframe, policies) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirMessageTypes.GRANT_PERMISSIONS_RESPONSE)));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: AirMessageTypes.GRANT_PERMISSIONS_REQUEST,
+      payload: {
+        policies
+      }
+    }, origin);
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.sessionData;
+  }
+  async sendExecuteActionRequest(walletIframe, params) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirMessageTypes.EXECUTE_ACTION_RESPONSE)));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: AirMessageTypes.EXECUTE_ACTION_REQUEST,
+      payload: {
+        sessionData: params.sessionData,
+        call: {
+          to: params.call.to,
+          value: params.call.value,
+          data: params.call.data
+        },
+        sessionOwnerPrivateKey: params.sessionOwnerPrivateKey
+      }
+    }, origin);
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.txHash;
+  }
+  async sendRevokePermissionsRequest(walletIframe, permissionId) {
+    const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirMessageTypes.REVOKE_PERMISSIONS_RESPONSE)));
+    const {
+      origin
+    } = new URL(walletIframe.src);
+    walletIframe.contentWindow.postMessage({
+      type: AirMessageTypes.REVOKE_PERMISSIONS_REQUEST,
+      payload: {
+        permissionId
+      }
+    }, origin);
+    const result = await response;
+    if (result.payload.success === false) {
+      throw new RealmEmbedError(result.payload.errorName, result.payload.errorMessage);
+    }
+    return result.payload.txHash;
+  }
   sendDeploySmartAccountRequest(walletIframe) {
     const response = firstValueFrom(this.messages$.pipe(filter(msg => msg.type === AirMessageTypes.DEPLOY_SMART_ACCOUNT_RESPONSE)));
     const {

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

@@ -15,12 +15,12 @@ const AIR_URLS = {
     logLevel: "debug"
   },
   [EMBED_BUILD_ENV.STAGING]: {
-    authUrl: "https://login.staging.realmnetwork.io",
+    authUrl: "https://auth.staging.air3.com",
     walletUrl: "https://account.staging.realmnetwork.io",
     logLevel: "info"
   },
   [EMBED_BUILD_ENV.PRODUCTION]: {
-    authUrl: "https://login.realmnetwork.io",
+    authUrl: "https://auth.air3.com",
     walletUrl: "https://account.realmnetwork.io",
     logLevel: "error"
   }

package/dist/types/airService.d.ts

@@ -1,3 +1,5 @@
+import { Hex } from "./common/realm/smart-session/hex";
+import { ActionPolicyInfo, Call } from "./common/realm/smart-session/types";
 import AirInPageProvider from "./inPageProvider";
 import { AirEmbedConnectResult, AirEmbedLoginResult, AirEventListener, AirLoginResult, AirPartnerUserDetails, AirUserDetails, ClaimAirIdOptions, EMBED_BUILD_ENV_TYPE } from "./interfaces";
 declare class AirService {
@@ -19,7 +21,30 @@ declare class AirService {
     login(options?: {
         authToken?: string;
     }): Promise<AirLoginResult>;
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
     deploySmartAccount(): Promise<void>;
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    grantPermission(policies: ActionPolicyInfo[]): Promise<{
+        compressedSessionData: string;
+        sessionOwnerPrivateKey: string;
+        permissionIds: string[];
+    }>;
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    executeAction(params: {
+        sessionData: string;
+        call: Call;
+        sessionOwnerPrivateKey: `0x${string}`;
+    }): Promise<string>;
+    /**
+     * @experimental This method is experimental and will change in the future.
+     */
+    revokePermission(permissionId: Hex): Promise<string>;
     logout(): Promise<void>;
     getProvider(): Promise<AirInPageProvider>;
     preloadWallet(): Promise<AirEmbedConnectResult | AirEmbedLoginResult>;

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

@@ -1,4 +1,6 @@
+import type { Hex } from "viem";
 import { AirErrorName } from "../error/types";
+import { ActionPolicyInfo, Call } from "../smart-session/types";
 export declare const AirMessageTypes: {
     readonly SERVICE_INITIALIZED: "air_service_initialized";
     readonly SERVICE_INITIALIZED_ERROR: "air_service_initialized_error";
@@ -9,6 +11,12 @@ export declare const AirMessageTypes: {
     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";
+    readonly GRANT_PERMISSIONS_REQUEST: "air_grant_permissions_request";
+    readonly GRANT_PERMISSIONS_RESPONSE: "air_grant_permissions_response";
+    readonly EXECUTE_ACTION_REQUEST: "air_execute_action_request";
+    readonly EXECUTE_ACTION_RESPONSE: "air_execute_action_response";
+    readonly REVOKE_PERMISSIONS_REQUEST: "air_revoke_permissions_request";
+    readonly REVOKE_PERMISSIONS_RESPONSE: "air_revoke_permissions_response";
 };
 export declare const AirLoginClaimStates: {
     readonly CONNECTED: "connected";
@@ -88,8 +96,48 @@ export type AirDeploySmartAccountResponseMessage = AirMessageBase<"air_deploy_sm
     txHash: string;
 } | {
     success: false;
-    errorMessage: string;
+    errorName: AirErrorName;
+    errorMessage?: string;
+}>;
+export type AirGrantPermissionsRequestMessage = AirMessageBase<"air_grant_permissions_request", {
+    policies: ActionPolicyInfo[];
+}>;
+export type AirGrantPermissionsResponseMessage = AirMessageBase<"air_grant_permissions_response", {
+    success: true;
+    sessionData: {
+        compressedSessionData: string;
+        sessionOwnerPrivateKey: string;
+        permissionIds: string[];
+    };
+} | {
+    success: false;
+    errorName: AirErrorName;
+    errorMessage?: string;
+}>;
+export type AirExecuteActionRequestMessage = AirMessageBase<"air_execute_action_request", {
+    sessionData: string;
+    call: Call;
+    sessionOwnerPrivateKey: `0x${string}`;
+}>;
+export type AirRevokePermissionsRequestMessage = AirMessageBase<"air_revoke_permissions_request", {
+    permissionId: Hex;
+}>;
+export type AirRevokePermissionsResponseMessage = AirMessageBase<"air_revoke_permissions_response", {
+    success: true;
+    txHash: string;
+} | {
+    success: false;
+    errorName: AirErrorName;
+    errorMessage?: string;
+}>;
+export type AirExecuteActionResponseMessage = AirMessageBase<"air_execute_action_response", {
+    success: true;
+    txHash: string;
+} | {
+    success: false;
+    errorName: AirErrorName;
+    errorMessage?: string;
 }>;
-export type AirMessage = AirServiceInitializedMessage | AirServiceInitializedErrorMessage | AirLoginRequestMessage | AirClaimRequestMessage | AirLoginClaimStateMessage | AirCloseModalMessage | AirInitAuthCommunicationMessage | AirDeploySmartAccountRequestMessage | AirDeploySmartAccountResponseMessage;
+export type AirMessage = AirServiceInitializedMessage | AirServiceInitializedErrorMessage | AirLoginRequestMessage | AirClaimRequestMessage | AirLoginClaimStateMessage | AirCloseModalMessage | AirInitAuthCommunicationMessage | AirDeploySmartAccountRequestMessage | AirDeploySmartAccountResponseMessage | AirGrantPermissionsRequestMessage | AirGrantPermissionsResponseMessage | AirRevokePermissionsRequestMessage | AirRevokePermissionsResponseMessage | AirExecuteActionRequestMessage | AirExecuteActionResponseMessage;
 export type AirLoginClaimStatePayload = AirLoginClaimStateMessage["payload"];
 export {};

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

@@ -1,30 +1,4 @@
 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;
@@ -32,6 +6,7 @@ export type RealmIdValidation = {
 export type RealmPartnerConfigStyle = {
     hideCloseIcon?: boolean;
     hideModalOverlay?: boolean;
+    passwordlessButtonVariant?: "inline" | "standalone";
 };
 export declare const REALM_LOGIN_PROVIDER: {
     readonly REALM_CUSTOM_AUTH: "realm_custom_auth";
@@ -66,3 +41,30 @@ export type RealmCustomAuthConfig = {
 };
 export declare const REALM_LOGIN_METHODS: readonly ["passwordless", "passwordlessToggle", "google", "wallet", "passkey"];
 export type RealmLoginMethod = (typeof REALM_LOGIN_METHODS)[number];
+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[];
+    skipPartnerLinkingConfirmation?: boolean;
+};

package/dist/types/common/realm/smart-session/hex.d.ts

@@ -0,0 +1 @@
+export type Hex = `0x${string}`;

package/dist/types/common/realm/smart-session/rule.d.ts

@@ -0,0 +1,49 @@
+import type { Hex } from "./hex";
+/**
+ * Represents the usage limit for a rule.
+ */
+export type LimitUsage = {
+    limit: bigint;
+    used: bigint;
+};
+export type ByteArray = Uint8Array;
+/**
+ * Represents a hardcoded hex value reference.
+ * Used when you want to bypass automatic hex conversion.
+ */
+export type HardcodedReference = {
+    /** The raw hex value */
+    raw: Hex;
+};
+/**
+ * Base types that can be converted to hex references.
+ */
+type BaseReferenceValue = string | number | bigint | boolean | ByteArray;
+export type AnyReferenceValue = BaseReferenceValue | HardcodedReference;
+/**
+ * Enum representing different parameter conditions for rules.
+ */
+export declare enum ParamCondition {
+    EQUAL = 0,
+    GREATER_THAN = 1,
+    LESS_THAN = 2,
+    GREATER_THAN_OR_EQUAL = 3,
+    LESS_THAN_OR_EQUAL = 4,
+    NOT_EQUAL = 5
+}
+/**
+ * Represents a rule for action policies.
+ */
+export type Rule = {
+    /** The condition to apply to the parameter */
+    condition: ParamCondition;
+    /** The offset index in the calldata where the value to be checked is located */
+    offsetIndex: number;
+    /** Indicates if the rule has a usage limit */
+    isLimited: boolean;
+    /** The reference value to compare against */
+    ref: AnyReferenceValue;
+    /** The usage object containing limit and used values (required if isLimited is true) */
+    usage: LimitUsage;
+};
+export {};