fix: linting updates from code review

Author: cpb8010

packages/auth-server/components/session/row/Row.vue

@@ -16,14 +16,14 @@
       </div>
     </div>
     <div class="session-expiry-container">
+      <!-- TODO: created-at is hardcoded to 0 because the current session data
+           does not include a creation timestamp. Update this when a real
+           created-at value is available or when SessionRowExpiry is changed
+           to not rely on created-at for active sessions. -->
       <SessionRowExpiry
         v-if="sessionState"
         :status="sessionState.status"
         :is-expired="isExpired"
-        <!-- TODO: created-at is hardcoded to 0 because the current session data
-             does not include a creation timestamp. Update this when a real
-             created-at value is available or when SessionRowExpiry is changed
-             to not rely on created-at for active sessions. -->
         :created-at="0"
         :expires-at="expiresAt"
         :now="now"

packages/auth-server/pages/dashboard/sessions.vue

@@ -55,7 +55,7 @@
 import { InformationCircleIcon } from "@heroicons/vue/20/solid";
 import type { Address, Hex } from "viem";
 import { listActiveSessions } from "zksync-sso-4337";
-import { LimitType, type SessionSpec } from "zksync-sso-4337/client";
+import { type ConstraintCondition, LimitType, type SessionSpec } from "zksync-sso-4337/client";
 
 const { defaultChain } = useClientStore();
 const { address } = storeToRefs(useAccountStore());
@@ -68,7 +68,7 @@ interface WasmUsageLimit {
 }
 
 interface WasmConstraint {
-  condition: string;
+  condition: string; // Will be converted to ConstraintCondition enum
   index: string;
   refValue: Hex;
   limit: WasmUsageLimit;
@@ -107,6 +107,7 @@ const convertSessionSpec = (wasmSpec: WasmSessionSpec): SessionSpec => {
     else {
       const numericLimitType = Number(limit.limitType);
       if (Number.isNaN(numericLimitType)) {
+        // eslint-disable-next-line no-console
         console.warn(
           "Unexpected limitType value received from WASM:",
           limit.limitType,
@@ -118,32 +119,61 @@ const convertSessionSpec = (wasmSpec: WasmSessionSpec): SessionSpec => {
       }
     }
 
+    // Validate and convert BigInt values with try-catch
+    let limitValue: bigint;
+    let periodValue: bigint;
+    try {
+      limitValue = BigInt(limit.limit);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.warn("Invalid limit value from WASM, defaulting to 0:", limit.limit, e);
+      limitValue = 0n;
+    }
+    try {
+      periodValue = BigInt(limit.period);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.warn("Invalid period value from WASM, defaulting to 0:", limit.period, e);
+      periodValue = 0n;
+    }
+
     return {
       limitType,
-      limit: BigInt(limit.limit),
-      period: BigInt(limit.period),
+      limit: limitValue,
+      period: periodValue,
     };
   };
 
+  // Helper to safely convert BigInt with validation
+  const safeBigInt = (value: string, fieldName: string): bigint => {
+    try {
+      return BigInt(value);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.warn(`Invalid ${fieldName} value from WASM, defaulting to 0:`, value, e);
+      return 0n;
+    }
+  };
+
   return {
     signer: wasmSpec.signer,
-    expiresAt: BigInt(wasmSpec.expiresAt),
+    expiresAt: safeBigInt(wasmSpec.expiresAt, "expiresAt"),
     feeLimit: convertLimit(wasmSpec.feeLimit),
     callPolicies: (wasmSpec.callPolicies || []).map((policy: WasmCallPolicy) => ({
       target: policy.target,
       selector: policy.selector,
-      maxValuePerUse: BigInt(policy.maxValuePerUse),
+      maxValuePerUse: safeBigInt(policy.maxValuePerUse, "maxValuePerUse"),
       valueLimit: convertLimit(policy.valueLimit),
       constraints: (policy.constraints || []).map((constraint: WasmConstraint) => ({
-        condition: constraint.condition,
-        index: BigInt(constraint.index),
+        condition: constraint.condition as unknown as ConstraintCondition,
+        index: safeBigInt(constraint.index, "constraint.index"),
         refValue: constraint.refValue,
         limit: convertLimit(constraint.limit),
       })),
     })),
     transferPolicies: (wasmSpec.transferPolicies || []).map((policy: WasmTransferPolicy) => ({
       target: policy.target,
-      maxValuePerUse: BigInt(policy.maxValuePerUse),
+      maxValuePerUse: safeBigInt(policy.maxValuePerUse, "transfer.maxValuePerUse"),
       valueLimit: convertLimit(policy.valueLimit),
     })),
   };
@@ -169,7 +199,7 @@ const {
     rpcUrl,
     contracts: {
       sessionValidator: contracts.sessionValidator,
-      entryPoint: (contracts as any).entryPoint || "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+      entryPoint: (contracts as { entryPoint?: Address }).entryPoint || "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       accountFactory: contracts.factory,
       webauthnValidator: contracts.webauthnValidator,
       eoaValidator: contracts.eoaValidator,
@@ -178,16 +208,17 @@ const {
   });
 
   // Map snake_case properties from WASM to camelCase and convert types
-  const filtered = activeSessions
-    .filter((item: { session_hash?: Hex; session_spec?: WasmSessionSpec }) => {
+  type WasmSession = { session_hash: Hex; session_spec: WasmSessionSpec };
+  const filtered = (activeSessions as unknown as WasmSession[])
+    .filter((item) => {
       const isValid = item?.session_hash && item?.session_spec && item?.session_spec?.signer;
       if (!isValid) {
         // eslint-disable-next-line no-console
         console.warn("[sessions.vue] Filtering out invalid session:", item);
       }
       return isValid;
     })
-    .map((item: { session_hash: Hex; session_spec: WasmSessionSpec }) => ({
+    .map((item) => ({
       sessionHash: item.session_hash,
       sessionSpec: convertSessionSpec(item.session_spec),
     }));

packages/sdk-platforms/rust/zksync-sso-erc4337/crates/zksync-sso-erc4337-ffi-web/src/account/modular_smart_account/session/list.rs

@@ -37,15 +37,16 @@ pub fn get_active_sessions_wasm(
         };
 
         // Parse contracts JSON
-        let contracts: CoreContracts = match serde_json::from_str(&contracts_json) {
-            Ok(c) => c,
-            Err(e) => {
-                return Err(JsValue::from_str(&format!(
-                    "Invalid contracts JSON: {}",
-                    e
-                )));
-            }
-        };
+        let contracts: CoreContracts =
+            match serde_json::from_str(&contracts_json) {
+                Ok(c) => c,
+                Err(e) => {
+                    return Err(JsValue::from_str(&format!(
+                        "Invalid contracts JSON: {}",
+                        e
+                    )));
+                }
+            };
 
         // Create transport and provider
         let transport = WasmHttpTransport::new(rpc_url);