@ab-org/sdk-core 0.1.0 → 0.1.2-beta.0

package/dist/social-auth.d.ts

@@ -0,0 +1,11 @@
+import { b as CubeSignerSession, h as SupportedChain, i as WalletProvider } from './cubeSignerAuth-DrPc9FeB.js';
+export { C as CubeSignerAuth, a as CubeSignerConfig, O as OidcLoginHooks, T as TwitterCodeExchangeParams } from './cubeSignerAuth-DrPc9FeB.js';
+
+interface CreateCubistEvmWalletProviderArgs {
+    session: CubeSignerSession;
+    address: string;
+    chain: SupportedChain;
+}
+declare const createCubistEvmWalletProvider: ({ session, address, chain, }: CreateCubistEvmWalletProviderArgs) => WalletProvider;
+
+export { CubeSignerSession, createCubistEvmWalletProvider };

package/dist/social-auth.js

@@ -0,0 +1 @@
+export { CubeSignerAuth, createCubistEvmWalletProvider } from './chunk-5HURLKIK.js';

package/dist/social-provider-Bq58TBRt.d.ts

@@ -0,0 +1,88 @@
+import { d as WalletAdapter, P as ProviderCategory, c as WalletSession, e as WalletConnectArgs, i as WalletProvider, T as TwitterCodeExchangeParams, b as CubeSignerSession, a as CubeSignerConfig, C as CubeSignerAuth } from './cubeSignerAuth-DrPc9FeB.js';
+
+declare abstract class AbstractProvider implements WalletAdapter {
+    abstract readonly id: string;
+    abstract readonly title: string;
+    abstract readonly category: ProviderCategory;
+    protected currentSession: WalletSession | null;
+    abstract connect(args?: WalletConnectArgs): Promise<WalletSession>;
+    disconnect(): Promise<void>;
+    protected setSession(session: WalletSession): WalletSession;
+    protected clearSession(): void;
+    protected get session(): WalletSession | null;
+    protected requireSession(message?: string): WalletSession;
+    getProvider(): WalletProvider | null;
+    reconnect(_persistedSession: WalletSession): Promise<WalletSession | null>;
+}
+
+interface SocialLoginOptions {
+    hint?: string;
+    redirectUri?: string;
+}
+interface SocialConnectArgs extends WalletConnectArgs {
+    options?: SocialLoginOptions;
+}
+declare abstract class AbstractSocialProvider extends AbstractProvider {
+    readonly category: "social";
+    /**
+     * Authenticate and cache a social-wallet session.
+     *
+     * Some providers only need `options`, while others may require an
+     * additional credential payload (for example an OIDC token or OAuth result).
+     */
+    abstract signIn(options?: SocialLoginOptions, payload?: unknown): Promise<void>;
+    abstract signOut(): Promise<void>;
+    connect(args?: WalletConnectArgs): Promise<WalletSession>;
+}
+
+type CubistLoginMethod = {
+    type: "google";
+    idToken: string;
+} | {
+    type: "twitter";
+    params: TwitterCodeExchangeParams;
+};
+interface CubistSessionAdapter {
+    /**
+     * Convert a raw CubeSigner session into a WalletSession
+     * (resolve the first key's address, chain, build a provider, etc.).
+     */
+    resolve(session: CubeSignerSession): Promise<WalletSession>;
+}
+declare class CubistSocialProvider extends AbstractSocialProvider {
+    readonly id = "cubist";
+    readonly title = "Cubist Social Wallet";
+    private auth;
+    private adapter;
+    private lastCubeSignerSession;
+    /** Stash the login method so `connect()` can auto-retry. */
+    private lastLogin;
+    constructor(config: CubeSignerConfig, adapter?: CubistSessionAdapter);
+    private createWalletSession;
+    private authenticate;
+    private getResolvedLoginMethod;
+    /**
+     * Preferred explicit sign-in entrypoint.
+     */
+    signInWith(method: CubistLoginMethod, _options?: SocialLoginOptions): Promise<void>;
+    /**
+     * Backward-compatible abstract implementation.
+     *
+     * - If `payload` is provided, it is treated as the login method.
+     * - Otherwise reuses the previously cached login method if available.
+     */
+    signIn(_options?: SocialLoginOptions, payload?: unknown): Promise<void>;
+    /**
+     * Explicit connect flow that both authenticates and returns the wallet session.
+     */
+    connectWith(method: CubistLoginMethod, options?: SocialLoginOptions): Promise<WalletSession>;
+    connect(args?: WalletConnectArgs): Promise<WalletSession>;
+    reconnect(persistedSession: WalletSession): Promise<WalletSession | null>;
+    signOut(): Promise<void>;
+    disconnect(): Promise<void>;
+    /** Direct access to the underlying CubeSignerAuth for advanced use-cases. */
+    get cubeSignerAuth(): CubeSignerAuth;
+    get cubeSignerSession(): CubeSignerSession | null;
+}
+
+export { AbstractSocialProvider as A, type CubistLoginMethod as C, type SocialConnectArgs as S, type CubistSessionAdapter as a, CubistSocialProvider as b, type SocialLoginOptions as c, AbstractProvider as d };

