@ab-org/sdk-core 0.3.0-beta.4 → 0.3.0-beta.6

package/dist/{chunk-SBOQGPRF.js → chunk-K63POESF.js}

@@ -1,89 +1,4 @@
-import { CubeSignerAuth, createCubistEvmWalletProvider } from './chunk-ADMEF7PF.js';
-
-// src/core/chains.ts
-var chainDescriptors = {
-  AB_CORE: {
-    chain: "AB_CORE",
-    namespace: "ab-core",
-    reference: "ab:core",
-    label: "AB Core",
-    rpcFamily: "custom",
-    supportsSmartSessions: true,
-    supportsAccountAbstraction: true
-  },
-  ETH: {
-    chain: "ETH",
-    namespace: "evm",
-    reference: "eip155:1",
-    label: "Ethereum",
-    rpcFamily: "evm",
-    evmChainId: 1,
-    supportsSmartSessions: true,
-    supportsAccountAbstraction: true
-  },
-  BSC: {
-    chain: "BSC",
-    namespace: "evm",
-    reference: "eip155:56",
-    label: "BNB Smart Chain",
-    rpcFamily: "evm",
-    evmChainId: 56,
-    supportsSmartSessions: true,
-    supportsAccountAbstraction: false
-  },
-  ETH_TENDERLY: {
-    chain: "ETH_TENDERLY",
-    namespace: "evm",
-    reference: "eip155:3030",
-    label: "Ethereum Tenderly",
-    rpcFamily: "evm",
-    evmChainId: 3030,
-    supportsSmartSessions: true,
-    supportsAccountAbstraction: true
-  },
-  BSC_TENDERLY: {
-    chain: "BSC_TENDERLY",
-    namespace: "evm",
-    reference: "eip155:3131",
-    label: "BNB Smart Chain Tenderly",
-    rpcFamily: "evm",
-    evmChainId: 3131,
-    supportsSmartSessions: true,
-    supportsAccountAbstraction: false
-  },
-  SOL: {
-    chain: "SOL",
-    namespace: "solana",
-    reference: "solana:mainnet-beta",
-    label: "Solana",
-    rpcFamily: "solana",
-    supportsSmartSessions: true,
-    supportsAccountAbstraction: false
-  }
-};
-var getChainDescriptor = (chain) => chainDescriptors[chain];
-var getAllChainDescriptors = () => Object.values(chainDescriptors);
-var normalizeEvmChainId = (value) => {
-  if (typeof value === "number") return value;
-  if (typeof value === "bigint") return Number(value);
-  return Number(BigInt(value));
-};
-var getSupportedChainFromEvmChainId = (value) => {
-  const chainId = normalizeEvmChainId(value);
-  const descriptor = getAllChainDescriptors().find(
-    (item) => item.namespace === "evm" && item.evmChainId === chainId
-  );
-  if (!descriptor) {
-    throw new Error(`Unsupported EVM chainId: ${chainId}`);
-  }
-  return descriptor.chain;
-};
-var createChainContext = (walletChain, settlementChain = walletChain) => ({
-  walletChain,
-  walletChainDescriptor: getChainDescriptor(walletChain),
-  settlementChain,
-  settlementChainDescriptor: getChainDescriptor(settlementChain)
-});
+import { CubeSignerAuth, createChainContext, createCubistEvmWalletProvider } from './chunk-V4LAUAGS.js';
 
 // src/core/capabilities.ts
 var SessionCapabilityError = class extends Error {
@@ -251,6 +166,15 @@ var CubistSocialProvider = class extends AbstractSocialProvider {
     /** Stash the login method so `connect()` can auto-retry. */
     this.lastLogin = null;
     this.auth = new CubeSignerAuth(config);
+    this.auth.onSessionDataUpdated = (sessionData) => {
+      if (this.lastCubeSignerSession) {
+        this.lastCubeSignerSession = {
+          ...this.lastCubeSignerSession,
+          sessionData
+        };
+      }
+      this.onSessionDataUpdated?.(sessionData);
+    };
     this.adapter = adapter;
   }
   async createWalletSession(method) {
@@ -258,12 +182,15 @@ var CubistSocialProvider = class extends AbstractSocialProvider {
     this.lastCubeSignerSession = session;
     const walletSession = await this.adapter.resolve(session);
     const capabilityPolicy = this.auth.defaultSessionPolicy ? createSessionCapabilityPolicy(this.auth.defaultSessionPolicy) : void 0;
+    const sessionExpMs = session.sessionData.session_exp ? session.sessionData.session_exp * 1e3 : void 0;
+    const expiresAt = capabilityPolicy?.expiresAt && sessionExpMs ? Math.min(capabilityPolicy.expiresAt, sessionExpMs) : capabilityPolicy?.expiresAt ?? sessionExpMs;
     return {
       ...walletSession,
       walletType: "social",
       authSource: method.type,
       sessionId: `${method.type}:${walletSession.address.toLowerCase()}`,
-      expiresAt: capabilityPolicy?.expiresAt,
+      issuedAt: Date.now(),
+      expiresAt,
       capabilities: CUBIST_CAPABILITIES,
       sessionData: session.sessionData,
       chainContext: walletSession.chainContext ?? createChainContext(walletSession.chain),
@@ -334,6 +261,8 @@ var CubistSocialProvider = class extends AbstractSocialProvider {
         address: walletSession.address,
         chain: restoredChain
       });
+      const sessionExpMs = csSession.sessionData.session_exp ? csSession.sessionData.session_exp * 1e3 : void 0;
+      const expiresAt = persistedSession.expiresAt && sessionExpMs ? Math.min(persistedSession.expiresAt, sessionExpMs) : persistedSession.expiresAt ?? sessionExpMs;
       return this.setSession({
         ...walletSession,
         chain: restoredChain,
@@ -341,7 +270,8 @@ var CubistSocialProvider = class extends AbstractSocialProvider {
         walletType: persistedSession.walletType ?? "social",
         authSource: persistedSession.authSource,
         sessionId: persistedSession.sessionId,
-        expiresAt: persistedSession.expiresAt,
+        issuedAt: persistedSession.issuedAt,
+        expiresAt,
         capabilities: CUBIST_CAPABILITIES,
         sessionData: csSession.sessionData,
         chainContext: createChainContext(restoredChain),
@@ -370,4 +300,4 @@ var CubistSocialProvider = class extends AbstractSocialProvider {
   }
 };
 
-export { AbstractProvider, AbstractSocialProvider, CUBIST_CAPABILITIES, CubistSocialProvider, SessionCapabilityError, assertSessionCapability, createChainContext, createSessionCapabilityPolicy, describeSessionCapabilityPolicy, getAllChainDescriptors, getChainDescriptor, getSupportedChainFromEvmChainId, isCapabilityPolicyExpired, isSessionExpired, sessionSupportsCapability };
+export { AbstractProvider, AbstractSocialProvider, CUBIST_CAPABILITIES, CubistSocialProvider, SessionCapabilityError, assertSessionCapability, createSessionCapabilityPolicy, describeSessionCapabilityPolicy, isCapabilityPolicyExpired, isSessionExpired, sessionSupportsCapability };

package/dist/{chunk-ADMEF7PF.js → chunk-V4LAUAGS.js}

@@ -1,3 +1,4 @@
+import EventEmitter from 'eventemitter3';
 import { jwtDecode } from 'jwt-decode';
 
 var __typeError = (msg) => {
@@ -9,6 +10,265 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
+// src/core/chains.ts
+var chainDescriptors = {
+  AB_CORE: {
+    chain: "AB_CORE",
+    namespace: "ab-core",
+    reference: "ab:core",
+    label: "AB Core",
+    rpcFamily: "custom",
+    supportsSmartSessions: true,
+    supportsAccountAbstraction: true
+  },
+  ETH: {
+    chain: "ETH",
+    namespace: "evm",
+    reference: "eip155:1",
+    label: "Ethereum",
+    rpcFamily: "evm",
+    evmChainId: 1,
+    supportsSmartSessions: true,
+    supportsAccountAbstraction: true
+  },
+  BSC: {
+    chain: "BSC",
+    namespace: "evm",
+    reference: "eip155:56",
+    label: "BNB Smart Chain",
+    rpcFamily: "evm",
+    evmChainId: 56,
+    supportsSmartSessions: true,
+    supportsAccountAbstraction: false
+  },
+  ETH_TENDERLY: {
+    chain: "ETH_TENDERLY",
+    namespace: "evm",
+    reference: "eip155:3030",
+    label: "Ethereum Tenderly",
+    rpcFamily: "evm",
+    evmChainId: 3030,
+    supportsSmartSessions: true,
+    supportsAccountAbstraction: true
+  },
+  BSC_TENDERLY: {
+    chain: "BSC_TENDERLY",
+    namespace: "evm",
+    reference: "eip155:3131",
+    label: "BNB Smart Chain Tenderly",
+    rpcFamily: "evm",
+    evmChainId: 3131,
+    supportsSmartSessions: true,
+    supportsAccountAbstraction: false
+  },
+  SOL: {
+    chain: "SOL",
+    namespace: "solana",
+    reference: "solana:mainnet-beta",
+    label: "Solana",
+    rpcFamily: "solana",
+    supportsSmartSessions: true,
+    supportsAccountAbstraction: false
+  }
+};
+var getChainDescriptor = (chain) => chainDescriptors[chain];
+var getAllChainDescriptors = () => Object.values(chainDescriptors);
+var normalizeEvmChainId = (value) => {
+  if (typeof value === "number") return value;
+  if (typeof value === "bigint") return Number(value);
+  return Number(BigInt(value));
+};
+var getSupportedChainFromEvmChainId = (value) => {
+  const chainId = normalizeEvmChainId(value);
+  const descriptor = getAllChainDescriptors().find(
+    (item) => item.namespace === "evm" && item.evmChainId === chainId
+  );
+  if (!descriptor) {
+    throw new Error(`Unsupported EVM chainId: ${chainId}`);
+  }
+  return descriptor.chain;
+};
+var createChainContext = (walletChain, settlementChain = walletChain) => ({
+  walletChain,
+  walletChainDescriptor: getChainDescriptor(walletChain),
+  settlementChain,
+  settlementChainDescriptor: getChainDescriptor(settlementChain)
+});
+var STORAGE_KEY = "ab:wallet:session";
+function getStorage() {
+  try {
+    return typeof localStorage !== "undefined" ? localStorage : null;
+  } catch {
+    return null;
+  }
+}
+function persistSession(session) {
+  const storage = getStorage();
+  if (!storage) return;
+  if (!session) {
+    storage.removeItem(STORAGE_KEY);
+    return;
+  }
+  const serializable = {
+    address: session.address,
+    chain: session.chain,
+    walletType: session.walletType,
+    authSource: session.authSource,
+    sessionId: session.sessionId,
+    issuedAt: session.issuedAt,
+    expiresAt: session.expiresAt
+  };
+  if (session.capabilities?.length) {
+    serializable.capabilities = session.capabilities;
+  }
+  if (session.sessionData !== void 0) {
+    serializable.sessionData = session.sessionData;
+  }
+  if (session.capabilityPolicy !== void 0) {
+    serializable.capabilityPolicy = session.capabilityPolicy;
+  }
+  if (session.userInfo !== void 0) {
+    serializable.userInfo = session.userInfo;
+  }
+  try {
+    storage.setItem(STORAGE_KEY, JSON.stringify(serializable));
+  } catch {
+    storage.removeItem(STORAGE_KEY);
+  }
+}
+function readPersistedSession() {
+  const storage = getStorage();
+  if (!storage) return null;
+  const raw = storage.getItem(STORAGE_KEY);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    storage.removeItem(STORAGE_KEY);
+    return null;
+  }
+}
+var STALE_SESSION_ERROR_MESSAGE = "Session restored from cache. Reconnect your wallet for transactions.";
+var USER_SESSION_EXPIRED_MESSAGE = "Session expired. Please reconnect your wallet and try again.";
+function isStaleSessionError(error) {
+  return error instanceof Error && error.message.includes(STALE_SESSION_ERROR_MESSAGE);
+}
+var staleProvider = {
+  request() {
+    return Promise.reject(new Error(STALE_SESSION_ERROR_MESSAGE));
+  },
+  disconnect() {
+    return Promise.resolve();
+  }
+};
+var SessionStore = class {
+  constructor() {
+    this.state = {
+      session: null,
+      balance: null,
+      isConnecting: false
+    };
+    this.emitter = new EventEmitter();
+    this._pendingExpiredSession = null;
+    this._expiryTimerId = null;
+    this.tryRehydrate();
+  }
+  getState() {
+    return { ...this.state };
+  }
+  setConnecting(flag) {
+    this.state.isConnecting = flag;
+    this.emitter.emit("connecting:changed", flag);
+  }
+  setSession(session) {
+    this.state.session = session;
+    persistSession(session);
+    this.emitter.emit("session:changed", session);
+  }
+  rehydrateSession(session) {
+    this.state.session = session;
+    persistSession(session);
+    this.emitter.emit("session:changed", session);
+    this.emitter.emit("session:rehydrated", session);
+  }
+  clearSession() {
+    this.state.session = null;
+    this.state.balance = null;
+    persistSession(null);
+    this.emitter.emit("session:changed", null);
+    this.emitter.emit("balance:changed", null);
+  }
+  expireSession() {
+    const currentSession = this.state.session;
+    if (!currentSession) return;
+    this.clearSession();
+    this.emitter.emit("session:expired", currentSession);
+  }
+  revokeSession() {
+    const currentSession = this.state.session;
+    if (!currentSession) return;
+    this.clearSession();
+    this.emitter.emit("session:revoked", currentSession);
+  }
+  setBalance(balance) {
+    this.state.balance = balance;
+    this.emitter.emit("balance:changed", balance);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return () => this.emitter.off(event, listener);
+  }
+  /**
+   * Emit `session:expired` for a session that was already expired at rehydration time.
+   * Call this after attaching listeners so the event is actually received.
+   */
+  flushPendingExpiry() {
+    const pending = this._pendingExpiredSession;
+    if (!pending) return;
+    this._pendingExpiredSession = null;
+    this.emitter.emit("session:expired", pending);
+  }
+  /**
+   * Start a periodic timer that checks whether the current session has expired.
+   * When `session.expiresAt <= Date.now()`, calls `expireSession()` which emits `session:expired`.
+   */
+  startExpiryTimer(intervalMs = 3e4) {
+    this.stopExpiryTimer();
+    if (typeof setInterval === "undefined") return;
+    this._expiryTimerId = setInterval(() => {
+      const session = this.state.session;
+      if (session?.expiresAt && session.expiresAt <= Date.now()) {
+        this.expireSession();
+      }
+    }, intervalMs);
+  }
+  stopExpiryTimer() {
+    if (this._expiryTimerId != null) {
+      clearInterval(this._expiryTimerId);
+      this._expiryTimerId = null;
+    }
+  }
+  tryRehydrate() {
+    const persisted = readPersistedSession();
+    if (!persisted) return;
+    if (persisted.expiresAt && persisted.expiresAt <= Date.now()) {
+      persistSession(null);
+      this._pendingExpiredSession = {
+        ...persisted,
+        provider: staleProvider,
+        chainContext: createChainContext(persisted.chain)
+      };
+      return;
+    }
+    this.state.session = {
+      ...persisted,
+      provider: staleProvider,
+      chainContext: createChainContext(persisted.chain)
+    };
+  }
+};
+var sessionStore = new SessionStore();
+
 // src/providers/social/cubistRuntime.ts
 var DEFAULT_EXPIRATION_BUFFER_SECS = 30;
 var DEFAULT_RETRY_ATTEMPTS = 3;
@@ -226,10 +486,7 @@ var MemorySessionManager = class {
     if (!isStale(__privateGet(this, _data))) {
       return __privateGet(this, _data).token;
     }
-    __privateGet(this, _refreshing) ?? __privateSet(this, _refreshing, refreshSession(__privateGet(this, _data)).then(async (refreshed2) => {
-      await this.store(refreshed2);
-      return refreshed2;
-    }).catch((error) => {
+    __privateGet(this, _refreshing) ?? __privateSet(this, _refreshing, this.refresh().catch((error) => {
       if (error instanceof Error && /\(401\)|\(403\)/.test(error.message) && typeof this.onInvalidToken === "function") {
         this.onInvalidToken();
       }
@@ -240,12 +497,27 @@ var MemorySessionManager = class {
     const refreshed = await __privateGet(this, _refreshing);
     return refreshed.token;
   }
+  async refresh() {
+    __privateGet(this, _refreshing) ?? __privateSet(this, _refreshing, refreshSession(__privateGet(this, _data)).then(async (refreshed) => {
+      await this.store(refreshed);
+      return refreshed;
+    }).catch((error) => {
+      if (error instanceof Error && /\(401\)|\(403\)/.test(error.message) && typeof this.onInvalidToken === "function") {
+        this.onInvalidToken();
+      }
+      throw error;
+    }).finally(() => {
+      __privateSet(this, _refreshing, void 0);
+    }));
+    return __privateGet(this, _refreshing);
+  }
 };
 _data = new WeakMap();
 _refreshing = new WeakMap();
-async function refreshSession(session1) {
-  const secretB64Token = btoa(JSON.stringify(session1)).replace(/\s/g, "");
-  const session = JSON.parse(atob(secretB64Token));
+async function refreshSession(session) {
+  if (session === void 0 || session === null || !session.refresh_token) {
+    throw new Error("Session is undefined");
+  }
   const env = getPrimarySessionEnv(session);
   const payload = {
     epoch_num: session.session_info.epoch,
@@ -292,6 +564,12 @@ var _CubistApiClient = class _CubistApiClient {
     }
     return __privateGet(this, _sessionManager).retrieve();
   }
+  async refreshSessionData() {
+    if (typeof __privateGet(this, _sessionManager).refresh === "function") {
+      return __privateGet(this, _sessionManager).refresh();
+    }
+    return this.retrieveSessionData();
+  }
   withOrg(orgId) {
     return new _CubistApiClient(__privateGet(this, _sessionManager), __privateGet(this, _sessionMeta), orgId);
   }
@@ -551,6 +829,9 @@ var _CubeSignerClient = class _CubeSignerClient {
   async retrieveSessionData() {
     return __privateGet(this, _apiClient4).retrieveSessionData();
   }
+  async refreshSessionData() {
+    return __privateGet(this, _apiClient4).refreshSessionData();
+  }
   static async create(session, targetOrgId) {
     const created = typeof session === "string" || isSessionData(session) ? new MemorySessionManager(parseSessionLike(session)) : session;
     if (typeof session === "object" && session !== null && session.onInvalidToken && created instanceof MemorySessionManager) {
@@ -707,19 +988,97 @@ function resolveEnv(env) {
 function decodeJwtPayload(token) {
   return jwtDecode(token);
 }
-async function refreshCubeSignerSessionData(sessionData) {
-  const client = await CubeSignerClient.create(sessionData);
-  await client.sessionKeys();
-  return await client.retrieveSessionData() ?? sessionData;
-}
+var _refreshing2, _autoRefreshTimerId, _authLifetimeSecs;
+var ManagedCubeSignerSession = class {
+  constructor(data, notifySessionDataUpdated, authLifetimeSecs) {
+    this.data = data;
+    this.notifySessionDataUpdated = notifySessionDataUpdated;
+    __privateAdd(this, _refreshing2);
+    __privateAdd(this, _autoRefreshTimerId, null);
+    __privateAdd(this, _authLifetimeSecs);
+    __privateSet(this, _authLifetimeSecs, authLifetimeSecs);
+  }
+  async metadata() {
+    return {
+      env: this.data.env,
+      org_id: this.data.org_id,
+      role_id: this.data.role_id,
+      purpose: this.data.purpose,
+      session_exp: this.data.session_exp,
+      session_id: this.data.session_info.session_id,
+      epoch: this.data.session_info.epoch
+    };
+  }
+  async token() {
+    if (!isStale(this.data)) {
+      return this.data.token;
+    }
+    __privateGet(this, _refreshing2) ?? __privateSet(this, _refreshing2, this.refresh().catch((error) => {
+      if (error instanceof Error && /\(401\)|\(403\)/.test(error.message) && typeof this.onInvalidToken === "function") {
+        this.onInvalidToken();
+      }
+      throw error;
+    }).finally(() => {
+      __privateSet(this, _refreshing2, void 0);
+    }));
+    const refreshed = await __privateGet(this, _refreshing2);
+    return refreshed.token;
+  }
+  async refresh() {
+    __privateGet(this, _refreshing2) ?? __privateSet(this, _refreshing2, refreshSession(this.data).then(async (refreshed) => {
+      await this.store(refreshed);
+      return refreshed;
+    }).catch((error) => {
+      if (error instanceof Error && /\(401\)|\(403\)/.test(error.message) && typeof this.onInvalidToken === "function") {
+        this.onInvalidToken();
+      }
+      throw error;
+    }).finally(() => {
+      __privateSet(this, _refreshing2, void 0);
+    }));
+    return __privateGet(this, _refreshing2);
+  }
+  async retrieve() {
+    return this.data;
+  }
+  async store(data) {
+    this.data = data;
+    this.notifySessionDataUpdated(data);
+  }
+  /**
+   * Start a periodic timer that proactively refreshes the auth token
+   * when the remaining auth time drops below 1/3 of the total auth lifetime.
+   */
+  startAutoRefresh(intervalMs = 3e4) {
+    this.stopAutoRefresh();
+    if (typeof setInterval === "undefined") return;
+    __privateSet(this, _autoRefreshTimerId, setInterval(() => {
+      const remainingSecs = this.data.session_info.auth_token_exp - Date.now() / 1e3;
+      if (remainingSecs < __privateGet(this, _authLifetimeSecs) / 3) {
+        this.refresh().catch(() => {
+        });
+      }
+    }, intervalMs));
+  }
+  stopAutoRefresh() {
+    if (__privateGet(this, _autoRefreshTimerId) != null) {
+      clearInterval(__privateGet(this, _autoRefreshTimerId));
+      __privateSet(this, _autoRefreshTimerId, null);
+    }
+  }
+};
+_refreshing2 = new WeakMap();
+_autoRefreshTimerId = new WeakMap();
+_authLifetimeSecs = new WeakMap();
 var CubeSignerAuth = class {
   constructor(config) {
     this._client = null;
     this._sessionData = null;
+    this._managedSession = null;
     this.env = resolveEnv(config.env);
     this.orgId = config.orgId;
     this.scopes = config.scopes ?? ["sign:*", "manage:*"];
-    this.lifetimes = config.lifetimes ?? { session: 60 * 60 * 24 * 30, auth: 60 * 60 * 24 * 30, refresh: 60 * 60 * 24 * 30 * 2 };
+    this.lifetimes = config.lifetimes ?? { session: 60 * 60 * 24 * 30, auth: 60 * 60 * 24 * 30 };
     this.defaultSessionPolicy = config.defaultSessionPolicy;
     this.oidcLoginHooks = config.oidcLoginHooks;
   }
@@ -763,6 +1122,8 @@ var CubeSignerAuth = class {
   }
   /* ── Sign-out ─────────────────────────────── */
   async signOut() {
+    this._managedSession?.stopAutoRefresh();
+    this._managedSession = null;
     if (this._client) {
       try {
         await this._client.revokeSession();
@@ -781,10 +1142,10 @@ var CubeSignerAuth = class {
     if (this._client) {
       await this.signOut();
     }
-    const client = await CubeSignerClient.create(sessionData);
+    const managedSession = this.createManagedSession(sessionData);
+    const client = await CubeSignerClient.create(managedSession);
     this._client = client;
-    this._sessionData = sessionData;
-    return { client, sessionData };
+    return { client, sessionData: this._sessionData ?? sessionData };
   }
   /* ── Private ──────────────────────────────── */
   async authenticateWithOidcToken(oidcToken) {
@@ -845,11 +1206,31 @@ var CubeSignerAuth = class {
       this.lifetimes
     );
     const sessionData = resp.data();
-    const client = await CubeSignerClient.create(sessionData);
+    const managedSession = this.createManagedSession(sessionData);
+    const client = await CubeSignerClient.create(managedSession);
     this._client = client;
-    this._sessionData = sessionData;
+    const currentSessionData = this._sessionData ?? sessionData;
     const userInfo = this.parseOidcUserInfo(oidcToken);
-    return { client, sessionData, userInfo };
+    return { client, sessionData: currentSessionData, userInfo };
+  }
+  createManagedSession(sessionData) {
+    this._managedSession?.stopAutoRefresh();
+    this._sessionData = sessionData;
+    const manager = new ManagedCubeSignerSession(
+      sessionData,
+      (nextSessionData) => {
+        this._sessionData = nextSessionData;
+        this.onSessionDataUpdated?.(nextSessionData);
+      },
+      this.lifetimes.auth ?? 60 * 60 * 24 * 30
+    );
+    manager.onInvalidToken = () => {
+      manager.stopAutoRefresh();
+      sessionStore.expireSession();
+    };
+    manager.startAutoRefresh();
+    this._managedSession = manager;
+    return manager;
   }
   parseOidcUserInfo(oidcToken) {
     try {
@@ -1101,4 +1482,4 @@ var createCubistEvmWalletProvider = ({
   };
 };
 
-export { CubeSignerAuth, createCubistEvmWalletProvider, refreshCubeSignerSessionData };
+export { CubeSignerAuth, STALE_SESSION_ERROR_MESSAGE, SessionStore, USER_SESSION_EXPIRED_MESSAGE, createChainContext, createCubistEvmWalletProvider, getAllChainDescriptors, getChainDescriptor, getSupportedChainFromEvmChainId, isStaleSessionError, sessionStore };

package/dist/{cubeSignerAuth-C3n7VgB8.d.ts → cubeSignerAuth-Cwnx1DZ1.d.ts}

@@ -115,6 +115,7 @@ interface WalletSession {
     walletType?: WalletType;
     authSource?: WalletAuthSource;
     sessionId?: string;
+    issuedAt?: number;
     expiresAt?: number;
     capabilities?: WalletCapability[];
     sessionData?: unknown;
@@ -181,6 +182,7 @@ interface SessionManager {
     onInvalidToken?: () => void;
     metadata(): Promise<SessionMetadata>;
     token(): Promise<string>;
+    refresh?(): Promise<SessionData>;
     retrieve?(): Promise<SessionData>;
     store?(data: SessionData): Promise<void>;
 }
@@ -275,6 +277,7 @@ declare class CubistApiClient {
     get orgId(): string;
     get sessionMeta(): SessionMetadata;
     retrieveSessionData(): Promise<SessionData | null>;
+    refreshSessionData(): Promise<SessionData | null>;
     withOrg(orgId: string): CubistApiClient;
     sessionKeysList(): Promise<KeyInfo[]>;
     keyGetByMaterialId(keyType: string, materialId: string): Promise<KeyInfo>;
@@ -329,6 +332,7 @@ declare class CubeSignerClient {
     get env(): EnvInterface;
     get orgId(): string;
     retrieveSessionData(): Promise<SessionData | null>;
+    refreshSessionData(): Promise<SessionData | null>;
     static create(session: string | SessionData | SessionManager, targetOrgId?: string): Promise<CubeSignerClient>;
     static createOidcSession(env: EnvInterface, orgId: string, token: string, scopes: Array<Scope>, lifetimes?: RatchetConfig, mfaReceipt?: MfaReceipts, purpose?: string): Promise<CubeSignerResponse<SessionData>>;
     static proveOidcIdentity(env: EnvInterface, orgId: string, token: string): Promise<IdentityProof>;
@@ -359,7 +363,7 @@ interface CubeSignerConfig {
     orgId: string;
     /** Session scopes (default: `["sign:*", "manage:*"]`). */
     scopes?: string[];
-    /** Session lifetimes (default: `{ session: 60 * 60 * 24 * 30, auth: 60 * 60 * 24 * 30, refresh: 60 * 60 * 24 * 30*2 }`). */
+    /** Session lifetimes (default: `{ session: 60 * 60 * 24 * 30, auth: 60 * 60 * 24 * 30 }`). */
     lifetimes?: RatchetConfig;
     /** Optional capability policy applied to smart-wallet sessions created from this auth flow. */
     defaultSessionPolicy?: Partial<SessionCapabilityPolicy>;
@@ -386,7 +390,6 @@ interface TwitterCodeExchangeParams {
     /** redirect_uri that was used in the authorization request. */
     redirectUri: string;
 }
-declare function refreshCubeSignerSessionData(sessionData: SessionData): Promise<SessionData>;
 declare class CubeSignerAuth {
     private readonly env;
     private readonly orgId;
@@ -394,8 +397,10 @@ declare class CubeSignerAuth {
     private readonly lifetimes;
     readonly defaultSessionPolicy?: Partial<SessionCapabilityPolicy>;
     private readonly oidcLoginHooks?;
+    onSessionDataUpdated?: (sessionData: SessionData) => void;
     private _client;
     private _sessionData;
+    private _managedSession;
     constructor(config: CubeSignerConfig);
     /** Currently authenticated client (null if not logged in). */
     get client(): CubeSignerClient | null;
@@ -436,7 +441,8 @@ declare class CubeSignerAuth {
      * Create a CubeSigner OIDC session from a generic OIDC id_token.
      */
     private createOidcSession;
+    private createManagedSession;
     private parseOidcUserInfo;
 }
 
-export { getChainDescriptor as A, type BalanceInfo as B, CubeSignerAuth as C, getSupportedChainFromEvmChainId as D, type EvmTransactionRequest as E, isCapabilityPolicyExpired as F, isSessionExpired as G, sessionSupportsCapability as H, type OidcLoginHooks as O, type ProviderCategory as P, type SessionCapabilityCheck as S, type TwitterCodeExchangeParams as T, type UserInfo as U, type WalletState as W, type CubeSignerConfig as a, type CubeSignerSession as b, type WalletSession as c, type WalletAdapter as d, type WalletConnectArgs as e, type WalletCapability as f, type WalletProviderRequest as g, type SupportedChain as h, type WalletProvider as i, type ChainContext as j, type SessionCapabilityPolicy as k, type ChainDescriptor as l, type ChainNamespace as m, type ChainRpcFamily as n, type EvmAccessListItem as o, type EvmQuantity as p, SessionCapabilityError as q, refreshCubeSignerSessionData as r, type SupportedToken as s, type WalletAuthSource as t, type WalletType as u, assertSessionCapability as v, createChainContext as w, createSessionCapabilityPolicy as x, describeSessionCapabilityPolicy as y, getAllChainDescriptors as z };
+export { getSupportedChainFromEvmChainId as A, type BalanceInfo as B, CubeSignerAuth as C, isCapabilityPolicyExpired as D, type EvmTransactionRequest as E, isSessionExpired as F, sessionSupportsCapability as G, type SessionData as H, type OidcLoginHooks as O, type ProviderCategory as P, type SessionCapabilityCheck as S, type TwitterCodeExchangeParams as T, type UserInfo as U, type WalletState as W, type CubeSignerConfig as a, type CubeSignerSession as b, type WalletSession as c, type WalletAdapter as d, type WalletConnectArgs as e, type WalletCapability as f, type WalletProviderRequest as g, type SupportedChain as h, type WalletProvider as i, type ChainContext as j, type SessionCapabilityPolicy as k, type ChainDescriptor as l, type ChainNamespace as m, type ChainRpcFamily as n, type EvmAccessListItem as o, type EvmQuantity as p, SessionCapabilityError as q, type SupportedToken as r, type WalletAuthSource as s, type WalletType as t, assertSessionCapability as u, createChainContext as v, createSessionCapabilityPolicy as w, describeSessionCapabilityPolicy as x, getAllChainDescriptors as y, getChainDescriptor as z };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { W as WalletState, c as WalletSession, B as BalanceInfo, d as WalletAdapter, e as WalletConnectArgs, f as WalletCapability, g as WalletProviderRequest, E as EvmTransactionRequest, S as SessionCapabilityCheck, h as SupportedChain, i as WalletProvider, j as ChainContext, k as SessionCapabilityPolicy } from './cubeSignerAuth-C3n7VgB8.js';
-export { l as ChainDescriptor, m as ChainNamespace, n as ChainRpcFamily, C as CubeSignerAuth, a as CubeSignerConfig, b as CubeSignerSession, o as EvmAccessListItem, p as EvmQuantity, O as OidcLoginHooks, P as ProviderCategory, q as SessionCapabilityError, s as SupportedToken, T as TwitterCodeExchangeParams, U as UserInfo, t as WalletAuthSource, u as WalletType, v as assertSessionCapability, w as createChainContext, x as createSessionCapabilityPolicy, y as describeSessionCapabilityPolicy, z as getAllChainDescriptors, A as getChainDescriptor, D as getSupportedChainFromEvmChainId, F as isCapabilityPolicyExpired, G as isSessionExpired, r as refreshCubeSignerSessionData, H as sessionSupportsCapability } from './cubeSignerAuth-C3n7VgB8.js';
+import { W as WalletState, c as WalletSession, B as BalanceInfo, d as WalletAdapter, e as WalletConnectArgs, f as WalletCapability, g as WalletProviderRequest, E as EvmTransactionRequest, S as SessionCapabilityCheck, h as SupportedChain, i as WalletProvider, j as ChainContext, k as SessionCapabilityPolicy } from './cubeSignerAuth-Cwnx1DZ1.js';
+export { l as ChainDescriptor, m as ChainNamespace, n as ChainRpcFamily, C as CubeSignerAuth, a as CubeSignerConfig, b as CubeSignerSession, o as EvmAccessListItem, p as EvmQuantity, O as OidcLoginHooks, P as ProviderCategory, q as SessionCapabilityError, r as SupportedToken, T as TwitterCodeExchangeParams, U as UserInfo, s as WalletAuthSource, t as WalletType, u as assertSessionCapability, v as createChainContext, w as createSessionCapabilityPolicy, x as describeSessionCapabilityPolicy, y as getAllChainDescriptors, z as getChainDescriptor, A as getSupportedChainFromEvmChainId, D as isCapabilityPolicyExpired, F as isSessionExpired, G as sessionSupportsCapability } from './cubeSignerAuth-Cwnx1DZ1.js';
 import EventEmitter from 'eventemitter3';
-import { e as AbstractProvider } from './social-provider-B1XSe1Sr.js';
-export { A as AbstractSocialProvider, C as CUBIST_CAPABILITIES, a as CubistLoginMethod, b as CubistSessionAdapter, c as CubistSocialProvider, S as SocialConnectArgs, d as SocialLoginOptions } from './social-provider-B1XSe1Sr.js';
+import { e as AbstractProvider } from './social-provider-DIuMlnXm.js';
+export { A as AbstractSocialProvider, C as CUBIST_CAPABILITIES, a as CubistLoginMethod, b as CubistSessionAdapter, c as CubistSocialProvider, S as SocialConnectArgs, d as SocialLoginOptions } from './social-provider-DIuMlnXm.js';
 
 declare const EVM_TRANSACTION_SIGNING_UNSUPPORTED = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
 declare class EvmTransactionSigningUnsupportedError extends Error {
@@ -28,6 +28,8 @@ type WalletEvents = {
 declare class SessionStore {
     private state;
     private emitter;
+    private _pendingExpiredSession;
+    private _expiryTimerId;
     constructor();
     getState(): WalletState;
     setConnecting(flag: boolean): void;
@@ -38,6 +40,17 @@ declare class SessionStore {
     revokeSession(): void;
     setBalance(balance: BalanceInfo | null): void;
     on<T extends keyof WalletEvents>(event: T, listener: (...args: WalletEvents[T]) => void): () => EventEmitter<WalletEvents, any>;
+    /**
+     * Emit `session:expired` for a session that was already expired at rehydration time.
+     * Call this after attaching listeners so the event is actually received.
+     */
+    flushPendingExpiry(): void;
+    /**
+     * Start a periodic timer that checks whether the current session has expired.
+     * When `session.expiresAt <= Date.now()`, calls `expireSession()` which emits `session:expired`.
+     */
+    startExpiryTimer(intervalMs?: number): void;
+    stopExpiryTimer(): void;
     private tryRehydrate;
 }
 declare const sessionStore: SessionStore;

package/dist/index.js

@@ -1,7 +1,7 @@
-import { createChainContext, AbstractProvider, getSupportedChainFromEvmChainId, assertSessionCapability } from './chunk-SBOQGPRF.js';
-export { AbstractProvider, AbstractSocialProvider, CUBIST_CAPABILITIES, CubistSocialProvider, SessionCapabilityError, assertSessionCapability, createChainContext, createSessionCapabilityPolicy, describeSessionCapabilityPolicy, getAllChainDescriptors, getChainDescriptor, getSupportedChainFromEvmChainId, isCapabilityPolicyExpired, isSessionExpired, sessionSupportsCapability } from './chunk-SBOQGPRF.js';
-export { CubeSignerAuth, refreshCubeSignerSessionData } from './chunk-ADMEF7PF.js';
-import EventEmitter from 'eventemitter3';
+import { AbstractProvider, assertSessionCapability } from './chunk-K63POESF.js';
+export { AbstractProvider, AbstractSocialProvider, CUBIST_CAPABILITIES, CubistSocialProvider, SessionCapabilityError, assertSessionCapability, createSessionCapabilityPolicy, describeSessionCapabilityPolicy, isCapabilityPolicyExpired, isSessionExpired, sessionSupportsCapability } from './chunk-K63POESF.js';
+import { sessionStore, getSupportedChainFromEvmChainId, createChainContext, isStaleSessionError, USER_SESSION_EXPIRED_MESSAGE } from './chunk-V4LAUAGS.js';
+export { CubeSignerAuth, STALE_SESSION_ERROR_MESSAGE, SessionStore, USER_SESSION_EXPIRED_MESSAGE, createChainContext, getAllChainDescriptors, getChainDescriptor, getSupportedChainFromEvmChainId, isStaleSessionError, sessionStore } from './chunk-V4LAUAGS.js';
 
 // src/core/errors.ts
 var EVM_TRANSACTION_SIGNING_UNSUPPORTED = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
@@ -47,142 +47,6 @@ var normalizeEvmTransactionSigningError = (providerName, error) => {
   }
   return error instanceof Error ? error : new Error(String(error));
 };
-var STORAGE_KEY = "ab:wallet:session";
-function getStorage() {
-  try {
-    return typeof localStorage !== "undefined" ? localStorage : null;
-  } catch {
-    return null;
-  }
-}
-function persistSession(session) {
-  const storage = getStorage();
-  if (!storage) return;
-  if (!session) {
-    storage.removeItem(STORAGE_KEY);
-    return;
-  }
-  const serializable = {
-    address: session.address,
-    chain: session.chain,
-    walletType: session.walletType,
-    authSource: session.authSource,
-    sessionId: session.sessionId,
-    expiresAt: session.expiresAt
-  };
-  if (session.capabilities?.length) {
-    serializable.capabilities = session.capabilities;
-  }
-  if (session.sessionData !== void 0) {
-    serializable.sessionData = session.sessionData;
-  }
-  if (session.capabilityPolicy !== void 0) {
-    serializable.capabilityPolicy = session.capabilityPolicy;
-  }
-  if (session.userInfo !== void 0) {
-    serializable.userInfo = session.userInfo;
-  }
-  try {
-    storage.setItem(STORAGE_KEY, JSON.stringify(serializable));
-  } catch {
-    storage.removeItem(STORAGE_KEY);
-  }
-}
-function readPersistedSession() {
-  const storage = getStorage();
-  if (!storage) return null;
-  const raw = storage.getItem(STORAGE_KEY);
-  if (!raw) return null;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    storage.removeItem(STORAGE_KEY);
-    return null;
-  }
-}
-var STALE_SESSION_ERROR_MESSAGE = "Session restored from cache. Reconnect your wallet for transactions.";
-var USER_SESSION_EXPIRED_MESSAGE = "Session expired. Please reconnect your wallet and try again.";
-function isStaleSessionError(error) {
-  return error instanceof Error && error.message.includes(STALE_SESSION_ERROR_MESSAGE);
-}
-var staleProvider = {
-  request() {
-    return Promise.reject(new Error(STALE_SESSION_ERROR_MESSAGE));
-  },
-  disconnect() {
-    return Promise.resolve();
-  }
-};
-var SessionStore = class {
-  constructor() {
-    this.state = {
-      session: null,
-      balance: null,
-      isConnecting: false
-    };
-    this.emitter = new EventEmitter();
-    this.tryRehydrate();
-  }
-  getState() {
-    return { ...this.state };
-  }
-  setConnecting(flag) {
-    this.state.isConnecting = flag;
-    this.emitter.emit("connecting:changed", flag);
-  }
-  setSession(session) {
-    this.state.session = session;
-    persistSession(session);
-    this.emitter.emit("session:changed", session);
-  }
-  rehydrateSession(session) {
-    this.state.session = session;
-    persistSession(session);
-    this.emitter.emit("session:changed", session);
-    this.emitter.emit("session:rehydrated", session);
-  }
-  clearSession() {
-    this.state.session = null;
-    this.state.balance = null;
-    persistSession(null);
-    this.emitter.emit("session:changed", null);
-    this.emitter.emit("balance:changed", null);
-  }
-  expireSession() {
-    const currentSession = this.state.session;
-    if (!currentSession) return;
-    this.clearSession();
-    this.emitter.emit("session:expired", currentSession);
-  }
-  revokeSession() {
-    const currentSession = this.state.session;
-    if (!currentSession) return;
-    this.clearSession();
-    this.emitter.emit("session:revoked", currentSession);
-  }
-  setBalance(balance) {
-    this.state.balance = balance;
-    this.emitter.emit("balance:changed", balance);
-  }
-  on(event, listener) {
-    this.emitter.on(event, listener);
-    return () => this.emitter.off(event, listener);
-  }
-  tryRehydrate() {
-    const persisted = readPersistedSession();
-    if (!persisted) return;
-    if (persisted.expiresAt && persisted.expiresAt <= Date.now()) {
-      persistSession(null);
-      return;
-    }
-    this.state.session = {
-      ...persisted,
-      provider: staleProvider,
-      chainContext: createChainContext(persisted.chain)
-    };
-  }
-};
-var sessionStore = new SessionStore();
 
 // src/core/walletExecution.ts
 var requireSession = (session) => {
@@ -288,8 +152,24 @@ var createWalletExecutionController = () => ({
 });
 
 // src/core/walletConnector.ts
+function attachSessionDataSync(adapter) {
+  const socialAdapter = adapter;
+  if (!("onSessionDataUpdated" in socialAdapter)) {
+    return;
+  }
+  const previousHandler = socialAdapter.onSessionDataUpdated;
+  socialAdapter.onSessionDataUpdated = (sessionData) => {
+    previousHandler?.(sessionData);
+    const current = sessionStore.getState().session;
+    if (!current) return;
+    sessionStore.setSession({
+      ...current,
+      sessionData
+    });
+  };
+}
 var ADAPTER_STORAGE_KEY = "ab:wallet:adapterId";
-function getStorage2() {
+function getStorage() {
   try {
     return typeof localStorage !== "undefined" ? localStorage : null;
   } catch {
@@ -297,7 +177,7 @@ function getStorage2() {
   }
 }
 function persistAdapterId(adapterId) {
-  const storage = getStorage2();
+  const storage = getStorage();
   if (!storage) return;
   if (!adapterId) {
     storage.removeItem(ADAPTER_STORAGE_KEY);
@@ -306,7 +186,7 @@ function persistAdapterId(adapterId) {
   }
 }
 function readPersistedAdapterId() {
-  const storage = getStorage2();
+  const storage = getStorage();
   if (!storage) return null;
   return storage.getItem(ADAPTER_STORAGE_KEY);
 }
@@ -349,6 +229,7 @@ var WalletConnector = class {
       this.currentAdapterId = adapter.id;
       persistAdapterId(adapter.id);
       sessionStore.setSession(session);
+      attachSessionDataSync(adapter);
       sessionStore.setBalance(null);
       return session;
     } finally {
@@ -390,6 +271,7 @@ var WalletConnector = class {
       this.currentAdapterId = adapterId;
       persistAdapterId(adapterId);
       sessionStore.rehydrateSession(session);
+      attachSessionDataSync(adapter);
       return session;
     } catch {
       return null;
@@ -1146,4 +1028,4 @@ function createDefaultInjectedWalletRegistry() {
   }));
 }
 
-export { BitgetProvider, BraveWalletProvider, CoinbaseWalletProvider, EVM_TRANSACTION_SIGNING_UNSUPPORTED, EvmTransactionSigningUnsupportedError, InjectedEvmProvider, MetaMaskProvider, OKXProvider, PhantomProvider, RabbyProvider, RainbowProvider, STALE_SESSION_ERROR_MESSAGE, SessionStore, TrustWalletProvider, USER_SESSION_EXPIRED_MESSAGE, WalletConnector, ZerionProvider, createAccountController, createDefaultInjectedWalletRegistry, createWalletConnectController, createWalletExecutionClient, createWalletExecutionController, discoverEIP6963Providers, findEIP6963Provider, findInjectedProvider, getWalletExecutionCapabilities, isStaleSessionError, isUnsupportedEvmTransactionSigningError, normalizeEvmTransactionSigningError, sessionStore, switchToFallbackFundingChain };
+export { BitgetProvider, BraveWalletProvider, CoinbaseWalletProvider, EVM_TRANSACTION_SIGNING_UNSUPPORTED, EvmTransactionSigningUnsupportedError, InjectedEvmProvider, MetaMaskProvider, OKXProvider, PhantomProvider, RabbyProvider, RainbowProvider, TrustWalletProvider, WalletConnector, ZerionProvider, createAccountController, createDefaultInjectedWalletRegistry, createWalletConnectController, createWalletExecutionClient, createWalletExecutionController, discoverEIP6963Providers, findEIP6963Provider, findInjectedProvider, getWalletExecutionCapabilities, isUnsupportedEvmTransactionSigningError, normalizeEvmTransactionSigningError, switchToFallbackFundingChain };

package/dist/social-auth.d.ts

@@ -1,5 +1,5 @@
-import { b as CubeSignerSession, h as SupportedChain, i as WalletProvider } from './cubeSignerAuth-C3n7VgB8.js';
-export { C as CubeSignerAuth, a as CubeSignerConfig, O as OidcLoginHooks, T as TwitterCodeExchangeParams, r as refreshCubeSignerSessionData } from './cubeSignerAuth-C3n7VgB8.js';
+import { b as CubeSignerSession, h as SupportedChain, i as WalletProvider } from './cubeSignerAuth-Cwnx1DZ1.js';
+export { C as CubeSignerAuth, a as CubeSignerConfig, O as OidcLoginHooks, T as TwitterCodeExchangeParams } from './cubeSignerAuth-Cwnx1DZ1.js';
 
 interface CreateCubistEvmWalletProviderArgs {
     session: CubeSignerSession;

package/dist/social-auth.js

@@ -1 +1 @@
-export { CubeSignerAuth, createCubistEvmWalletProvider, refreshCubeSignerSessionData } from './chunk-ADMEF7PF.js';
+export { CubeSignerAuth, createCubistEvmWalletProvider } from './chunk-V4LAUAGS.js';

package/dist/{social-provider-B1XSe1Sr.d.ts → social-provider-DIuMlnXm.d.ts}

@@ -1,4 +1,4 @@
-import { d as WalletAdapter, P as ProviderCategory, c as WalletSession, e as WalletConnectArgs, i as WalletProvider, f as WalletCapability, T as TwitterCodeExchangeParams, b as CubeSignerSession, a as CubeSignerConfig, C as CubeSignerAuth } from './cubeSignerAuth-C3n7VgB8.js';
+import { d as WalletAdapter, P as ProviderCategory, c as WalletSession, e as WalletConnectArgs, i as WalletProvider, f as WalletCapability, T as TwitterCodeExchangeParams, b as CubeSignerSession, H as SessionData, a as CubeSignerConfig, C as CubeSignerAuth } from './cubeSignerAuth-Cwnx1DZ1.js';
 
 declare abstract class AbstractProvider implements WalletAdapter {
     abstract readonly id: string;
@@ -53,6 +53,7 @@ declare const CUBIST_CAPABILITIES: WalletCapability[];
 declare class CubistSocialProvider extends AbstractSocialProvider {
     readonly id = "cubist";
     readonly title = "Cubist Social Wallet";
+    onSessionDataUpdated?: (sessionData: SessionData) => void;
     private auth;
     private adapter;
     private lastCubeSignerSession;

package/dist/social-provider.d.ts

@@ -1,2 +1,2 @@
-export { A as AbstractSocialProvider, C as CUBIST_CAPABILITIES, a as CubistLoginMethod, b as CubistSessionAdapter, c as CubistSocialProvider, S as SocialConnectArgs, d as SocialLoginOptions } from './social-provider-B1XSe1Sr.js';
-import './cubeSignerAuth-C3n7VgB8.js';
+export { A as AbstractSocialProvider, C as CUBIST_CAPABILITIES, a as CubistLoginMethod, b as CubistSessionAdapter, c as CubistSocialProvider, S as SocialConnectArgs, d as SocialLoginOptions } from './social-provider-DIuMlnXm.js';
+import './cubeSignerAuth-Cwnx1DZ1.js';

package/dist/social-provider.js

@@ -1,2 +1,2 @@
-export { AbstractSocialProvider, CUBIST_CAPABILITIES, CubistSocialProvider } from './chunk-SBOQGPRF.js';
-import './chunk-ADMEF7PF.js';
+export { AbstractSocialProvider, CUBIST_CAPABILITIES, CubistSocialProvider } from './chunk-K63POESF.js';
+import './chunk-V4LAUAGS.js';

package/dist/social.d.ts

@@ -1,3 +1,3 @@
-export { C as CubeSignerAuth, a as CubeSignerConfig, b as CubeSignerSession, O as OidcLoginHooks, T as TwitterCodeExchangeParams, r as refreshCubeSignerSessionData } from './cubeSignerAuth-C3n7VgB8.js';
+export { C as CubeSignerAuth, a as CubeSignerConfig, b as CubeSignerSession, O as OidcLoginHooks, T as TwitterCodeExchangeParams } from './cubeSignerAuth-Cwnx1DZ1.js';
 export { createCubistEvmWalletProvider } from './social-auth.js';
-export { A as AbstractSocialProvider, C as CUBIST_CAPABILITIES, a as CubistLoginMethod, b as CubistSessionAdapter, c as CubistSocialProvider, S as SocialConnectArgs, d as SocialLoginOptions } from './social-provider-B1XSe1Sr.js';
+export { A as AbstractSocialProvider, C as CUBIST_CAPABILITIES, a as CubistLoginMethod, b as CubistSessionAdapter, c as CubistSocialProvider, S as SocialConnectArgs, d as SocialLoginOptions } from './social-provider-DIuMlnXm.js';

package/dist/social.js

@@ -1,2 +1,2 @@
-export { AbstractSocialProvider, CUBIST_CAPABILITIES, CubistSocialProvider } from './chunk-SBOQGPRF.js';
-export { CubeSignerAuth, createCubistEvmWalletProvider, refreshCubeSignerSessionData } from './chunk-ADMEF7PF.js';
+export { AbstractSocialProvider, CUBIST_CAPABILITIES, CubistSocialProvider } from './chunk-K63POESF.js';
+export { CubeSignerAuth, createCubistEvmWalletProvider } from './chunk-V4LAUAGS.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ab-org/sdk-core",
-  "version": "0.3.0-beta.4",
+  "version": "0.3.0-beta.6",
   "type": "module",
   "files": [
     "dist/**/*",
@@ -37,7 +37,7 @@
   "devDependencies": {
     "typescript": "^5.5.4",
     "tsup": "^8.5.1",
-    "@ab-org/wallet-utils": "0.0.7"
+    "@ab-org/wallet-utils": "0.1.0-beta.1"
   },
   "scripts": {
     "build": "pnpm exec tsup",