@ant-design/web3-wagmi 0.0.0-alpha-20260209094036

package/dist/esm/wallets/okx-wallet.d.ts

@@ -0,0 +1,2 @@
+import type { EthereumWallet } from '../interface';
+export declare const OkxWallet: EthereumWallet;

package/dist/esm/wallets/okx-wallet.js

@@ -0,0 +1,11 @@
+import { metadata_OkxWallet } from '@ant-design/web3-assets';
+import { injected } from 'wagmi/connectors';
+import { UniversalWallet } from "./universal-wallet";
+export const OkxWallet = metadata => {
+  return new UniversalWallet({
+    ...metadata_OkxWallet,
+    ...metadata
+  }, () => injected({
+    target: 'okxWallet'
+  }));
+};

package/dist/esm/wallets/rainbow-wallet.d.ts

@@ -0,0 +1,2 @@
+import type { EthereumWallet } from '../interface';
+export declare const RainbowWallet: EthereumWallet;

package/dist/esm/wallets/rainbow-wallet.js

@@ -0,0 +1,11 @@
+import { metadata_RainbowWallet } from '@ant-design/web3-assets';
+import { injected } from 'wagmi/connectors';
+import { UniversalWallet } from "./universal-wallet";
+export const RainbowWallet = metadata => {
+  return new UniversalWallet({
+    ...metadata_RainbowWallet,
+    ...metadata
+  }, () => injected({
+    target: 'rainbow'
+  }));
+};

package/dist/esm/wallets/safeheron.d.ts

@@ -0,0 +1,2 @@
+import type { EthereumWallet } from '../interface';
+export declare const SafeheronWallet: EthereumWallet;

package/dist/esm/wallets/safeheron.js

@@ -0,0 +1,19 @@
+/* v8 ignore start */
+import { metadata_Safeheron } from '@ant-design/web3-assets';
+export const SafeheronWallet = metadata => {
+  return {
+    connectors: ['Safeheron'],
+    create: connectors => {
+      return {
+        ...metadata_Safeheron,
+        hasWalletReady: async () => {
+          return !!(await connectors?.[0]?.getProvider());
+        },
+        hasExtensionInstalled: async () => {
+          return !!(await connectors?.[0]?.getProvider());
+        },
+        ...metadata
+      };
+    }
+  };
+};

package/dist/esm/wallets/token-pocket.d.ts

@@ -0,0 +1,2 @@
+import type { EthereumWallet } from '../interface';
+export declare const TokenPocket: EthereumWallet;

package/dist/esm/wallets/token-pocket.js

@@ -0,0 +1,13 @@
+import { metadata_TokenPocket } from '@ant-design/web3-assets';
+import { injected } from 'wagmi/connectors';
+import { UniversalWallet } from "./universal-wallet";
+export const TokenPocket = metadata => {
+  return new UniversalWallet({
+    ...metadata_TokenPocket,
+    ...metadata
+  }, () => {
+    return injected({
+      target: 'tokenPocket'
+    });
+  });
+};

package/dist/esm/wallets/universal-wallet.d.ts

@@ -0,0 +1,11 @@
+import type { WalletMetadata } from '@ant-design/web3-common';
+import type { Connector, CreateConnectorFn } from 'wagmi';
+import type { CreateWalletOptions, WalletFactory, WalletUseInWagmiAdapter } from '../interface';
+export declare class UniversalWallet implements WalletFactory {
+    private wallet;
+    name?: string;
+    createWagmiConnector?: () => CreateConnectorFn;
+    connectors: string[];
+    constructor(wallet: WalletMetadata, createWagmiConnector?: () => CreateConnectorFn);
+    create: (connectors?: readonly Connector[], options?: CreateWalletOptions) => WalletUseInWagmiAdapter;
+}

package/dist/esm/wallets/universal-wallet.js