package/dist/social-provider.d.ts

@@ -0,0 +1,2 @@
+export { A as AbstractSocialProvider, C as CubistLoginMethod, a as CubistSessionAdapter, b as CubistSocialProvider, S as SocialConnectArgs, c as SocialLoginOptions } from './social-provider-Bq58TBRt.js';
+import './cubeSignerAuth-DrPc9FeB.js';

package/dist/social-provider.js

@@ -0,0 +1,2 @@
+export { AbstractSocialProvider, CubistSocialProvider } from './chunk-MVZIAM4H.js';
+import './chunk-5HURLKIK.js';

package/dist/social.d.ts

@@ -0,0 +1,3 @@
+export { C as CubeSignerAuth, a as CubeSignerConfig, b as CubeSignerSession, O as OidcLoginHooks, T as TwitterCodeExchangeParams } from './cubeSignerAuth-DrPc9FeB.js';
+export { createCubistEvmWalletProvider } from './social-auth.js';
+export { A as AbstractSocialProvider, C as CubistLoginMethod, a as CubistSessionAdapter, b as CubistSocialProvider, S as SocialConnectArgs, c as SocialLoginOptions } from './social-provider-Bq58TBRt.js';

package/dist/social.js

@@ -0,0 +1,2 @@
+export { AbstractSocialProvider, CubistSocialProvider } from './chunk-MVZIAM4H.js';
+export { CubeSignerAuth, createCubistEvmWalletProvider } from './chunk-5HURLKIK.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ab-org/sdk-core",
-  "version": "0.1.0",
+  "version": "0.1.2-beta.0",
   "type": "module",
   "files": [
     "dist/**/*",
@@ -8,20 +8,38 @@
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./social": {
+      "types": "./dist/social.d.ts",
+      "import": "./dist/social.js"
+    },
+    "./social/auth": {
+      "types": "./dist/social-auth.d.ts",
+      "import": "./dist/social-auth.js"
+    },
+    "./social/provider": {
+      "types": "./dist/social-provider.d.ts",
+      "import": "./dist/social-provider.js"
+    }
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@cubist-labs/cubesigner-sdk": "^0.4.219",
-    "eventemitter3": "^5.0.1",
-    "@ab-org/wallet-utils": "0.0.7"
+    "eventemitter3": "^5.0.1"
   },
   "devDependencies": {
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "tsup": "^8.5.1",
+    "@ab-org/wallet-utils": "0.0.7"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "pnpm exec tsup",
     "lint": "eslint 'src/**/*.{ts,tsx}'",
     "test": "vitest run --passWithNoTests"
   }

package/dist/core/capabilities.d.ts

