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

package/dist/index.js

@@ -1,16 +1,1119 @@
-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 { AbstractProvider, getSupportedChainFromEvmChainId, createChainContext, assertSessionCapability } from './chunk-MVZIAM4H.js';
+export { AbstractProvider, AbstractSocialProvider, CubistSocialProvider, SessionCapabilityError, assertSessionCapability, createChainContext, createSessionCapabilityPolicy, describeSessionCapabilityPolicy, getAllChainDescriptors, getChainDescriptor, getSupportedChainFromEvmChainId, isCapabilityPolicyExpired, isSessionExpired, sessionSupportsCapability } from './chunk-MVZIAM4H.js';
+export { CubeSignerAuth } from './chunk-5HURLKIK.js';
+import EventEmitter from 'eventemitter3';
+
+// 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;
+    }
+  };
+};
+
+// ../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 {
+  }
+  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")
+});
+new TextEncoder();
+
+// 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()
+  }));
+}
+
+export { BitgetProvider, BraveWalletProvider, CoinbaseWalletProvider, EVM_TRANSACTION_SIGNING_UNSUPPORTED, EvmTransactionSigningUnsupportedError, InjectedEvmProvider, MetaMaskProvider, OKXProvider, PhantomProvider, RabbyProvider, RainbowProvider, SessionStore, TrustWalletProvider, WalletConnector, ZerionProvider, createAccountController, createDefaultInjectedWalletRegistry, createWalletConnectController, createWalletExecutionClient, createWalletExecutionController, discoverEIP6963Providers, findEIP6963Provider, findInjectedProvider, getWalletExecutionCapabilities, isUnsupportedEvmTransactionSigningError, normalizeEvmTransactionSigningError, sessionStore, switchToFallbackFundingChain };