@@ -0,0 +1,66 @@
+export class UniversalWallet {
+  name;
+  createWagmiConnector;
+  connectors = [];
+  constructor(wallet, createWagmiConnector) {
+    this.wallet = wallet;
+    this.name = wallet.name;
+    this.createWagmiConnector = createWagmiConnector;
+    if (wallet.extensions) {
+      // support injected connector
+      // https://wagmi.sh/react/connectors/injected
+      this.connectors.push(wallet.name);
+    }
+    if (wallet.app) {
+      // support WalletConnect https://wagmi.sh/react/connectors/walletConnect
+      this.connectors.push('WalletConnect');
+    }
+  }
+  create = (connectors, options) => {
+    const walletConnector = connectors?.find(item => item.name === 'WalletConnect');
+    const injectedConnector = connectors?.find(item => item.name === this.wallet.name);
+    let qrCodeUri = undefined;
+    const getQrCode = async () => {
+      const provider = await walletConnector?.getProvider();
+      return new Promise(resolve => {
+        if (qrCodeUri) {
+          resolve({
+            uri: qrCodeUri
+          });
+          return;
+        }
+        provider?.on('display_uri', uri => {
+          qrCodeUri = uri;
+          resolve({
+            uri
+          });
+        });
+      });
+    };
+    const hasExtensionInstalled = async () => {
+      const provider = await injectedConnector?.getProvider?.();
+      return !!provider;
+    };
+    return {
+      ...this.wallet,
+      getWagmiConnector: async connectOptions => {
+        if (connectOptions?.connectType === 'qrCode') {
+          return walletConnector;
+        }
+        if (await hasExtensionInstalled()) {
+          return injectedConnector;
+        }
+        return walletConnector;
+      },
+      hasExtensionInstalled: async () => {
+        return hasExtensionInstalled();
+      },
+      hasWalletReady: async () => {
+        const installed = await hasExtensionInstalled();
+        return !!(installed || walletConnector);
+      },
+      customQrCodePanel: options?.useWalletConnectOfficialModal,
+      getQrCode: walletConnector ? getQrCode : undefined
+    };
+  };
+}

package/dist/esm/wallets/wallet-connect.d.ts

@@ -0,0 +1,6 @@
+import type { WalletMetadata } from '@ant-design/web3-common';
+import type { WalletFactory } from '../interface';
+export type EthereumWalletConnect = (metadata?: Partial<WalletMetadata> & {
+    useWalletConnectOfficialModal?: boolean;
+}) => WalletFactory;
+export declare const WalletConnect: EthereumWalletConnect;

package/dist/esm/wallets/wallet-connect.js

@@ -0,0 +1,42 @@
+import { metadata_WalletConnect } from '@ant-design/web3-assets';
+export const WalletConnect = metadata => {
+  const {
+    useWalletConnectOfficialModal = false,
+    ...rest
+  } = metadata || {};
+  return {
+    connectors: ['WalletConnect'],
+    create: (connectors, options = {}) => {
+      let qrCodeUri = undefined;
+      const getQrCode = async () => {
+        const provider = await connectors?.[0]?.getProvider();
+        return new Promise(resolve => {
+          if (qrCodeUri) {
+            resolve({
+              uri: qrCodeUri
+            });
+            return;
+          }
+          provider?.on('display_uri', uri => {
+            qrCodeUri = uri;
+            resolve({
+              uri
+            });
+          });
+        });
+      };
+      return {
+        ...metadata_WalletConnect,
+        getWagmiConnector: async () => {
+          return connectors?.[0];
+        },
+        hasWalletReady: async () => {
+          return true;
+        },
+        getQrCode: getQrCode,
+        customQrCodePanel: useWalletConnectOfficialModal || options.useWalletConnectOfficialModal,
+        ...rest
+      };
+    }
+  };
+};

package/dist/lib/chains.d.ts

@@ -0,0 +1,16 @@
+import type { ChainAssetWithWagmiChain } from './interface';
+export declare const Mainnet: ChainAssetWithWagmiChain;
+export declare const Goerli: ChainAssetWithWagmiChain;
+export declare const Sepolia: ChainAssetWithWagmiChain;
+export declare const Holesky: ChainAssetWithWagmiChain;
+export declare const Polygon: ChainAssetWithWagmiChain;
+export declare const BSC: ChainAssetWithWagmiChain;
+export declare const Arbitrum: ChainAssetWithWagmiChain;
+export declare const Optimism: ChainAssetWithWagmiChain;
+export declare const Avalanche: ChainAssetWithWagmiChain;
+export declare const Base: ChainAssetWithWagmiChain;
+export declare const X1Testnet: ChainAssetWithWagmiChain;
+export declare const Scroll: ChainAssetWithWagmiChain;
+export declare const ScrollSepolia: ChainAssetWithWagmiChain;
+export declare const Hardhat: ChainAssetWithWagmiChain;
+export declare const Localhost: ChainAssetWithWagmiChain;