@@ -1,32 +0,0 @@
-import type { SupportedChain, SupportedToken, WalletSession } from "./types.js";
-export type WalletCapability = "eth_accounts" | "eth_requestAccounts" | "eth_chainId" | "eth_signTransaction" | "eth_sendTransaction" | "personal_sign" | "eth_signTypedData_v4" | "wallet_disconnect" | "wallet_rehydrate" | string;
-export interface SessionCapabilityPolicy {
-    id: string;
-    appId?: string;
-    origin?: string;
-    expiresAt?: number;
-    methods?: WalletCapability[];
-    chains?: SupportedChain[];
-    tokens?: SupportedToken[];
-    maxAmount?: string;
-    revocable?: boolean;
-    metadata?: Record<string, unknown>;
-}
-export interface SessionCapabilityCheck {
-    capability: WalletCapability;
-    chain?: SupportedChain;
-    token?: SupportedToken;
-    amount?: string | number | bigint;
-    appId?: string;
-    origin?: string;
-    now?: number;
-}
-export declare class SessionCapabilityError extends Error {
-    constructor(message: string);
-}
-export declare const createSessionCapabilityPolicy: (input?: Partial<SessionCapabilityPolicy>) => SessionCapabilityPolicy;
-export declare const isSessionExpired: (session: Pick<WalletSession, "expiresAt"> | null | undefined, now?: number) => boolean;
-export declare const isCapabilityPolicyExpired: (policy: SessionCapabilityPolicy | null | undefined, now?: number) => boolean;
-export declare const sessionSupportsCapability: (session: Pick<WalletSession, "capabilities"> | null | undefined, capability: WalletCapability) => boolean;
-export declare const describeSessionCapabilityPolicy: (policy: SessionCapabilityPolicy | null | undefined) => string[];
-export declare const assertSessionCapability: (session: WalletSession, check: SessionCapabilityCheck) => void;

package/dist/core/capabilities.js

@@ -1,88 +0,0 @@
-export class SessionCapabilityError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "SessionCapabilityError";
-    }
-}
-const toBigIntAmount = (value) => {
-    if (typeof value === "bigint")
-        return value;
-    if (typeof value === "number")
-        return BigInt(value);
-    return BigInt(value);
-};
-export const createSessionCapabilityPolicy = (input = {}) => ({
-    id: input.id ?? `cap:${Date.now()}`,
-    appId: input.appId,
-    origin: input.origin,
-    expiresAt: input.expiresAt,
-    methods: input.methods,
-    chains: input.chains,
-    tokens: input.tokens,
-    maxAmount: input.maxAmount,
-    revocable: input.revocable ?? true,
-    metadata: input.metadata,
-});
-export const isSessionExpired = (session, now = Date.now()) => Boolean(session?.expiresAt && session.expiresAt <= now);
-export const isCapabilityPolicyExpired = (policy, now = Date.now()) => Boolean(policy?.expiresAt && policy.expiresAt <= now);
-export const sessionSupportsCapability = (session, capability) => {
-    const capabilities = session?.capabilities;
-    if (!capabilities || capabilities.length === 0)
-        return true;
-    return capabilities.includes(capability);
-};
-export const describeSessionCapabilityPolicy = (policy) => {
-    if (!policy)
-        return [];
-    const lines = [];
-    if (policy.origin)
-        lines.push(`Origin: ${policy.origin}`);
-    if (policy.appId)
-        lines.push(`App: ${policy.appId}`);
-    if (policy.methods?.length)
-        lines.push(`Methods: ${policy.methods.join(", ")}`);
-    if (policy.chains?.length)
-        lines.push(`Chains: ${policy.chains.join(", ")}`);
-    if (policy.tokens?.length)
-        lines.push(`Tokens: ${policy.tokens.join(", ")}`);
-    if (policy.maxAmount)
-        lines.push(`Max amount: ${policy.maxAmount}`);
-    if (policy.expiresAt)
-        lines.push(`Expires at: ${new Date(policy.expiresAt).toISOString()}`);
-    return lines;
-};
-export const assertSessionCapability = (session, check) => {
-    const now = check.now ?? Date.now();
-    if (isSessionExpired(session, now)) {
-        throw new SessionCapabilityError("Wallet session has expired");
-    }
-    const policy = session.capabilityPolicy;
-    if (isCapabilityPolicyExpired(policy, now)) {
-        throw new SessionCapabilityError("Capability session has expired");
-    }
-    if (!sessionSupportsCapability(session, check.capability)) {
-        throw new SessionCapabilityError(`Wallet session does not support capability "${check.capability}"`);
-    }
-    if (!policy)
-        return;
-    if (policy.appId && check.appId && policy.appId !== check.appId) {
-        throw new SessionCapabilityError("Capability session is scoped to a different app");
-    }
-    if (policy.origin && check.origin && policy.origin !== check.origin) {
-        throw new SessionCapabilityError("Capability session is scoped to a different origin");
-    }
-    if (policy.methods?.length && !policy.methods.includes(check.capability)) {
-        throw new SessionCapabilityError(`Capability "${check.capability}" is not allowed for this session`);
-    }
-    if (check.chain && policy.chains?.length && !policy.chains.includes(check.chain)) {
-        throw new SessionCapabilityError(`Chain "${check.chain}" is not allowed for this session`);
-    }
-    if (check.token && policy.tokens?.length && !policy.tokens.includes(check.token)) {
-        throw new SessionCapabilityError(`Token "${check.token}" is not allowed for this session`);
-    }
-    if (policy.maxAmount && check.amount !== undefined) {
-        if (toBigIntAmount(check.amount) > toBigIntAmount(policy.maxAmount)) {
-            throw new SessionCapabilityError("Requested amount exceeds the capability session limit");
-        }
-    }
-};

