@ab-org/sdk-core 0.0.1 → 0.1.1

package/dist/index.js

@@ -1,16 +1,1776 @@
-export * from "./core/types.js";
-export * from "./core/chains.js";
-export * from "./core/capabilities.js";
-export * from "./core/errors.js";
-export * from "./core/sessionStore.js";
-export * from "./core/walletConnector.js";
-export * from "./core/walletExecution.js";
-export * from "./hooks/useWalletConnect.js";
-export * from "./hooks/useAccount.js";
-export * from "./providers/base.js";
-export * from "./providers/plugin/injectedEvmProvider.js";
-export * from "./providers/plugin/injectedWalletRegistry.js";
-export * from "./providers/plugin/metamaskProvider.js";
-export * from "./providers/social/baseSocialProvider.js";
-export * from "./providers/social/cubeSignerAuth.js";
-export * from "./providers/social/cubistProvider.js";
+import EventEmitter from 'eventemitter3';
+import { CubeSignerClient, MemorySessionManager, envs, EvmSigner } from '@cubist-labs/cubesigner-sdk';
+
+// 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)
+});
+
+// src/core/capabilities.ts
+var SessionCapabilityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SessionCapabilityError";
+  }
+};
+var toBigIntAmount = (value) => {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") return BigInt(value);
+  return BigInt(value);
+};
+var 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
+});
+var isSessionExpired = (session, now = Date.now()) => Boolean(session?.expiresAt && session.expiresAt <= now);
+var isCapabilityPolicyExpired = (policy, now = Date.now()) => Boolean(policy?.expiresAt && policy.expiresAt <= now);
+var sessionSupportsCapability = (session, capability) => {
+  const capabilities = session?.capabilities;
+  if (!capabilities || capabilities.length === 0) return true;
+  return capabilities.includes(capability);
+};
+var 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;
+};
+var 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 !== void 0) {
+    if (toBigIntAmount(check.amount) > toBigIntAmount(policy.maxAmount)) {
+      throw new SessionCapabilityError("Requested amount exceeds the capability session limit");
+    }
+  }
+};
+
+// src/core/errors.ts
+var EVM_TRANSACTION_SIGNING_UNSUPPORTED = "EVM_TRANSACTION_SIGNING_UNSUPPORTED";
+var EvmTransactionSigningUnsupportedError = class 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";
+  }
+};
+var getErrorCode = (error) => {
+  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+  const { code } = error;
+  return typeof code === "number" || typeof code === "string" ? code : void 0;
+};
+var 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);
+};
+var 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"));
+};
+var 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));
+};
+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;
+  }
+  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 staleProvider = {
+  request() {
+    return Promise.reject(
+      new Error("Session restored from cache. Reconnect your wallet for transactions.")
+    );
+  },
+  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 };
+  }
+};
+var sessionStore = new SessionStore();
+
+// src/core/walletExecution.ts
+var requireSession = (session) => {
+  const resolvedSession = session ?? sessionStore.getState().session;
+  if (!resolvedSession) {
+    throw new Error("Wallet session missing");
+  }
+  return resolvedSession;
+};
+var performCapabilityCheck = (session, capability, check) => {
+  assertSessionCapability(session, {
+    capability,
+    chain: check?.chain ?? session.chainContext?.walletChain ?? session.chain,
+    token: check?.token,
+    amount: check?.amount,
+    appId: check?.appId,
+    origin: check?.origin,
+    now: check?.now
+  });
+};
+var getWalletExecutionCapabilities = (session) => requireSession(session).capabilities ?? [];
+var createWalletExecutionClient = (session) => {
+  const resolvedSession = requireSession(session);
+  return {
+    session: resolvedSession,
+    capabilities: resolvedSession.capabilities ?? [],
+    supports(capability) {
+      return this.capabilities.length === 0 || this.capabilities.includes(capability);
+    },
+    async sendTransaction(transaction, check) {
+      performCapabilityCheck(resolvedSession, "eth_sendTransaction", {
+        ...check,
+        amount: check?.amount ?? transaction.value
+      });
+      return resolvedSession.provider.request({
+        method: "eth_sendTransaction",
+        params: [{ ...transaction, from: transaction.from ?? resolvedSession.address }]
+      });
+    },
+    async signTransaction(transaction, check) {
+      performCapabilityCheck(resolvedSession, "eth_signTransaction", {
+        ...check,
+        amount: check?.amount ?? transaction.value
+      });
+      return resolvedSession.provider.request({
+        method: "eth_signTransaction",
+        params: [{ ...transaction, from: transaction.from ?? resolvedSession.address }]
+      });
+    },
+    async signMessage(message, check) {
+      performCapabilityCheck(resolvedSession, "personal_sign", check);
+      return resolvedSession.provider.request({
+        method: "personal_sign",
+        params: [message, resolvedSession.address]
+      });
+    },
+    async signTypedData(typedData, check) {
+      performCapabilityCheck(resolvedSession, "eth_signTypedData_v4", check);
+      return resolvedSession.provider.request({
+        method: "eth_signTypedData_v4",
+        params: [resolvedSession.address, JSON.stringify(typedData)]
+      });
+    }
+  };
+};
+var createWalletExecutionController = () => ({
+  get session() {
+    return sessionStore.getState().session;
+  },
+  get capabilities() {
+    return sessionStore.getState().session?.capabilities ?? [];
+  },
+  supports(capability) {
+    const session = requireSession();
+    return createWalletExecutionClient(session).supports(capability);
+  },
+  sendTransaction(transaction, check) {
+    return createWalletExecutionClient().sendTransaction(transaction, check);
+  },
+  signTransaction(transaction, check) {
+    return createWalletExecutionClient().signTransaction(transaction, check);
+  },
+  signMessage(message, check) {
+    return createWalletExecutionClient().signMessage(message, check);
+  },
+  signTypedData(typedData, check) {
+    return createWalletExecutionClient().signTypedData(typedData, check);
+  }
+});
+
+// src/core/walletConnector.ts
+var ADAPTER_STORAGE_KEY = "ab:wallet:adapterId";
+function getStorage2() {
+  try {
+    return typeof localStorage !== "undefined" ? localStorage : null;
+  } catch {
+    return null;
+  }
+}
+function persistAdapterId(adapterId) {
+  const storage = getStorage2();
+  if (!storage) return;
+  if (!adapterId) {
+    storage.removeItem(ADAPTER_STORAGE_KEY);
+  } else {
+    storage.setItem(ADAPTER_STORAGE_KEY, adapterId);
+  }
+}
+function readPersistedAdapterId() {
+  const storage = getStorage2();
+  if (!storage) return null;
+  return storage.getItem(ADAPTER_STORAGE_KEY);
+}
+var WalletConnector = class {
+  constructor(adapters) {
+    this.adapters = adapters;
+    this.currentAdapterId = null;
+    this.currentAdapterId = readPersistedAdapterId();
+  }
+  getAdapterById(adapterId) {
+    const adapter = this.adapters.find((item) => item.id === adapterId);
+    if (!adapter) throw new Error(`Wallet adapter ${adapterId} not registered`);
+    return adapter;
+  }
+  getCurrentAdapter(session = sessionStore.getState().session) {
+    return (this.currentAdapterId ? this.adapters.find((item) => item.id === this.currentAdapterId) : void 0) ?? this.adapters.find((item) => item.getProvider() === session?.provider);
+  }
+  clearActiveSession() {
+    this.currentAdapterId = null;
+    persistAdapterId(null);
+    sessionStore.clearSession();
+  }
+  requireActiveSession() {
+    const session = sessionStore.getState().session;
+    if (!session) {
+      throw new Error("Wallet session missing");
+    }
+    return session;
+  }
+  async connect(adapterId, args) {
+    const adapter = this.getAdapterById(adapterId);
+    const currentAdapter = this.getCurrentAdapter();
+    if (currentAdapter && currentAdapter.id !== adapter.id) {
+      await currentAdapter.disconnect();
+      this.clearActiveSession();
+    }
+    sessionStore.setConnecting(true);
+    try {
+      const session = await adapter.connect(args);
+      this.currentAdapterId = adapter.id;
+      persistAdapterId(adapter.id);
+      sessionStore.setSession(session);
+      sessionStore.setBalance(null);
+      return session;
+    } finally {
+      sessionStore.setConnecting(false);
+    }
+  }
+  async disconnect() {
+    const adapter = this.getCurrentAdapter();
+    if (!adapter) return;
+    await adapter?.disconnect();
+    this.clearActiveSession();
+  }
+  rehydrateSession(adapterId, session) {
+    this.currentAdapterId = adapterId;
+    persistAdapterId(adapterId);
+    sessionStore.rehydrateSession(session);
+    sessionStore.setBalance(null);
+    return session;
+  }
+  /**
+   * Attempt to silently reconnect a wallet whose session was rehydrated
+   * from localStorage. Uses the adapter's `reconnect()` if available,
+   * falling back to `connect()` for backward compatibility.
+   *
+   * Returns the restored session on success, or `null` if reconnection
+   * is not possible (e.g. wallet extension removed, social session expired).
+   */
+  async tryAutoReconnect() {
+    const state = sessionStore.getState();
+    if (!state.session) return null;
+    const adapterId = this.currentAdapterId ?? readPersistedAdapterId();
+    if (!adapterId) return null;
+    const adapter = this.adapters.find((a) => a.id === adapterId);
+    if (!adapter) return null;
+    sessionStore.setConnecting(true);
+    try {
+      const session = adapter.reconnect ? await adapter.reconnect(state.session) : null;
+      if (!session) return null;
+      this.currentAdapterId = adapterId;
+      persistAdapterId(adapterId);
+      sessionStore.rehydrateSession(session);
+      return session;
+    } catch {
+      return null;
+    } finally {
+      sessionStore.setConnecting(false);
+    }
+  }
+  supportsCapability(capability) {
+    const session = this.requireActiveSession();
+    return createWalletExecutionClient(session).supports(capability);
+  }
+  async requestCurrentProvider(payload) {
+    return this.requireActiveSession().provider.request(payload);
+  }
+  async sendEvmTransaction(transaction) {
+    const session = this.requireActiveSession();
+    return createWalletExecutionClient(session).sendTransaction(transaction);
+  }
+  async signEvmTransaction(transaction) {
+    const session = this.requireActiveSession();
+    return createWalletExecutionClient(session).signTransaction(transaction);
+  }
+  async signMessage(message) {
+    const session = this.requireActiveSession();
+    return createWalletExecutionClient(session).signMessage(message);
+  }
+  async signTypedData(typedData) {
+    const session = this.requireActiveSession();
+    return createWalletExecutionClient(session).signTypedData(typedData);
+  }
+};
+
+// src/hooks/useWalletConnect.ts
+var createWalletConnectController = ({
+  connector,
+  defaultAdapterId
+}) => {
+  return {
+    openModal: async (adapterId = defaultAdapterId, args) => {
+      if (!adapterId) throw new Error("No adapter id provided");
+      await connector.connect(adapterId, args);
+    },
+    disconnect: () => connector.disconnect(),
+    rehydrate: (adapterId, session) => connector.rehydrateSession(adapterId, session),
+    tryAutoReconnect: () => connector.tryAutoReconnect(),
+    supports(capability) {
+      if (!sessionStore.getState().session) return false;
+      return connector.supportsCapability(capability);
+    },
+    get isConnected() {
+      return Boolean(sessionStore.getState().session);
+    },
+    get isConnecting() {
+      return sessionStore.getState().isConnecting;
+    }
+  };
+};
+
+// src/hooks/useAccount.ts
+var createAccountController = () => {
+  return {
+    get session() {
+      return sessionStore.getState().session;
+    },
+    get address() {
+      return sessionStore.getState().session?.address ?? null;
+    },
+    get chain() {
+      return sessionStore.getState().session?.chain ?? null;
+    },
+    get balance() {
+      return sessionStore.getState().balance;
+    },
+    get isConnected() {
+      return Boolean(sessionStore.getState().session);
+    },
+    get currentProvider() {
+      return sessionStore.getState().session?.provider ?? null;
+    },
+    get chainContext() {
+      return sessionStore.getState().session?.chainContext ?? null;
+    },
+    get capabilities() {
+      return sessionStore.getState().session?.capabilities ?? [];
+    },
+    get capabilityPolicy() {
+      return sessionStore.getState().session?.capabilityPolicy ?? null;
+    }
+  };
+};
+
+// src/providers/base.ts
+var AbstractProvider = class {
+  constructor() {
+    this.currentSession = null;
+  }
+  async disconnect() {
+    this.clearSession();
+  }
+  setSession(session) {
+    this.currentSession = session;
+    return session;
+  }
+  clearSession() {
+    this.currentSession = null;
+  }
+  get session() {
+    return this.currentSession;
+  }
+  requireSession(message = `${this.title} session missing`) {
+    if (!this.currentSession) {
+      throw new Error(message);
+    }
+    return this.currentSession;
+  }
+  getProvider() {
+    return this.currentSession?.provider ?? null;
+  }
+  async reconnect(_persistedSession) {
+    return null;
+  }
+};
+
+// ../wallet-utils/dist/index.js
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var cache_exports = {};
+__export(cache_exports, {
+  clear: () => clear,
+  get: () => get,
+  remove: () => remove,
+  set: () => set,
+  setKeyNS: () => setKeyNS
+});
+var keyNS = "tomo-";
+function get(key) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const tempKey = keyNS + key;
+  if (!isKeyExist(tempKey)) {
+    return null;
+  }
+  let val = null;
+  try {
+    const data = window.localStorage.getItem(tempKey) || window.sessionStorage.getItem(tempKey);
+    val = JSON.parse(data);
+  } catch (err) {
+    console.error(err);
+  }
+  if (val !== null && Object.prototype.hasOwnProperty.call(val, "type") && Object.prototype.hasOwnProperty.call(val, "data")) {
+    return val["data"];
+  }
+  return null;
+}
+function set(key, val, isTemp) {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  let store;
+  if (isTemp) {
+    store = window.sessionStorage;
+  } else {
+    store = window.localStorage;
+  }
+  const data = JSON.stringify({
+    data: val,
+    time: (/* @__PURE__ */ new Date()).getTime(),
+    //for manage by time limit
+    type: typeof val
+  });
+  try {
+    store.setItem(keyNS + key, data);
+    return true;
+  } catch (err) {
+    if (err?.name?.toUpperCase().indexOf("QUOTA") >= 0) {
+      window.localStorage.clear();
+      store.setItem(keyNS + key, data);
+    }
+  }
+  return false;
+}
+function remove(key) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const tempKey = keyNS + key;
+  window.localStorage.removeItem(tempKey);
+  window.sessionStorage.removeItem(tempKey);
+}
+function clear() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window?.localStorage?.clear();
+  window?.sessionStorage?.clear();
+}
+function isKeyExist(key) {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(window.localStorage, key) || Object.prototype.hasOwnProperty.call(window.sessionStorage, key);
+}
+function setKeyNS(NS) {
+  const isString = typeof NS === "string";
+  if (isString && NS !== "") {
+    keyNS = NS;
+  }
+}
+function pick(...candidates) {
+  for (const c of candidates) {
+    if (c != null && c !== "") return c;
+  }
+  return void 0;
+}
+function nextPublicProcessEnvKey(logicalKey) {
+  return `NEXT_PUBLIC_${logicalKey}`;
+}
+function readProcessEnvStatic(key) {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  switch (key) {
+    case "STAGE":
+      return pick(
+        process.env.NEXT_PUBLIC_STAGE,
+        process.env.STAGE
+      );
+    case "FUNDING_CHAIN_ID":
+      return pick(
+        process.env.NEXT_PUBLIC_FUNDING_CHAIN_ID,
+        process.env.FUNDING_CHAIN_ID
+      );
+    /** Next.js 仅内联「静态」`process.env.NEXT_PUBLIC_*`；动态键名在客户端会为 undefined，必须逐键写出。 */
+    case "GOOGLE_CLIENT_ID":
+      return pick(
+        process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID,
+        process.env.GOOGLE_CLIENT_ID
+      );
+    case "X_CLIENT_ID":
+      return pick(
+        process.env.NEXT_PUBLIC_X_CLIENT_ID,
+        process.env.X_CLIENT_ID
+      );
+    case "MERCHANT_BASE_URL":
+      return pick(
+        process.env.NEXT_PUBLIC_MERCHANT_BASE_URL,
+        process.env.MERCHANT_BASE_URL
+      );
+    case "RELAY_ORIGIN":
+      return pick(
+        process.env.NEXT_PUBLIC_RELAY_ORIGIN,
+        process.env.RELAY_ORIGIN
+      );
+    case "CUBE_SIGNER_ENV":
+      return pick(
+        process.env.NEXT_PUBLIC_CUBE_SIGNER_ENV,
+        process.env.CUBE_SIGNER_ENV
+      );
+    case "CUBE_SIGNER_ORG_ID":
+      return pick(
+        process.env.NEXT_PUBLIC_CUBE_SIGNER_ORG_ID,
+        process.env.CUBE_SIGNER_ORG_ID
+      );
+    case "CUBE_REG":
+      return pick(
+        process.env.NEXT_PUBLIC_CUBE_REG,
+        process.env.CUBE_REG
+      );
+    case "FUNDING_TOKEN_SYMBOL":
+      return pick(
+        process.env.NEXT_PUBLIC_FUNDING_TOKEN_SYMBOL,
+        process.env.FUNDING_TOKEN_SYMBOL
+      );
+    case "FUNDING_TOKEN_ADDRESS":
+      return pick(
+        process.env.NEXT_PUBLIC_FUNDING_TOKEN_ADDRESS,
+        process.env.FUNDING_TOKEN_ADDRESS
+      );
+    default:
+      return pick(
+        process.env[`NEXT_PUBLIC_${key}`],
+        process.env[key]
+      );
+  }
+}
+function getEnv(key) {
+  const staticVal = readProcessEnvStatic(key);
+  if (staticVal != null && staticVal !== "") return staticVal;
+  const g = globalThis;
+  const env = g.process?.env;
+  if (env) {
+    const pub = nextPublicProcessEnvKey(key);
+    const v = env[key] ?? env[pub];
+    if (v != null && v !== "") return v;
+  }
+  try {
+    const m = import.meta.env;
+    if (m) {
+      const pub = nextPublicProcessEnvKey(key);
+      const v = m[key] ?? m[pub];
+      if (v != null && v !== "") return v;
+    }
+  } catch {
+  }
+  console.error(`${key} is not set.`);
+  return "";
+}
+var TENDERLY_BSC_3131 = {
+  chainId: "3131",
+  name: "BSC_TENDERLY",
+  chainName: "BSC_TENDERLY",
+  nativeCurrencyName: "BSC",
+  nativeCurrencySymbol: "BSC",
+  nativeCurrencyDecimals: 18,
+  rpcUrls: [
+    "https://virtual.binance.eu.rpc.tenderly.co/e643ea28-32eb-4fb9-8116-90be24f7defa"
+  ],
+  blockExplorerUrl: "https://dashboard.tenderly.co/explorer/vnet/6593bc72-f548-497d-bff9-5be061436a48",
+  platformType: "EVM",
+  icon: "https://static.tomo.inc/token/bsc_new.svg",
+  // Tenderly 默认资金侧合约地址（测试环境镜像）：
+  defaultFundingTokenAddress: "0x55d398326f99059fF775485246999027B3197955"
+};
+var BSC_MAINNET_56 = {
+  chainId: "56",
+  name: "BSC",
+  chainName: "BNB Smart Chain",
+  nativeCurrencyName: "BNB",
+  nativeCurrencySymbol: "BNB",
+  nativeCurrencyDecimals: 18,
+  rpcUrls: ["https://bsc-dataseed.binance.org", "https://bsc-dataseed1.defibit.io"],
+  blockExplorerUrl: "https://bscscan.com",
+  platformType: "EVM",
+  icon: "https://static.tomo.inc/token/bsc_new.svg",
+  // 主网默认资金侧合约地址（USDT）；如需覆盖请使用 FUNDING_TOKEN_ADDRESS 环境变量
+  defaultFundingTokenAddress: "0x55d398326f99059fF775485246999027B3197955"
+};
+var CHAIN_REGISTRY = {
+  [TENDERLY_BSC_3131.chainId]: TENDERLY_BSC_3131,
+  [BSC_MAINNET_56.chainId]: BSC_MAINNET_56
+};
+var DEFAULT_FUNDING_CHAIN_ID = getEnv("FUNDING_CHAIN_ID") || "3131";
+function normalizeFundingChainId(chainId) {
+  if (chainId === void 0 || chainId === null) return DEFAULT_FUNDING_CHAIN_ID;
+  const s = String(chainId).trim();
+  return s === "" ? DEFAULT_FUNDING_CHAIN_ID : s;
+}
+function getChainInfo(chainId) {
+  const id = normalizeFundingChainId(chainId);
+  const info = CHAIN_REGISTRY[id];
+  if (!info) {
+    throw new Error(
+      `Unsupported funding chainId "${id}". Supported: ${Object.keys(CHAIN_REGISTRY).sort().join(", ")}`
+    );
+  }
+  return info;
+}
+function pickEnvFundingTokenAddress() {
+  const tryPairs = [
+    ["NEXT_PUBLIC_FUNDING_TOKEN_ADDRESS", "FUNDING_TOKEN_ADDRESS"]
+  ];
+  if (typeof process !== "undefined" && process.env) {
+    for (const [pub, priv] of tryPairs) {
+      const a = process.env[pub];
+      const b = process.env[priv];
+      if (a != null && a !== "") return a;
+      if (b != null && b !== "") return b;
+    }
+  }
+  try {
+    const m = import.meta.env;
+    if (m) {
+      for (const [pub, priv] of tryPairs) {
+        const a = m[pub];
+        const b = m[priv];
+        if (a != null && a !== "") return a;
+        if (b != null && b !== "") return b;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getFundingTokenAddress(chainId) {
+  const v = pickEnvFundingTokenAddress();
+  if (v && /^0x[0-9a-fA-F]{40}$/.test(v)) return v;
+  return getChainInfo(chainId).defaultFundingTokenAddress;
+}
+getFundingTokenAddress(DEFAULT_FUNDING_CHAIN_ID);
+({
+  google: getEnv("GOOGLE_CLIENT_ID"),
+  x: getEnv("X_CLIENT_ID")
+});
+
+// src/providers/plugin/injectedEvmProvider.ts
+var injectedWalletCapabilities = [
+  "eth_accounts",
+  "eth_requestAccounts",
+  "eth_chainId",
+  "eth_signTransaction",
+  "eth_sendTransaction",
+  "personal_sign",
+  "eth_signTypedData_v4",
+  "wallet_disconnect",
+  "wallet_rehydrate"
+];
+function unwrapProvider(candidate) {
+  if (!candidate) return void 0;
+  if ("request" in candidate) return candidate;
+  return candidate.ethereum;
+}
+function collectCandidates() {
+  if (typeof window === "undefined") return [];
+  const providers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (candidate) => {
+    const provider = unwrapProvider(candidate);
+    if (!provider || seen.has(provider)) return;
+    seen.add(provider);
+    providers.push(provider);
+  };
+  push(window.ethereum);
+  window.ethereum?.providers?.forEach(push);
+  push(window.okxwallet);
+  push(window.coinbaseWalletExtension);
+  push(window.trustwallet);
+  push(window.phantom?.ethereum);
+  push(window.rabby);
+  push(window.bitkeep);
+  push(window.rainbow?.ethereum);
+  push(window.zerionWallet);
+  push(unwrapProvider(window.bitget));
+  return providers;
+}
+function discoverEIP6963Providers() {
+  if (typeof window === "undefined") return [];
+  const details = [];
+  const seen = /* @__PURE__ */ new Set();
+  const onAnnounce = (event) => {
+    const detail = event.detail;
+    if (!detail?.info?.uuid || !detail.provider) return;
+    if (seen.has(detail.info.uuid)) return;
+    seen.add(detail.info.uuid);
+    details.push(detail);
+  };
+  window.addEventListener("eip6963:announceProvider", onAnnounce);
+  window.dispatchEvent(new Event("eip6963:requestProviderInfo"));
+  window.removeEventListener("eip6963:announceProvider", onAnnounce);
+  return details;
+}
+function getWindow() {
+  return typeof window === "undefined" ? void 0 : window;
+}
+function getKnownNonMetaMaskProviders() {
+  const currentWindow = getWindow();
+  if (!currentWindow) return [];
+  const providers = [
+    unwrapProvider(currentWindow.okxwallet),
+    unwrapProvider(currentWindow.coinbaseWalletExtension),
+    unwrapProvider(currentWindow.trustwallet),
+    unwrapProvider(currentWindow.phantom?.ethereum),
+    unwrapProvider(currentWindow.rabby),
+    unwrapProvider(currentWindow.bitkeep),
+    unwrapProvider(currentWindow.rainbow?.ethereum),
+    currentWindow.zerionWallet,
+    unwrapProvider(currentWindow.bitget)
+  ];
+  return providers.filter((provider) => Boolean(provider));
+}
+function findInjectedProvider(predicate) {
+  return collectCandidates().find(predicate);
+}
+function findEIP6963Provider(predicate) {
+  return discoverEIP6963Providers().find(predicate)?.provider;
+}
+function isMetaMaskOnly(provider) {
+  const knownNonMetaMaskProviders = getKnownNonMetaMaskProviders();
+  return provider.isMetaMask === true && !knownNonMetaMaskProviders.includes(provider) && provider.isCoinbaseWallet !== true && provider.isPhantom !== true && provider.isRabby !== true && provider.isOkxWallet !== true && provider.isTrust !== true && provider.isTrustWallet !== true && provider.isBitKeep !== true && provider.isRainbow !== true && provider.isZerion !== true && provider.isBraveWallet !== true && provider.isBitget !== true;
+}
+function rdnsIncludes(info, value) {
+  return info.rdns.toLowerCase().includes(value.toLowerCase());
+}
+function nameIncludes(info, value) {
+  return info.name.toLowerCase().includes(value.toLowerCase());
+}
+var FALLBACK_FUNDING_CHAIN = getChainInfo();
+function evmChainInfoToWalletAddEthereumChainParams(info) {
+  const chainIdHex = `0x${BigInt(info.chainId).toString(16)}`;
+  return {
+    chainId: chainIdHex,
+    chainName: info.chainName,
+    nativeCurrency: {
+      name: info.nativeCurrencyName,
+      symbol: info.nativeCurrencySymbol,
+      decimals: info.nativeCurrencyDecimals
+    },
+    rpcUrls: [...info.rpcUrls],
+    blockExplorerUrls: [info.blockExplorerUrl]
+  };
+}
+var FALLBACK_FUNDING_CHAIN_ID_HEX = `0x${BigInt(FALLBACK_FUNDING_CHAIN.chainId).toString(16)}`;
+var FALLBACK_FUNDING_CHAIN_PARAMS = evmChainInfoToWalletAddEthereumChainParams(FALLBACK_FUNDING_CHAIN);
+async function switchToFallbackFundingChain(provider) {
+  const switchChain = () => provider.request({
+    method: "wallet_switchEthereumChain",
+    params: [{ chainId: FALLBACK_FUNDING_CHAIN_ID_HEX }]
+  });
+  try {
+    await switchChain();
+  } catch (err) {
+    const code = err?.code;
+    if (code === 4902) {
+      await provider.request({
+        method: "wallet_addEthereumChain",
+        params: [FALLBACK_FUNDING_CHAIN_PARAMS]
+      });
+      await switchChain();
+      return;
+    }
+    throw err;
+  }
+}
+function createInjectedWalletProvider(title, provider) {
+  return {
+    async request(payload) {
+      try {
+        return await provider.request(payload);
+      } catch (error) {
+        if (payload.method === "eth_signTransaction") {
+          throw normalizeEvmTransactionSigningError(title, error);
+        }
+        throw error;
+      }
+    },
+    async disconnect() {
+      await provider.disconnect();
+    }
+  };
+}
+var InjectedEvmProvider = class extends AbstractProvider {
+  constructor(config, injected) {
+    super();
+    this.config = config;
+    this.injected = injected;
+    this.category = "plugin";
+    this.id = config.id;
+    this.title = config.title;
+  }
+  isAvailable() {
+    return Boolean(this.injected ?? this.config.resolveProvider());
+  }
+  get client() {
+    const provider = this.injected ?? this.config.resolveProvider();
+    if (provider) return provider;
+    throw new Error(`${this.title} provider not available`);
+  }
+  async connect(_args) {
+    const provider = this.client;
+    const walletProvider = createInjectedWalletProvider(this.title, provider);
+    const [address] = await walletProvider.request({ method: "eth_requestAccounts" }) ?? [];
+    if (!address) {
+      throw new Error(`${this.title} did not return an account`);
+    }
+    await switchToFallbackFundingChain(provider);
+    const chainId = await walletProvider.request({ method: "eth_chainId" });
+    const chain = getSupportedChainFromEvmChainId(chainId);
+    const session = {
+      address,
+      chain,
+      provider: walletProvider,
+      walletType: "injected",
+      authSource: "wallet",
+      sessionId: `${this.id}:${address.toLowerCase()}`,
+      capabilities: injectedWalletCapabilities,
+      chainContext: createChainContext(chain)
+    };
+    return this.setSession(session);
+  }
+  async reconnect(_persistedSession) {
+    const provider = this.injected ?? this.config.resolveProvider();
+    if (!provider) return null;
+    const walletProvider = createInjectedWalletProvider(this.title, provider);
+    const accounts = await provider.request({
+      method: "eth_accounts",
+      params: []
+    });
+    const [address] = accounts ?? [];
+    if (!address) return null;
+    let chain;
+    try {
+      const chainId = await walletProvider.request({ method: "eth_chainId" });
+      chain = getSupportedChainFromEvmChainId(chainId);
+    } catch {
+      return null;
+    }
+    const session = {
+      address,
+      chain,
+      provider: walletProvider,
+      walletType: "injected",
+      authSource: "wallet",
+      sessionId: `${this.id}:${address.toLowerCase()}`,
+      capabilities: injectedWalletCapabilities,
+      chainContext: createChainContext(chain)
+    };
+    return this.setSession(session);
+  }
+};
+var MetaMaskProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "metamask",
+        title: "MetaMask",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "io.metamask") || nameIncludes(info, "metamask")
+        ) ?? findInjectedProvider(isMetaMaskOnly)
+      },
+      injected
+    );
+  }
+};
+var OKXProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "okx",
+        title: "OKX Wallet",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "okx") || nameIncludes(info, "okx")
+        ) ?? unwrapProvider(getWindow()?.okxwallet) ?? findInjectedProvider((provider) => provider.isOkxWallet === true)
+      },
+      injected
+    );
+  }
+};
+var CoinbaseWalletProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "coinbase",
+        title: "Coinbase Wallet",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "com.coinbase.wallet") || nameIncludes(info, "coinbase")
+        ) ?? unwrapProvider(getWindow()?.coinbaseWalletExtension) ?? findInjectedProvider((provider) => provider.isCoinbaseWallet === true)
+      },
+      injected
+    );
+  }
+};
+var TrustWalletProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "trust",
+        title: "Trust Wallet",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "trust") || nameIncludes(info, "trust")
+        ) ?? unwrapProvider(getWindow()?.trustwallet) ?? findInjectedProvider(
+          (provider) => provider.isTrust === true || provider.isTrustWallet === true
+        )
+      },
+      injected
+    );
+  }
+};
+var PhantomProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "phantom",
+        title: "Phantom",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "phantom") || nameIncludes(info, "phantom")
+        ) ?? unwrapProvider(getWindow()?.phantom?.ethereum) ?? findInjectedProvider((provider) => provider.isPhantom === true)
+      },
+      injected
+    );
+  }
+};
+var RabbyProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "rabby",
+        title: "Rabby",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "rabby") || nameIncludes(info, "rabby")
+        ) ?? unwrapProvider(getWindow()?.rabby) ?? findInjectedProvider((provider) => provider.isRabby === true)
+      },
+      injected
+    );
+  }
+};
+var RainbowProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "rainbow",
+        title: "Rainbow",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "rainbow") || nameIncludes(info, "rainbow")
+        ) ?? unwrapProvider(getWindow()?.rainbow?.ethereum) ?? findInjectedProvider((provider) => provider.isRainbow === true)
+      },
+      injected
+    );
+  }
+};
+var ZerionProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "zerion",
+        title: "Zerion",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "zerion") || nameIncludes(info, "zerion")
+        ) ?? getWindow()?.zerionWallet ?? findInjectedProvider((provider) => provider.isZerion === true)
+      },
+      injected
+    );
+  }
+};
+var BraveWalletProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "brave",
+        title: "Brave Wallet",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "brave") || nameIncludes(info, "brave")
+        ) ?? findInjectedProvider((provider) => provider.isBraveWallet === true)
+      },
+      injected
+    );
+  }
+};
+var BitgetProvider = class extends InjectedEvmProvider {
+  constructor(injected) {
+    super(
+      {
+        id: "bitget",
+        title: "Bitget",
+        resolveProvider: () => findEIP6963Provider(
+          ({ info }) => rdnsIncludes(info, "bitget") || nameIncludes(info, "bitget")
+        ) ?? unwrapProvider(getWindow()?.bitget) ?? findInjectedProvider((provider) => provider.isBitget === true)
+      },
+      injected
+    );
+  }
+};
+
+// src/providers/plugin/injectedWalletRegistry.ts
+var installUrls = {
+  metamask: "https://metamask.io/download/",
+  okx: "https://www.okx.com/web3",
+  coinbase: "https://www.coinbase.com/wallet/downloads",
+  trust: "https://trustwallet.com/browser-extension",
+  phantom: "https://phantom.com/download",
+  rabby: "https://rabby.io/",
+  rainbow: "https://rainbow.me/extension",
+  zerion: "https://zerion.io/extension",
+  brave: "https://brave.com/wallet/",
+  bitget: "https://web3.bitget.com/en/wallet-download"
+};
+function createDefaultInjectedWalletRegistry() {
+  const providers = [
+    new MetaMaskProvider(),
+    new OKXProvider(),
+    new CoinbaseWalletProvider(),
+    new TrustWalletProvider(),
+    new PhantomProvider(),
+    new RabbyProvider(),
+    new RainbowProvider(),
+    new ZerionProvider(),
+    new BraveWalletProvider(),
+    new BitgetProvider()
+  ];
+  return providers.map((provider) => ({
+    id: provider.id,
+    title: provider.title,
+    installUrl: installUrls[provider.id],
+    provider,
+    installed: provider.isAvailable()
+  }));
+}
+
+// src/providers/social/baseSocialProvider.ts
+var AbstractSocialProvider = class extends AbstractProvider {
+  constructor() {
+    super(...arguments);
+    this.category = "social";
+  }
+  async connect(args) {
+    await this.signIn(args?.options, args?.payload);
+    return this.requireSession();
+  }
+};
+function resolveEnv(env) {
+  return typeof env === "string" ? envs[env] : env;
+}
+var CubeSignerAuth = class {
+  constructor(config) {
+    this._client = null;
+    this._sessionData = null;
+    this.env = resolveEnv(config.env);
+    this.orgId = config.orgId;
+    this.scopes = config.scopes ?? ["sign:*", "manage:*"];
+    this.defaultSessionPolicy = config.defaultSessionPolicy;
+    this.oidcLoginHooks = config.oidcLoginHooks;
+  }
+  /** Currently authenticated client (null if not logged in). */
+  get client() {
+    return this._client;
+  }
+  get currentSession() {
+    if (!this._client || !this._sessionData) return null;
+    return {
+      client: this._client,
+      sessionData: this._sessionData
+    };
+  }
+  /* ── Google ───────────────────────────────── */
+  /**
+   * Login with a Google ID token (JWT).
+   * The token is used directly as the OIDC credential.
+   */
+  async loginWithGoogle(idToken) {
+    return this.authenticateWithOidcToken(idToken);
+  }
+  /* ── Twitter / X ──────────────────────────── */
+  /**
+   * Login with a Twitter OAuth 2.0 authorization code.
+   *
+   * 1. Exchange the code for an OIDC `id_token` via CubeSigner's
+   *    `/v0/org/{org_id}/oauth2/twitter` endpoint.
+   * 2. Create a CubeSigner session with that token.
+   */
+  async loginWithTwitter(params) {
+    const idToken = await this.exchangeTwitterCode(params);
+    return this.authenticateWithOidcToken(idToken);
+  }
+  /* ── Sign-out ─────────────────────────────── */
+  async signOut() {
+    if (this._client) {
+      try {
+        await this._client.revokeSession();
+      } catch {
+      }
+      this._client = null;
+      this._sessionData = null;
+    }
+  }
+  /* ── Session restore ────────────────────── */
+  /**
+   * Restore a CubeSigner session from previously persisted SessionData.
+   * Useful for reconnecting after page reload without re-authentication.
+   */
+  async restoreSession(sessionData) {
+    if (this._client) {
+      await this.signOut();
+    }
+    const client = await CubeSignerClient.create(
+      new MemorySessionManager(sessionData)
+    );
+    this._client = client;
+    this._sessionData = sessionData;
+    return { client, sessionData };
+  }
+  /* ── Private ──────────────────────────────── */
+  async authenticateWithOidcToken(oidcToken) {
+    if (this._client) {
+      await this.signOut();
+    }
+    const hooks = this.oidcLoginHooks;
+    if (hooks) {
+      const proof = await CubeSignerClient.proveOidcIdentity(
+        this.env,
+        this.orgId,
+        oidcToken
+      );
+      if (!proof.user_info?.initialized) {
+        await hooks.registerUser(oidcToken);
+      }
+    }
+    return this.createOidcSession(oidcToken);
+  }
+  /**
+   * Exchange a Twitter authorization code for an OIDC id_token
+   * via CubeSigner's dedicated endpoint.
+   *
+   * `POST {SignerApiRoot}/v0/org/{org_id}/oauth2/twitter`
+   */
+  async exchangeTwitterCode(params) {
+    const url = `${this.env.SignerApiRoot}/v0/org/${this.orgId}/oauth2/twitter`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        code: params.code,
+        code_verifier: params.codeVerifier,
+        redirect_uri: params.redirectUri
+      })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(
+        `Twitter code exchange failed (${res.status}): ${text}`
+      );
+    }
+    const data = await res.json();
+    if (!data.id_token) {
+      throw new Error("CubeSigner twitter exchange did not return id_token");
+    }
+    return data.id_token;
+  }
+  /**
+   * Create a CubeSigner OIDC session from a generic OIDC id_token.
+   */
+  async createOidcSession(oidcToken) {
+    const resp = await CubeSignerClient.createOidcSession(
+      this.env,
+      this.orgId,
+      oidcToken,
+      this.scopes
+    );
+    const sessionData = resp.data();
+    const client = await CubeSignerClient.create(
+      new MemorySessionManager(sessionData)
+    );
+    this._client = client;
+    this._sessionData = sessionData;
+    return { client, sessionData };
+  }
+};
+var evmChainIdMap = {
+  ETH: 1,
+  BSC: 56
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var toBigIntQuantity = (value) => {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw new Error(`Invalid EVM quantity number: ${value}`);
+    }
+    return BigInt(value);
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("EVM quantity cannot be empty");
+  }
+  if (/^0x[0-9a-fA-F]+$/.test(trimmed) || /^\d+$/.test(trimmed)) {
+    return BigInt(trimmed);
+  }
+  throw new Error(`Invalid EVM quantity string: ${value}`);
+};
+var toHexQuantity = (value) => {
+  if (value === void 0) return void 0;
+  return `0x${toBigIntQuantity(value).toString(16)}`;
+};
+var normalizeAccessList = (accessList) => {
+  if (!accessList) return void 0;
+  return accessList.map((item) => ({
+    address: item.address,
+    storageKeys: item.storageKeys
+  }));
+};
+var textEncoder = new TextEncoder();
+var resolveTransactionType = (transaction) => {
+  if (transaction.type !== void 0) {
+    const normalized = toHexQuantity(transaction.type);
+    if (normalized === "0x0" || normalized === "0x1" || normalized === "0x2") {
+      return normalized;
+    }
+    throw new Error(`Unsupported EVM transaction type for Cubist: ${normalized}`);
+  }
+  if (transaction.maxFeePerGas !== void 0 || transaction.maxPriorityFeePerGas !== void 0) {
+    return "0x2";
+  }
+  if (transaction.accessList?.length) {
+    return "0x1";
+  }
+  return "0x0";
+};
+var toCubistSignRequest = (address, chain, transaction) => {
+  const resolvedChainId = (transaction.chainId !== void 0 ? Number(toBigIntQuantity(transaction.chainId)) : void 0) ?? evmChainIdMap[chain];
+  if (!resolvedChainId) {
+    throw new Error("Cubist signing requires an EVM chainId");
+  }
+  const type = resolveTransactionType(transaction);
+  const commonFields = {
+    from: transaction.from ?? address,
+    to: transaction.to,
+    data: transaction.data,
+    gas: toHexQuantity(transaction.gas),
+    nonce: toHexQuantity(transaction.nonce),
+    value: toHexQuantity(transaction.value)
+  };
+  const accessList = normalizeAccessList(transaction.accessList);
+  const tx = type === "0x2" ? {
+    ...commonFields,
+    type,
+    ...accessList ? { accessList } : {},
+    maxFeePerGas: toHexQuantity(transaction.maxFeePerGas),
+    maxPriorityFeePerGas: toHexQuantity(transaction.maxPriorityFeePerGas)
+  } : type === "0x1" ? {
+    ...commonFields,
+    type,
+    ...accessList ? { accessList } : {},
+    gasPrice: toHexQuantity(transaction.gasPrice)
+  } : {
+    ...commonFields,
+    type,
+    gasPrice: toHexQuantity(transaction.gasPrice)
+  };
+  return {
+    chain_id: resolvedChainId,
+    tx
+  };
+};
+var getTransactionParam = (params) => {
+  const candidate = params?.[0];
+  if (!isRecord(candidate)) {
+    throw new Error("eth_signTransaction requires a transaction object");
+  }
+  return candidate;
+};
+var toHexBytes = (value) => {
+  if (/^0x[0-9a-fA-F]*$/.test(value)) return value;
+  return `0x${Array.from(textEncoder.encode(value)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+};
+var getMessageParam = (address, params) => {
+  const [first, second] = params ?? [];
+  if (typeof second === "string" && second.toLowerCase() === address.toLowerCase()) {
+    return String(first ?? "");
+  }
+  if (typeof first === "string" && first.toLowerCase() === address.toLowerCase()) {
+    return String(second ?? "");
+  }
+  return String(first ?? "");
+};
+var getTypedDataParam = (address, params) => {
+  const [first, second] = params ?? [];
+  if (typeof first === "string" && first.toLowerCase() === address.toLowerCase()) {
+    return typeof second === "string" ? JSON.parse(second) : second ?? {};
+  }
+  return typeof second === "string" ? JSON.parse(second) : second ?? first ?? {};
+};
+var createCubistEvmWalletProvider = ({
+  session,
+  address,
+  chain
+}) => {
+  const signer = new EvmSigner(address, session.client);
+  return {
+    async request(payload) {
+      switch (payload.method) {
+        case "eth_accounts":
+        case "eth_requestAccounts":
+          return [address];
+        case "eth_chainId": {
+          const chainId = evmChainIdMap[chain];
+          return `0x${chainId.toString(16)}`;
+        }
+        case "eth_signTransaction": {
+          const transaction = getTransactionParam(payload.params);
+          const signRequest = toCubistSignRequest(address, chain, transaction);
+          return await signer.signTransaction(signRequest);
+        }
+        case "personal_sign": {
+          const message = getMessageParam(address, payload.params);
+          return await signer.signEip191({
+            data: toHexBytes(message)
+          });
+        }
+        case "eth_signTypedData_v4": {
+          const typedData = getTypedDataParam(address, payload.params);
+          const domain = typedData.domain;
+          const chainId = domain?.chainId !== void 0 ? Number(toBigIntQuantity(domain.chainId)) : evmChainIdMap[chain];
+          if (!chainId) {
+            throw new Error("CubistProvider: typed data signing requires an EVM chainId");
+          }
+          return await signer.signEip712({
+            chain_id: chainId,
+            typed_data: typedData
+          });
+        }
+        default:
+          throw new Error(`CubistProvider: unsupported RPC method "${payload.method}"`);
+      }
+    },
+    async disconnect() {
+      await session.client.revokeSession();
+    }
+  };
+};
+
+// src/providers/social/cubistProvider.ts
+var defaultAdapter = {
+  async resolve(session) {
+    const keys = await session.client.sessionKeys();
+    const evmKey = keys.find((k) => k.cached.key_type === "SecpEthAddr");
+    if (!evmKey) throw new Error("No EVM key found in CubeSigner session");
+    const address = evmKey.materialId;
+    const chain = "ETH";
+    const provider = createCubistEvmWalletProvider({
+      session,
+      address,
+      chain
+    });
+    return {
+      address,
+      chain,
+      provider,
+      chainContext: createChainContext(chain)
+    };
+  }
+};
+var cubistCapabilities = [
+  "eth_accounts",
+  "eth_requestAccounts",
+  "eth_chainId",
+  "eth_signTransaction",
+  "personal_sign",
+  "eth_signTypedData_v4",
+  "wallet_disconnect",
+  "wallet_rehydrate"
+];
+var CubistSocialProvider = class extends AbstractSocialProvider {
+  constructor(config, adapter = defaultAdapter) {
+    super();
+    this.id = "cubist";
+    this.title = "Cubist Social Wallet";
+    this.lastCubeSignerSession = null;
+    /** Stash the login method so `connect()` can auto-retry. */
+    this.lastLogin = null;
+    this.auth = new CubeSignerAuth(config);
+    this.adapter = adapter;
+  }
+  async createWalletSession(method) {
+    const session = method.type === "google" ? await this.auth.loginWithGoogle(method.idToken) : await this.auth.loginWithTwitter(method.params);
+    this.lastCubeSignerSession = session;
+    const walletSession = await this.adapter.resolve(session);
+    const capabilityPolicy = this.auth.defaultSessionPolicy ? createSessionCapabilityPolicy(this.auth.defaultSessionPolicy) : void 0;
+    return {
+      ...walletSession,
+      walletType: "social",
+      authSource: method.type,
+      sessionId: `${method.type}:${walletSession.address.toLowerCase()}`,
+      expiresAt: capabilityPolicy?.expiresAt,
+      capabilities: cubistCapabilities,
+      sessionData: session.sessionData,
+      chainContext: walletSession.chainContext ?? createChainContext(walletSession.chain),
+      capabilityPolicy
+    };
+  }
+  async authenticate(method) {
+    const walletSession = await this.createWalletSession(method);
+    this.lastLogin = method;
+    this.setSession(walletSession);
+  }
+  getResolvedLoginMethod(payload) {
+    const method = payload ?? this.lastLogin;
+    if (!method) {
+      throw new Error(
+        "CubistSocialProvider.signIn requires a login method. Use signInWith(method) first."
+      );
+    }
+    return method;
+  }
+  /**
+   * Preferred explicit sign-in entrypoint.
+   */
+  async signInWith(method, _options) {
+    await this.authenticate(method);
+  }
+  /**
+   * Backward-compatible abstract implementation.
+   *
+   * - If `payload` is provided, it is treated as the login method.
+   * - Otherwise reuses the previously cached login method if available.
+   */
+  async signIn(_options, payload) {
+    await this.authenticate(this.getResolvedLoginMethod(payload));
+  }
+  /**
+   * Explicit connect flow that both authenticates and returns the wallet session.
+   */
+  async connectWith(method, options) {
+    return this.connect({ options, payload: method });
+  }
+  async connect(args) {
+    if (args?.payload !== void 0 || args?.options !== void 0) {
+      await this.signIn(args.options, args.payload);
+      return this.requireSession("Cubist session missing after sign-in");
+    }
+    if (this.session) {
+      return this.session;
+    }
+    if (!this.lastLogin) {
+      throw new Error("Cubist session missing \u2014 call signInWith(method) first");
+    }
+    await this.signIn();
+    return this.requireSession("Cubist session missing after sign-in");
+  }
+  async reconnect(persistedSession) {
+    if (!persistedSession.sessionData) return null;
+    try {
+      const csSession = await this.auth.restoreSession(
+        persistedSession.sessionData
+      );
+      this.lastCubeSignerSession = csSession;
+      const walletSession = await this.adapter.resolve(csSession);
+      return this.setSession({
+        ...walletSession,
+        walletType: persistedSession.walletType ?? "social",
+        authSource: persistedSession.authSource,
+        sessionId: persistedSession.sessionId,
+        expiresAt: persistedSession.expiresAt,
+        capabilities: cubistCapabilities,
+        sessionData: csSession.sessionData,
+        chainContext: walletSession.chainContext ?? createChainContext(walletSession.chain),
+        capabilityPolicy: persistedSession.capabilityPolicy
+      });
+    } catch {
+      return null;
+    }
+  }
+  async signOut() {
+    await this.auth.signOut();
+    this.clearSession();
+    this.lastLogin = null;
+    this.lastCubeSignerSession = null;
+  }
+  async disconnect() {
+    await this.signOut();
+  }
+  /** Direct access to the underlying CubeSignerAuth for advanced use-cases. */
+  get cubeSignerAuth() {
+    return this.auth;
+  }
+  get cubeSignerSession() {
+    return this.lastCubeSignerSession ?? this.auth.currentSession;
+  }
+};
+
+export { AbstractProvider, AbstractSocialProvider, BitgetProvider, BraveWalletProvider, CoinbaseWalletProvider, CubeSignerAuth, CubistSocialProvider, EVM_TRANSACTION_SIGNING_UNSUPPORTED, EvmTransactionSigningUnsupportedError, InjectedEvmProvider, MetaMaskProvider, OKXProvider, PhantomProvider, RabbyProvider, RainbowProvider, SessionCapabilityError, SessionStore, TrustWalletProvider, WalletConnector, ZerionProvider, assertSessionCapability, createAccountController, createChainContext, createDefaultInjectedWalletRegistry, createSessionCapabilityPolicy, createWalletConnectController, createWalletExecutionClient, createWalletExecutionController, describeSessionCapabilityPolicy, discoverEIP6963Providers, findEIP6963Provider, findInjectedProvider, getAllChainDescriptors, getChainDescriptor, getSupportedChainFromEvmChainId, getWalletExecutionCapabilities, isCapabilityPolicyExpired, isSessionExpired, isUnsupportedEvmTransactionSigningError, normalizeEvmTransactionSigningError, sessionStore, sessionSupportsCapability, switchToFallbackFundingChain };