package/dist/lib/chains.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.X1Testnet = exports.Sepolia = exports.ScrollSepolia = exports.Scroll = exports.Polygon = exports.Optimism = exports.Mainnet = exports.Localhost = exports.Holesky = exports.Hardhat = exports.Goerli = exports.Base = exports.BSC = exports.Avalanche = exports.Arbitrum = void 0;
+var _web3Assets = require("@ant-design/web3-assets");
+var _chains = require("wagmi/chains");
+const Mainnet = exports.Mainnet = {
+  ..._web3Assets.Mainnet,
+  wagmiChain: _chains.mainnet
+};
+const Goerli = exports.Goerli = {
+  ..._web3Assets.Goerli,
+  wagmiChain: _chains.goerli
+};
+const Sepolia = exports.Sepolia = {
+  ..._web3Assets.Sepolia,
+  wagmiChain: _chains.sepolia
+};
+const Holesky = exports.Holesky = {
+  ..._web3Assets.Holesky,
+  wagmiChain: _chains.holesky
+};
+const Polygon = exports.Polygon = {
+  ..._web3Assets.Polygon,
+  wagmiChain: _chains.polygon
+};
+const BSC = exports.BSC = {
+  ..._web3Assets.BSC,
+  wagmiChain: _chains.bsc
+};
+const Arbitrum = exports.Arbitrum = {
+  ..._web3Assets.Arbitrum,
+  wagmiChain: _chains.arbitrum
+};
+const Optimism = exports.Optimism = {
+  ..._web3Assets.Optimism,
+  wagmiChain: _chains.optimism
+};
+const Avalanche = exports.Avalanche = {
+  ..._web3Assets.Avalanche,
+  wagmiChain: _chains.avalanche
+};
+const Base = exports.Base = {
+  ..._web3Assets.Base,
+  wagmiChain: _chains.base
+};
+
+// OKX X1: https://www.okx.com/cn/x1/docs/developer/build-on-x1/quickstart
+const X1Testnet = exports.X1Testnet = {
+  ..._web3Assets.X1Testnet,
+  wagmiChain: {
+    id: _web3Assets.X1Testnet.id,
+    name: _web3Assets.X1Testnet.name,
+    nativeCurrency: {
+      name: 'OKB',
+      symbol: 'OKB',
+      decimals: 18
+    },
+    rpcUrls: {
+      default: {
+        http: ['https://testrpc.x1.tech']
+      }
+    },
+    blockExplorers: {
+      default: {
+        name: 'X1TestnetScan',
+        url: 'https://www.okx.com/explorer/x1-test'
+      }
+    }
+  }
+};
+const Scroll = exports.Scroll = {
+  ..._web3Assets.Scroll,
+  wagmiChain: _chains.scroll
+};
+const ScrollSepolia = exports.ScrollSepolia = {
+  ..._web3Assets.ScrollSepolia,
+  wagmiChain: _chains.scrollSepolia
+};
+const Hardhat = exports.Hardhat = {
+  ..._web3Assets.Hardhat,
+  wagmiChain: _chains.hardhat
+};
+const Localhost = exports.Localhost = {
+  ..._web3Assets.Localhost,
+  wagmiChain: _chains.localhost
+};

package/dist/lib/global.d.ts

@@ -0,0 +1,3 @@
+declare interface Window {
+  ethereum?: any;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './wagmi-provider';
+export * from './wallets';
+export * from './interface';
+export * from './chains';
+export * from '@ant-design/web3-assets/tokens';
+export * from '@ant-design/web3-assets/wallets';

package/dist/lib/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _wagmiProvider = require("./wagmi-provider");
+Object.keys(_wagmiProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _wagmiProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _wagmiProvider[key];
+    }
+  });
+});
+var _wallets = require("./wallets");
+Object.keys(_wallets).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _wallets[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _wallets[key];
+    }
+  });
+});
+var _interface = require("./interface");
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _interface[key];
+    }
+  });
+});
+var _chains = require("./chains");
+Object.keys(_chains).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _chains[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _chains[key];
+    }
+  });
+});
+var _tokens = require("@ant-design/web3-assets/tokens");
+Object.keys(_tokens).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _tokens[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _tokens[key];
+    }
+  });
+});
+var _wallets2 = require("@ant-design/web3-assets/wallets");
+Object.keys(_wallets2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _wallets2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _wallets2[key];
+    }
+  });
+});

package/dist/lib/interface.d.ts

@@ -0,0 +1,26 @@
+import type { Chain, ConnectOptions, UniversalEIP6963Config, Wallet, WalletMetadata } from '@ant-design/web3-common';
+import type { Chain as WagmiChain } from 'viem';
+import type { CreateSiweMessageParameters } from 'viem/siwe';
+import type { Connector, CreateConnectorFn } from 'wagmi';
+export interface WalletUseInWagmiAdapter extends Wallet {
+    getWagmiConnector?: (options?: ConnectOptions) => Promise<Connector | undefined>;
+}
+export type EthereumWallet = (metadata?: Partial<WalletMetadata>) => WalletFactory;
+export interface CreateWalletOptions {
+    useWalletConnectOfficialModal?: boolean;
+}
+export interface WalletFactory {
+    name?: string;
+    connectors: Connector['name'][];
+    create: (connector?: readonly Connector[], options?: CreateWalletOptions) => WalletUseInWagmiAdapter;
+    createWagmiConnector?: () => CreateConnectorFn;
+}
+export type EIP6963Config = boolean | UniversalEIP6963Config;
+export type ChainAssetWithWagmiChain = Chain & {
+    wagmiChain?: WagmiChain;
+};
+export interface SIWEConfig {
+    getNonce: (address: string, chainId?: number) => Promise<string>;
+    createMessage: (args: CreateSiweMessageParameters) => string;
+    verifyMessage: (message: string, signature: string) => Promise<boolean>;
+}