package/dist/core/chains.d.ts

@@ -1,23 +0,0 @@
-import type { SupportedChain } from "./types.js";
-export type ChainNamespace = "evm" | "solana" | "ab-core";
-export type ChainRpcFamily = "evm" | "solana" | "custom";
-export interface ChainDescriptor {
-    chain: SupportedChain;
-    namespace: ChainNamespace;
-    reference: string;
-    label: string;
-    rpcFamily: ChainRpcFamily;
-    evmChainId?: number;
-    supportsSmartSessions: boolean;
-    supportsAccountAbstraction: boolean;
-}
-export interface ChainContext {
-    walletChain: SupportedChain;
-    walletChainDescriptor: ChainDescriptor;
-    settlementChain: SupportedChain;
-    settlementChainDescriptor: ChainDescriptor;
-}
-export declare const getChainDescriptor: (chain: SupportedChain) => ChainDescriptor;
-export declare const getAllChainDescriptors: () => ChainDescriptor[];
-export declare const getSupportedChainFromEvmChainId: (value: string | number | bigint) => SupportedChain;
-export declare const createChainContext: (walletChain: SupportedChain, settlementChain?: SupportedChain) => ChainContext;

package/dist/core/chains.js

@@ -1,83 +0,0 @@
-const 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,
-    },
-};
-export const getChainDescriptor = (chain) => chainDescriptors[chain];
-export const getAllChainDescriptors = () => Object.values(chainDescriptors);
-const normalizeEvmChainId = (value) => {
-    if (typeof value === "number")
-        return value;
-    if (typeof value === "bigint")
-        return Number(value);
-    return Number(BigInt(value));
-};
-export const 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;
-};
-export const createChainContext = (walletChain, settlementChain = walletChain) => ({
-    walletChain,
-    walletChainDescriptor: getChainDescriptor(walletChain),
-    settlementChain,
-    settlementChainDescriptor: getChainDescriptor(settlementChain),
-});

package/dist/core/errors.d.ts

@@ -1,9 +0,0 @@
-export declare const EVM_TRANSACTION_SIGNING_UNSUPPORTED = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
-export declare class EvmTransactionSigningUnsupportedError extends Error {
-    readonly providerName: string;
-    readonly cause?: unknown | undefined;
-    readonly code = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
-    constructor(providerName: string, cause?: unknown | undefined);
-}
-export declare const isUnsupportedEvmTransactionSigningError: (error: unknown) => boolean;
-export declare const normalizeEvmTransactionSigningError: (providerName: string, error: unknown) => Error;

