@particle-network/connectkit/dist/esm/chunk-X46QBYVB.mjs

"use client";
import {
  init_context,
  init_useAAPlugin,
  init_useAccount,
  init_useModalError,
  init_useMutation,
  useAAPlugin,
  useAccount,
  useContext,
  useModalError,
  useMutation
} from "./chunk-ODGVUXUQ.mjs";
import {
  __esm
} from "./chunk-Y7A564BU.mjs";

// src/actions/disconnect.ts
async function disconnect(config, parameters = {}) {
  let connectors;
  if (parameters.connector) {
    connectors = [parameters.connector];
  } else {
    const connections2 = [...config.state.connections.values()];
    connectors = connections2.map((connection) => connection.connector);
  }
  const connections = config.state.connections;
  if (connectors && connectors.length) {
    for (const connector of connectors) {
      await connector.disconnect();
      connector.emitter.off("change", config._internal.events.change);
      connector.emitter.off("disconnect", config._internal.events.disconnect);
      connector.emitter.on("connect", config._internal.events.connect);
      connections.delete(connector.uid);
    }
  }
  config.setState((x) => {
    if (connections.size === 0)
      return {
        ...x,
        connections: /* @__PURE__ */ new Map(),
        current: null,
        status: "disconnected"
      };
    const nextConnection = connections.values().next().value;
    return {
      ...x,
      connections: new Map(connections),
      current: nextConnection.connector.uid
    };
  });
  {
    const current = config.state.current;
    if (!current)
      return;
    const connector = config.state.connections.get(current)?.connector;
    if (!connector)
      return;
    await config.storage?.setItem("recentConnectorId", connector.id);
  }
}
var init_disconnect = __esm({
  "src/actions/disconnect.ts"() {
    "use strict";
  }
});

// src/hooks/useDisconnect.ts
import { useCallback } from "react";
function useDisconnect(parameters) {
  const { config } = useContext();
  const mutationFn = useCallback(async (parameters2) => {
    await disconnect(config, parameters2 ?? void 0);
  }, []);
  const { status, data, error, mutate, mutateAsync } = useMutation(mutationFn, parameters);
  return {
    status,
    data,
    error,
    disconnect: mutate,
    disconnectAsync: mutateAsync
  };
}
var init_useDisconnect = __esm({
  "src/hooks/useDisconnect.ts"() {
    "use strict";
    init_disconnect();
    init_context();
    init_useMutation();
  }
});

// src/hooks/useSmartAccount.ts
var useSmartAccount;
var init_useSmartAccount = __esm({
  "src/hooks/useSmartAccount.ts"() {
    "use strict";
    init_useAAPlugin();
    useSmartAccount = () => {
      const smartAccount = useAAPlugin((state) => state.smartAccount);
      return smartAccount;
    };
  }
});

// src/hooks/useAddress.ts
import { useEffect, useState } from "react";
import { checksumAddress } from "viem";
var useAddress;
var init_useAddress = __esm({
  "src/hooks/useAddress.ts"() {
    "use strict";
    init_useAccount();
    init_useDisconnect();
    init_useModalError();
    init_useSmartAccount();
    useAddress = () => {
      const { address: eoaAddress, chain } = useAccount();
      const smartAccount = useSmartAccount();
      const { disconnect: disconnect2 } = useDisconnect();
      const { showError } = useModalError();
      const [address, setAddress] = useState();
      useEffect(() => {
        if (smartAccount && eoaAddress && eoaAddress.startsWith("0x")) {
          setAddress(void 0);
          if (chain) {
            smartAccount.getAddress().then((result) => {
              if (smartAccount) {
                if (result) {
                  setAddress(checksumAddress(result));
                } else {
                  setAddress(void 0);
                }
              } else {
                if (eoaAddress === "0x0000000000000000000000000000000000000000") {
                  setAddress(void 0);
                } else {
                  setAddress(eoaAddress);
                }
              }
            }).catch((error) => {
              disconnect2();
              setTimeout(() => showError(error.message), 10);
            });
          } else {
            setAddress(void 0);
          }
        } else {
          if (eoaAddress === "0x0000000000000000000000000000000000000000") {
            setAddress(void 0);
          } else {
            setAddress(eoaAddress);
          }
        }
      }, [eoaAddress, smartAccount, disconnect2, chain]);
      return address;
    };
  }
});

export {
  useDisconnect,
  init_useDisconnect,
  useSmartAccount,
  init_useSmartAccount,
  useAddress,
  init_useAddress
};
//# sourceMappingURL=chunk-X46QBYVB.mjs.map