package/dist/lib/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Connector as WagmiConnector } from 'wagmi';
+declare const isEIP6963Connector: (connector: WagmiConnector) => boolean;
+export { isEIP6963Connector };

package/dist/lib/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEIP6963Connector = void 0;
+var _connectors = require("wagmi/connectors");
+const isEIP6963Connector = connector => {
+  if (connector.type === _connectors.injected.type && connector.icon && connector.id && connector.name) {
+    return true;
+  }
+  return false;
+};
+exports.isEIP6963Connector = isEIP6963Connector;

package/dist/lib/wagmi-provider/__mocks__/wagmiBaseMock.d.ts

@@ -0,0 +1,76 @@
+export declare const wagmiBaseMock: {
+    useAccount: () => {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://etherscan.io";
+                    readonly apiUrl: "https://api.etherscan.io/api";
+                };
+            };
+            blockTime?: number | undefined;
+            contracts: {
+                readonly ensRegistry: {
+                    readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+                };
+                readonly ensUniversalResolver: {
+                    readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+                    readonly blockCreated: 19258213;
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14353601;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 1;
+            name: "Ethereum";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://eth.merkle.io"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet?: boolean | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+        };
+        address: string;
+        connector: {
+            name: string;
+        };
+    };
+    useConfig: () => {};
+    useBalance: () => {
+        data: {};
+    };
+    useSwitchChain: () => {
+        switchChain: () => void;
+    };
+    useConnect: () => {
+        connectors: {
+            name: string;
+        }[];
+        connectAsync: () => Promise<{}>;
+    };
+    useDisconnect: () => {
+        disconnectAsync: () => void;
+    };
+    useEnsName: () => {
+        data: null;
+    };
+    useEnsAvatar: () => {
+        data: null;
+    };
+    useSignMessage: () => {
+        signMessageAsync: () => Promise<string>;
+    };
+};

package/dist/lib/wagmi-provider/__mocks__/wagmiBaseMock.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wagmiBaseMock = void 0;
+var _chains = require("wagmi/chains");
+const mockConnector = {
+  name: 'MetaMask'
+};
+const wagmiBaseMock = exports.wagmiBaseMock = {
+  useAccount: () => {
+    return {
+      chain: _chains.mainnet,
+      address: '0x21CDf0974d53a6e96eF05d7B324a9803735fFd3B',
+      connector: mockConnector
+    };
+  },
+  useConfig: () => ({}),
+  useBalance: () => ({
+    data: {}
+  }),
+  useSwitchChain: () => ({
+    switchChain: () => {}
+  }),
+  useConnect: () => ({
+    connectors: [mockConnector],
+    connectAsync: async () => ({})
+  }),
+  useDisconnect: () => ({
+    disconnectAsync: () => {}
+  }),
+  useEnsName: () => ({
+    data: null
+  }),
+  useEnsAvatar: () => ({
+    data: null
+  }),
+  useSignMessage: () => ({
+    signMessageAsync: async () => 'signMessage'
+  })
+};

package/dist/lib/wagmi-provider/config-provider.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { type Chain, type Locale } from '@ant-design/web3-common';
+import type { Config as WagmiConfig } from 'wagmi';
+import type { EIP6963Config, SIWEConfig, WalletFactory } from '../interface';
+export interface AntDesignWeb3ConfigProviderProps {
+    chainAssets: Chain[];
+    walletFactories: WalletFactory[];
+    locale?: Locale;
+    children?: React.ReactNode;
+    ens?: boolean;
+    balance?: boolean;
+    eip6963?: EIP6963Config;
+    wagimConfig: WagmiConfig;
+    useWalletConnectOfficialModal?: boolean;
+    siwe?: SIWEConfig;
+    /**
+     * If true, this provider's configuration will be ignored when merging with parent context.
+     * This is useful when you have multiple chain providers and want to switch between them
+     * without causing page flickering. Only the active provider should not have this flag set.
+     */
+    ignoreConfig?: boolean;
+}
+export declare const AntDesignWeb3ConfigProvider: React.FC<AntDesignWeb3ConfigProviderProps>;