package/dist/core/errors.js

@@ -1,51 +0,0 @@
-export const EVM_TRANSACTION_SIGNING_UNSUPPORTED = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
-export class EvmTransactionSigningUnsupportedError extends Error {
-    constructor(providerName, cause) {
-        super(`${providerName} does not support EVM transaction signing`);
-        this.providerName = providerName;
-        this.cause = cause;
-        this.code = EVM_TRANSACTION_SIGNING_UNSUPPORTED;
-        this.name = "EvmTransactionSigningUnsupportedError";
-    }
-}
-const getErrorCode = (error) => {
-    if (typeof error !== "object" || error === null || !("code" in error))
-        return undefined;
-    const { code } = error;
-    return typeof code === "number" || typeof code === "string" ? code : undefined;
-};
-const getErrorMessage = (error) => {
-    if (error instanceof Error)
-        return error.message;
-    if (typeof error === "object" && error !== null && "message" in error) {
-        const { message } = error;
-        if (typeof message === "string")
-            return message;
-    }
-    return String(error);
-};
-export const isUnsupportedEvmTransactionSigningError = (error) => {
-    if (error instanceof EvmTransactionSigningUnsupportedError) {
-        return true;
-    }
-    const code = getErrorCode(error);
-    if (code === 4200 || code === -32601) {
-        return true;
-    }
-    const message = getErrorMessage(error).toLowerCase();
-    return (message.includes("eth_signtransaction") &&
-        (message.includes("unsupported") ||
-            message.includes("not support") ||
-            message.includes("not found") ||
-            message.includes("does not exist") ||
-            message.includes("unrecognized")));
-};
-export const normalizeEvmTransactionSigningError = (providerName, error) => {
-    if (error instanceof Error && !isUnsupportedEvmTransactionSigningError(error)) {
-        return error;
-    }
-    if (isUnsupportedEvmTransactionSigningError(error)) {
-        return new EvmTransactionSigningUnsupportedError(providerName, error);
-    }
-    return error instanceof Error ? error : new Error(String(error));
-};

package/dist/core/sessionStore.d.ts

@@ -1,26 +0,0 @@
-import EventEmitter from "eventemitter3";
-import type { BalanceInfo, WalletSession, WalletState } from "./types.js";
-export type WalletEvents = {
-    "session:changed": [WalletSession | null];
-    "session:rehydrated": [WalletSession];
-    "session:expired": [WalletSession];
-    "session:revoked": [WalletSession];
-    "balance:changed": [BalanceInfo | null];
-    "connecting:changed": [boolean];
-};
-export declare class SessionStore {
-    private state;
-    private emitter;
-    constructor();
-    getState(): WalletState;
-    setConnecting(flag: boolean): void;
-    setSession(session: WalletSession | null): void;
-    rehydrateSession(session: WalletSession): void;
-    clearSession(): void;
-    expireSession(): void;
-    revokeSession(): void;
-    setBalance(balance: BalanceInfo | null): void;
-    on<T extends keyof WalletEvents>(event: T, listener: (...args: WalletEvents[T]) => void): () => EventEmitter<WalletEvents, any>;
-    private tryRehydrate;
-}
-export declare const sessionStore: SessionStore;

package/dist/core/sessionStore.js

@@ -1,129 +0,0 @@
-import EventEmitter from "eventemitter3";
-const STORAGE_KEY = "ab:wallet:session";
-function getStorage() {
-    try {
-        return typeof localStorage !== "undefined" ? localStorage : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Only persist known JSON-serializable fields; session may contain DOM/React refs or circular refs. */
-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;
-    }
-    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;
-    }
-}
-const staleProvider = {
-    request() {
-        return Promise.reject(new Error("Session restored from cache. Reconnect your wallet for transactions."));
-    },
-    disconnect() {
-        return Promise.resolve();
-    },
-};
-export class SessionStore {
-    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 };
-    }
-}
-export const sessionStore = new SessionStore();