@sky-mavis/tanto-connect 0.0.1-alpha.0

package/dist/index.js

@@ -0,0 +1,799 @@
+import {EthereumProvider}from'@walletconnect/ethereum-provider';import {SafeAppProvider}from'@safe-global/safe-apps-provider';import SafeAppsSDK from'@safe-global/safe-apps-sdk';import {WaypointProvider}from'@sky-mavis/waypoint';import {EventEmitter}from'events';var ChainIds;
+(function (ChainIds) {
+    ChainIds[ChainIds["Ethereum"] = 1] = "Ethereum";
+    ChainIds[ChainIds["Goerli"] = 5] = "Goerli";
+    ChainIds[ChainIds["RoninMainet"] = 2020] = "RoninMainet";
+    ChainIds[ChainIds["RoninTestnet"] = 2021] = "RoninTestnet";
+})(ChainIds || (ChainIds = {}));
+const CHAINS_CONFIG = {
+    [ChainIds.RoninMainet]: {
+        chainId: ChainIds.RoninMainet,
+        blockExplorerUrl: 'https://app.roninchain.com',
+        chainName: 'Ronin Mainnet',
+        iconUrl: 'https://cdn.skymavis.com/explorer-cdn/asset/favicon/apple-touch-icon.png',
+        nativeCurrency: {
+            name: 'Ronin',
+            symbol: 'RON',
+            decimals: 18,
+        },
+    },
+    [ChainIds.RoninTestnet]: {
+        chainId: ChainIds.RoninTestnet,
+        blockExplorerUrl: 'https://saigon-app.roninchain.com',
+        chainName: 'Saigon Testnet',
+        iconUrl: 'https://cdn.skymavis.com/explorer-cdn/asset/favicon/apple-touch-icon.png',
+        nativeCurrency: {
+            name: 'tRonin',
+            symbol: 'tRON',
+            decimals: 18,
+        },
+    },
+    [ChainIds.Ethereum]: {
+        chainId: ChainIds.Ethereum,
+        blockExplorerUrl: 'https://etherscan.io',
+        chainName: 'Ethereum',
+        nativeCurrency: {
+            name: 'Ethereum',
+            symbol: 'ETH',
+            decimals: 18,
+        },
+    },
+    [ChainIds.Goerli]: {
+        chainId: ChainIds.Goerli,
+        blockExplorerUrl: 'https://goerli.etherscan.io/',
+        chainName: 'Goerli',
+        nativeCurrency: {
+            name: 'GoerliETH',
+            symbol: 'GTH',
+            decimals: 18,
+        },
+    },
+};var SupportedConnectors;
+(function (SupportedConnectors) {
+    SupportedConnectors["RONIN_WALLET"] = "RONIN_WALLET";
+    SupportedConnectors["RONIN_WC"] = "RONIN_WC";
+    SupportedConnectors["INJECTED"] = "INJECTED";
+    SupportedConnectors["WAYPOINT"] = "WAYPOINT";
+    SupportedConnectors["SAFE"] = "SAFE";
+    SupportedConnectors["COINBASE_WALLET"] = "COINBASE_WALLET";
+})(SupportedConnectors || (SupportedConnectors = {}));
+var ConnectorType;
+(function (ConnectorType) {
+    ConnectorType["WALLET"] = "WALLET";
+    ConnectorType["MULTISIG"] = "MULTISIG";
+    ConnectorType["MPC"] = "MPC";
+    ConnectorType["WC"] = "WC";
+})(ConnectorType || (ConnectorType = {}));
+const DEFAULT_CONNECTORS_CONFIG = {
+    [SupportedConnectors.RONIN_WALLET]: {
+        name: 'Ronin Wallet',
+        id: SupportedConnectors.RONIN_WALLET,
+        type: ConnectorType.WALLET,
+    },
+    [SupportedConnectors.RONIN_WC]: {
+        name: 'Ronin Mobile',
+        id: SupportedConnectors.RONIN_WC,
+        type: ConnectorType.WC,
+    },
+    [SupportedConnectors.WAYPOINT]: {
+        name: 'Ronin Waypoint',
+        id: SupportedConnectors.WAYPOINT,
+        type: ConnectorType.MPC,
+    },
+    [SupportedConnectors.INJECTED]: {
+        name: 'Injected Providers',
+        id: SupportedConnectors.INJECTED,
+        type: ConnectorType.WALLET,
+    },
+    [SupportedConnectors.SAFE]: {
+        name: 'Gnosis Safe',
+        id: SupportedConnectors.SAFE,
+        type: ConnectorType.MULTISIG,
+    },
+    [SupportedConnectors.COINBASE_WALLET]: {
+        name: 'Coinbase Wallet',
+        id: SupportedConnectors.COINBASE_WALLET,
+        type: ConnectorType.WALLET,
+    },
+};const RONIN_WALLET_RDNS = 'com.roninchain.wallet';
+const DEFAULT_DELAY_TIME = 700;
+const WAYPOINT_CLIENT_ID = 'ced25363-9cab-4e50-b1bc-0e583b93c3a2';
+const WC_SUPPORTED_CHAIN_IDS = [ChainIds.RoninMainet, ChainIds.RoninTestnet];
+const WC_RPC_MAP = {
+    [ChainIds.RoninMainet]: 'https://api.roninchain.com/rpc',
+    [ChainIds.RoninTestnet]: 'https://saigon-testnet.roninchain.com/rpc',
+};
+const WC_CAIP_CHAIN = 'eip155';
+const WC_SUPPORTED_METHODS = ['eth_sendTransaction', 'eth_sign', 'personal_sign', 'eth_signTypedData'];
+const WC_SUPPORTED_OPTIONAL_METHODS = [
+    'eth_accounts',
+    'eth_requestAccounts',
+    'eth_signTypedData_v4',
+    'eth_getFreeGasRequests',
+    'wallet_initialData',
+];const STORAGE_PREFIX = 'tanto';
+const LocalStorage = {
+    isAccessible: () => typeof localStorage !== 'undefined',
+    set: (key, data) => {
+        if (!LocalStorage.isAccessible()) {
+            return false;
+        }
+        localStorage.setItem(key, JSON.stringify(data));
+        return true;
+    },
+    get: (key) => {
+        if (!LocalStorage.isAccessible()) {
+            return undefined;
+        }
+        const data = localStorage.getItem(key);
+        if (data) {
+            return JSON.parse(data);
+        }
+        return undefined;
+    },
+    remove: (key) => {
+        if (!LocalStorage.isAccessible()) {
+            return false;
+        }
+        localStorage.removeItem(key);
+        return true;
+    },
+};
+const ReconnectStorage = {
+    get: (connectorId) => LocalStorage.get(`${STORAGE_PREFIX}.RECONNECT.${connectorId}`) ?? false,
+    add: (connectorId) => LocalStorage.set(`${STORAGE_PREFIX}.RECONNECT.${connectorId}`, true),
+    remove: (connectorId) => LocalStorage.remove(`${STORAGE_PREFIX}.RECONNECT.${connectorId}`),
+};var EIP6963EventNames;
+(function (EIP6963EventNames) {
+    EIP6963EventNames["AnnounceProvider"] = "eip6963:announceProvider";
+    EIP6963EventNames["RequestProvider"] = "eip6963:requestProvider";
+})(EIP6963EventNames || (EIP6963EventNames = {}));const injectedProviders = [];
+const requestProviders = async (delay = DEFAULT_DELAY_TIME) => {
+    if (typeof window === 'undefined') {
+        return [];
+    }
+    const handlerAnnouncement = (event) => {
+        const isAnnounced = injectedProviders.some(detail => detail.info.uuid === event.detail.info.uuid);
+        if (!isAnnounced) {
+            injectedProviders.push(event.detail);
+        }
+    };
+    window.addEventListener(EIP6963EventNames.AnnounceProvider, handlerAnnouncement);
+    window.dispatchEvent(new CustomEvent(EIP6963EventNames.RequestProvider));
+    await new Promise(resolve => setTimeout(resolve, delay));
+    window.removeEventListener(EIP6963EventNames.AnnounceProvider, handlerAnnouncement);
+    return injectedProviders;
+};var ConnectorErrorType;
+(function (ConnectorErrorType) {
+    ConnectorErrorType["PROVIDER_NOT_FOUND"] = "ProviderNotFound";
+    ConnectorErrorType["WALLET_IS_LOCKED"] = "WalletIsLocked";
+    ConnectorErrorType["CONNECT_FAILED"] = "ConnectFailed";
+    ConnectorErrorType["USER_REJECTED_SESSION_REQUEST"] = "UserRejectedSessionRequest";
+    ConnectorErrorType["INVALID_PARAMS"] = "InvalidParams";
+    ConnectorErrorType["NOT_INSTALLED"] = "NotInstalled";
+    ConnectorErrorType["UNKNOWN"] = "Unknown";
+    ConnectorErrorType["SWITCH_CHAIN_NOT_SUPPORTED"] = "SwitchChainNotSupported";
+})(ConnectorErrorType || (ConnectorErrorType = {}));
+class ConnectorError extends Error {
+    name;
+    error;
+    constructor(name, error) {
+        super();
+        this.name = name;
+        this.error = error;
+    }
+}const checkRoninInstalled = () => {
+    if (typeof window !== 'undefined') {
+        return window.ronin !== undefined;
+    }
+    else {
+        return false;
+    }
+};
+function numberToHex(value) {
+    return `0x${value.toString(16)}`;
+}const requestRoninProvider = async (delay = DEFAULT_DELAY_TIME) => {
+    const providersDetail = await requestProviders(delay);
+    const roninProvider = providersDetail.find(({ info }) => info.rdns === RONIN_WALLET_RDNS)?.provider;
+    if (roninProvider) {
+        return roninProvider;
+    }
+    else {
+        throw new ConnectorError(ConnectorErrorType.PROVIDER_NOT_FOUND);
+    }
+};
+const requestLegacyRoninProvider = async (delay = DEFAULT_DELAY_TIME) => {
+    if (checkRoninInstalled()) {
+        return window.ronin?.provider;
+    }
+    // Wait for the provider to be injected if it's not available yet
+    await new Promise(resolve => setTimeout(resolve, delay));
+    if (checkRoninInstalled()) {
+        return window.ronin?.provider;
+    }
+    throw new ConnectorError(ConnectorErrorType.NOT_INSTALLED);
+};const requestRoninWalletConnectProvider = (options) => {
+    return EthereumProvider.init({
+        chains: WC_SUPPORTED_CHAIN_IDS,
+        methods: WC_SUPPORTED_METHODS,
+        optionalMethods: WC_SUPPORTED_OPTIONAL_METHODS,
+        rpcMap: WC_RPC_MAP,
+        ...options,
+    });
+};const requestSafeProvider = async (delay = DEFAULT_DELAY_TIME) => {
+    const safeSDK = new SafeAppsSDK();
+    const safeInfo = await Promise.race([
+        safeSDK.safe.getInfo(),
+        new Promise(resolve => setTimeout(resolve, delay)),
+    ]);
+    if (!safeInfo) {
+        throw new ConnectorError(ConnectorErrorType.PROVIDER_NOT_FOUND);
+    }
+    const safeProvider = new SafeAppProvider(safeInfo, safeSDK);
+    return safeProvider;
+};const requestWaypointProvider = (chainId) => {
+    const waypointProvider = WaypointProvider.create({
+        clientId: WAYPOINT_CLIENT_ID,
+        chainId: chainId || ChainIds.RoninMainet,
+    });
+    if (!waypointProvider) {
+        throw new ConnectorError(ConnectorErrorType.PROVIDER_NOT_FOUND);
+    }
+    return waypointProvider;
+};var EIP1193Event;
+(function (EIP1193Event) {
+    EIP1193Event["CONNECT"] = "connect";
+    EIP1193Event["DISCONNECT"] = "disconnect";
+    EIP1193Event["ACCOUNTS_CHANGED"] = "accountsChanged";
+    EIP1193Event["CHAIN_CHANGED"] = "chainChanged";
+    EIP1193Event["MESSAGE"] = "message";
+})(EIP1193Event || (EIP1193Event = {}));var WCEvent;
+(function (WCEvent) {
+    WCEvent["DISPLAY_URI"] = "display_uri";
+    WCEvent["SESSION_PING"] = "session_ping";
+    WCEvent["SESSION_UPDATE"] = "session_update";
+    WCEvent["SESSION_EVENT"] = "session_event";
+    WCEvent["SESSION_DELETE"] = "session_delete";
+})(WCEvent || (WCEvent = {}));
+var ConnectorEvent;
+(function (ConnectorEvent) {
+    ConnectorEvent["CONNECT"] = "connect";
+    ConnectorEvent["DISCONNECT"] = "disconnect";
+    ConnectorEvent["ACCOUNTS_CHANGED"] = "accountsChanged";
+    ConnectorEvent["CHAIN_CHANGED"] = "chainChanged";
+    ConnectorEvent["MESSAGE"] = "message";
+    ConnectorEvent["DISPLAY_URI"] = "display_uri";
+    ConnectorEvent["SESSION_DELETE"] = "session_delete";
+})(ConnectorEvent || (ConnectorEvent = {}));
+class ConnectorEventEmitter extends EventEmitter {
+    emit(event, payload) {
+        return super.emit(event, payload);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+}class BaseConnector extends ConnectorEventEmitter {
+    id;
+    name;
+    type;
+    isRonin;
+    icon;
+    provider;
+    constructor(configs, provider) {
+        const { id, name, icon, type } = configs;
+        super();
+        this.id = id;
+        this.name = name;
+        this.icon = icon;
+        this.type = type;
+        this.isRonin = false;
+        this.provider = provider;
+    }
+    getProvider = async () => {
+        if (!this.provider) {
+            this.provider = await this.requestProvider();
+        }
+        return this.provider;
+    };
+    autoConnect = async () => {
+        try {
+            const shouldConnect = await this.shouldAutoReconnect();
+            if (shouldConnect)
+                await this.connect();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    };
+    shouldAutoReconnect = async () => {
+        const isReconnect = ReconnectStorage.get(this.id);
+        const isAuthorized = await this.isAuthorized();
+        return isReconnect && isAuthorized;
+    };
+    onChainChanged = (chainId) => {
+        this.emit(ConnectorEvent.CHAIN_CHANGED, Number(chainId));
+    };
+    onAccountsChanged = (accounts) => {
+        if (accounts.length === 0) {
+            this.onDisconnect();
+        }
+        this.emit(ConnectorEvent.ACCOUNTS_CHANGED, accounts);
+    };
+    onConnect = (results) => {
+        this.emit(ConnectorEvent.CONNECT, results);
+    };
+    onDisconnect = () => {
+        this.emit(ConnectorEvent.DISCONNECT);
+    };
+}class InjectedConnector extends BaseConnector {
+    isRonin;
+    provider;
+    constructor(configs, provider) {
+        super(configs);
+        this.isRonin = !!provider.isRonin;
+        this.provider = provider;
+    }
+    async connect(chainId) {
+        const provider = await this.getProvider();
+        if (!provider) {
+            throw new ConnectorError(ConnectorErrorType.PROVIDER_NOT_FOUND);
+        }
+        try {
+            const accounts = await this.requestAccounts();
+            const currentChainId = await this.getChainId();
+            if (chainId && currentChainId !== chainId) {
+                await this.switchChain(chainId);
+            }
+            const connectResults = {
+                provider,
+                chainId: chainId || currentChainId,
+                account: accounts[0],
+            };
+            this.setupProviderListeners();
+            this.onConnect(connectResults);
+            ReconnectStorage.add(this.id);
+            return connectResults;
+        }
+        catch (err) {
+            throw new ConnectorError(ConnectorErrorType.CONNECT_FAILED, err);
+        }
+    }
+    async disconnect() {
+        this.onDisconnect();
+        this.removeAllListeners();
+        this.removeProviderListeners();
+    }
+    async isAuthorized() {
+        const accounts = await this.getAccounts();
+        return accounts.length > 0;
+    }
+    async getAccounts() {
+        const provider = await this.getProvider();
+        return provider.request({
+            method: 'eth_accounts',
+        });
+    }
+    async switchChain(chain) {
+        const provider = await this.getProvider();
+        const chainId = provider?.request({
+            method: 'wallet_switchEthereumChain',
+            params: [{ chainId: numberToHex(chain) }],
+        });
+        return !!chainId;
+    }
+    async getChainId() {
+        const provider = await this.getProvider();
+        const chainId = await provider?.request({
+            method: 'eth_chainId',
+        });
+        return Number(chainId);
+    }
+    async requestAccounts() {
+        const provider = await this.getProvider();
+        return provider?.request({
+            method: 'eth_requestAccounts',
+        });
+    }
+    async requestProvider() {
+        return this.provider;
+    }
+    setupProviderListeners() {
+        if (this.provider) {
+            this.provider.on(EIP1193Event.DISCONNECT, this.onDisconnect);
+            this.provider.on(EIP1193Event.ACCOUNTS_CHANGED, this.onAccountsChanged);
+            this.provider.on(EIP1193Event.CHAIN_CHANGED, this.onChainChanged);
+        }
+    }
+    removeProviderListeners() {
+        if (this.provider) {
+            this.provider.removeListener(EIP1193Event.DISCONNECT, this.onDisconnect);
+            this.provider.removeListener(EIP1193Event.ACCOUNTS_CHANGED, this.onAccountsChanged);
+            this.provider.removeListener(EIP1193Event.CHAIN_CHANGED, this.onChainChanged);
+        }
+    }
+}class RoninWalletConnector extends BaseConnector {
+    isRonin;
+    constructor(configs, provider) {
+        super({ ...DEFAULT_CONNECTORS_CONFIG.RONIN_WALLET, ...configs }, provider);
+        this.isRonin = true;
+    }
+    async connect(chainId) {
+        const provider = await this.getProvider();
+        if (!provider) {
+            throw new ConnectorError(ConnectorErrorType.PROVIDER_NOT_FOUND);
+        }
+        const accounts = await this.requestAccounts();
+        const currentChainId = await this.getChainId();
+        if (chainId && currentChainId !== chainId) {
+            await this.switchChain(chainId);
+        }
+        const connectResults = {
+            provider,
+            chainId: chainId || currentChainId,
+            account: accounts[0],
+        };
+        this.setupProviderListeners();
+        this.onConnect(connectResults);
+        ReconnectStorage.add(this.id);
+        return connectResults;
+    }
+    async disconnect() {
+        ReconnectStorage.remove(this.id);
+        this.onDisconnect();
+        this.removeAllListeners();
+        this.removeProviderListeners();
+    }
+    async isAuthorized() {
+        const accounts = await this.getAccounts();
+        return accounts.length > 0;
+    }
+    async getAccounts() {
+        const provider = await this.getProvider();
+        return provider.request({
+            method: 'eth_accounts',
+        });
+    }
+    async switchChain(chain) {
+        const provider = await this.getProvider();
+        const chainId = provider?.request({
+            method: 'wallet_switchEthereumChain',
+            params: [{ chainId: numberToHex(chain) }],
+        });
+        return !!chainId;
+    }
+    async getChainId() {
+        const provider = await this.getProvider();
+        const chainId = await provider?.request({
+            method: 'eth_chainId',
+        });
+        return Number(chainId);
+    }
+    async requestAccounts() {
+        const provider = await this.getProvider();
+        return provider?.request({
+            method: 'eth_requestAccounts',
+        });
+    }
+    async requestProvider() {
+        return requestRoninProvider();
+    }
+    setupProviderListeners() {
+        this.removeProviderListeners();
+        if (this.provider) {
+            this.provider.on(EIP1193Event.DISCONNECT, this.onDisconnect);
+            this.provider.on(EIP1193Event.ACCOUNTS_CHANGED, this.onAccountsChanged);
+            this.provider.on(EIP1193Event.CHAIN_CHANGED, this.onChainChanged);
+        }
+    }
+    removeProviderListeners() {
+        if (this.provider) {
+            this.provider.removeListener(EIP1193Event.DISCONNECT, this.onDisconnect);
+            this.provider.removeListener(EIP1193Event.ACCOUNTS_CHANGED, this.onAccountsChanged);
+            this.provider.removeListener(EIP1193Event.CHAIN_CHANGED, this.onChainChanged);
+        }
+    }
+}class RoninWalletConnectConnector extends BaseConnector {
+    projectId;
+    metadata;
+    showQrModal;
+    isRonin;
+    constructor(configs, provider) {
+        const { projectId, metadata, showQrModal, ...restConfigs } = configs;
+        super({ ...DEFAULT_CONNECTORS_CONFIG.RONIN_WC, ...restConfigs }, provider);
+        this.metadata = metadata;
+        this.projectId = projectId;
+        this.showQrModal = showQrModal;
+        this.isRonin = true;
+        this.setupProviderListeners();
+    }
+    getProvider = async () => {
+        if (!this.provider) {
+            this.provider = await this.requestProvider();
+        }
+        return this.provider;
+    };
+    async connect(chainId) {
+        const provider = await this.getProvider();
+        const targetChainId = chainId ?? WC_SUPPORTED_CHAIN_IDS[0];
+        const isChainSupported = WC_SUPPORTED_CHAIN_IDS.includes(targetChainId);
+        if (!isChainSupported) {
+            throw new ConnectorError(ConnectorErrorType.SWITCH_CHAIN_NOT_SUPPORTED);
+        }
+        const isAuthorized = await this.isAuthorized();
+        if (!isAuthorized) {
+            await provider.connect({ chains: [targetChainId] });
+        }
+        else {
+            await provider.enable();
+        }
+        const connectResults = {
+            provider,
+            chainId: targetChainId,
+            account: provider.accounts[0],
+        };
+        ReconnectStorage.add(this.id);
+        this.onConnect(connectResults);
+        return connectResults;
+    }
+    async disconnect() {
+        const provider = await this.getProvider();
+        await provider.disconnect();
+        this.onDisconnect();
+        ReconnectStorage.remove(this.id);
+        this.removeAllListeners();
+        this.removeProviderListeners();
+    }
+    async isAuthorized() {
+        const accounts = await this.getAccounts();
+        return accounts.length > 0;
+    }
+    async getAccounts() {
+        const provider = await this.getProvider();
+        return provider.accounts;
+    }
+    async switchChain(chain) {
+        const provider = await this.getProvider();
+        const chainId = provider?.request({
+            method: 'wallet_switchEthereumChain',
+            params: [{ chainId: numberToHex(chain) }],
+        });
+        return !!chainId;
+    }
+    async getChainId() {
+        const provider = await this.getProvider();
+        const chainId = await provider?.request({
+            method: 'eth_chainId',
+        });
+        return Number(chainId);
+    }
+    async requestAccounts() {
+        const provider = await this.getProvider();
+        return provider?.request({
+            method: 'eth_requestAccounts',
+        });
+    }
+    async requestProvider() {
+        return requestRoninWalletConnectProvider({
+            projectId: this.projectId,
+            metadata: this.metadata,
+            showQrModal: this.isRonin,
+            chains: WC_SUPPORTED_CHAIN_IDS,
+        });
+    }
+    onDisplayUri = (uri) => {
+        this.emit(ConnectorEvent.DISPLAY_URI, uri);
+    };
+    setupWalletConnectEvent() {
+        this.getProvider().then(provider => {
+            provider.on(WCEvent.SESSION_DELETE, this.onDisconnect);
+            provider.on(WCEvent.DISPLAY_URI, this.onDisplayUri);
+        });
+    }
+    setupProviderListeners() {
+        if (this.provider) {
+            this.provider.on(EIP1193Event.DISCONNECT, this.onDisconnect);
+            this.provider.on(EIP1193Event.ACCOUNTS_CHANGED, this.onAccountsChanged);
+            this.provider.on(EIP1193Event.CHAIN_CHANGED, this.onChainChanged);
+            this.setupWalletConnectEvent();
+        }
+    }
+    removeProviderListeners() {
+        if (this.provider) {
+            this.provider.removeListener(EIP1193Event.DISCONNECT, this.onDisconnect);
+            this.provider.removeListener(EIP1193Event.ACCOUNTS_CHANGED, this.onAccountsChanged);
+            this.provider.removeListener(EIP1193Event.CHAIN_CHANGED, this.onChainChanged);
+            this.provider.removeListener(WCEvent.DISPLAY_URI, this.onDisplayUri);
+            this.provider.removeListener(WCEvent.SESSION_DELETE, this.onDisconnect);
+        }
+    }
+}class SafeConnector extends BaseConnector {
+    constructor(configs, provider) {
+        super({ ...DEFAULT_CONNECTORS_CONFIG.SAFE, ...configs }, provider);
+    }
+    async connect(chainId) {
+        const provider = await this.getProvider();
+        if (!provider) {
+            throw new ConnectorError(ConnectorErrorType.PROVIDER_NOT_FOUND);
+        }
+        const accounts = await this.requestAccounts();
+        const currentChainId = await this.getChainId();
+        if (chainId && chainId !== currentChainId) {
+            await this.switchChain(chainId);
+        }
+        const connectResults = {
+            provider,
+            chainId: chainId || currentChainId,
+            account: accounts[0],
+        };
+        this.setupProviderListeners();
+        this.onConnect(connectResults);
+        return {
+            provider,
+            chainId: chainId ?? currentChainId,
+            account: accounts[0],
+        };
+    }
+    async disconnect() {
+        this.onDisconnect();
+        this.removeAllListeners();
+        this.removeProviderListeners();
+    }
+    async isAuthorized() {
+        const accounts = await this.getAccounts();
+        return accounts.length > 0;
+    }
+    async getAccounts() {
+        const provider = await this.getProvider();
+        return provider?.request({
+            method: 'eth_accounts',
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async switchChain(chain) {
+        // TODO: Add a Connector Error for not allowing switch chain
+        throw new ConnectorError(ConnectorErrorType.SWITCH_CHAIN_NOT_SUPPORTED);
+    }
+    async getChainId() {
+        const provider = await this.getProvider();
+        const chainId = await provider?.request({
+            method: 'eth_chainId',
+        });
+        return Number(chainId);
+    }
+    async requestAccounts() {
+        const provider = await this.getProvider();
+        return provider?.request({
+            method: 'eth_requestAccounts',
+        });
+    }
+    async requestProvider() {
+        return await requestSafeProvider();
+    }
+    setupProviderListeners() {
+        this.removeProviderListeners();
+        if (this.provider) {
+            this.provider.on(EIP1193Event.DISCONNECT, this.onDisconnect);
+            this.provider.on(EIP1193Event.ACCOUNTS_CHANGED, this.onAccountsChanged);
+        }
+    }
+    removeProviderListeners() {
+        if (this.provider) {
+            this.provider.removeListener(EIP1193Event.DISCONNECT, this.onDisconnect);
+            this.provider.removeListener(EIP1193Event.ACCOUNTS_CHANGED, this.onAccountsChanged);
+        }
+    }
+}class WaypointConnector extends BaseConnector {
+    constructor(configs, provider) {
+        super({ ...DEFAULT_CONNECTORS_CONFIG.WAYPOINT, ...configs }, provider);
+    }
+    async isAuthorized() {
+        const accounts = await this.getAccounts();
+        return accounts.length > 0;
+    }
+    async getAccounts() {
+        const provider = await this.getProvider();
+        return provider.request({
+            method: 'eth_accounts',
+        });
+    }
+    async switchChain() {
+        console.error(new ConnectorError(ConnectorErrorType.SWITCH_CHAIN_NOT_SUPPORTED));
+        return false;
+    }
+    async getChainId() {
+        const provider = await this.getProvider();
+        const chainId = await provider?.request({
+            method: 'eth_chainId',
+        });
+        return Number(chainId);
+    }
+    async requestAccounts() {
+        const provider = await this.getProvider();
+        return provider?.request({
+            method: 'eth_requestAccounts',
+        });
+    }
+    async connect(chainId) {
+        const provider = await this.getProvider();
+        if (!provider) {
+            throw new ConnectorError(ConnectorErrorType.PROVIDER_NOT_FOUND);
+        }
+        const accounts = await this.requestAccounts();
+        const currentChainId = await this.getChainId();
+        const connectResults = {
+            provider,
+            chainId: chainId || currentChainId,
+            account: accounts[0],
+        };
+        this.setupProviderListeners();
+        this.onConnect(connectResults);
+        ReconnectStorage.add(this.id);
+        return {
+            provider,
+            chainId: chainId ?? currentChainId,
+            account: accounts[0],
+        };
+    }
+    async disconnect() {
+        this.onDisconnect();
+        this.removeAllListeners();
+        this.removeProviderListeners();
+    }
+    async requestProvider() {
+        return requestWaypointProvider();
+    }
+    setupProviderListeners() {
+        this.removeProviderListeners();
+        if (this.provider) {
+            this.provider.on(EIP1193Event.DISCONNECT, this.onDisconnect);
+        }
+    }
+    removeProviderListeners() {
+        if (this.provider) {
+            this.provider.removeListener(EIP1193Event.DISCONNECT, this.onDisconnect);
+        }
+    }
+}const requestInjectedConnectors = async () => {
+    const providerDetails = await requestProviders();
+    return providerDetails.map(detail => {
+        if (detail.info.rdns === RONIN_WALLET_RDNS) {
+            return new RoninWalletConnector({ icon: detail.info.icon });
+        }
+        else {
+            const configs = {
+                name: detail.info.name,
+                id: detail.info.rdns,
+                icon: detail.info.icon,
+                type: 'injected',
+            };
+            return new InjectedConnector(configs, detail.provider);
+        }
+    });
+};
+const requestRoninWalletConnector = async () => {
+    const provider = await requestLegacyRoninProvider();
+    return new RoninWalletConnector({}, provider);
+};
+const requestRoninWalletConnectConnector = async (configs) => {
+    const provider = await requestRoninWalletConnectProvider({
+        projectId: configs.projectId,
+        metadata: configs.metadata,
+        chains: WC_SUPPORTED_CHAIN_IDS,
+        showQrModal: false,
+    });
+    return new RoninWalletConnectConnector(configs, provider);
+};
+const requestSafeConnector = async (configs, delay = DEFAULT_DELAY_TIME) => {
+    const provider = await requestSafeProvider(delay);
+    return new SafeConnector(configs, provider);
+};
+const requestWaypointConnector = (config, chainId) => {
+    const waypointProvider = requestWaypointProvider(chainId);
+    return new WaypointConnector(config, waypointProvider);
+};export{BaseConnector,CHAINS_CONFIG,ChainIds,ConnectorError,ConnectorErrorType,ConnectorEvent,ConnectorEventEmitter,ConnectorType,DEFAULT_CONNECTORS_CONFIG,DEFAULT_DELAY_TIME,EIP1193Event,EIP6963EventNames,InjectedConnector,LocalStorage,RONIN_WALLET_RDNS,ReconnectStorage,RoninWalletConnectConnector,RoninWalletConnector,STORAGE_PREFIX,SafeConnector,SupportedConnectors,WAYPOINT_CLIENT_ID,WCEvent,WC_CAIP_CHAIN,WC_RPC_MAP,WC_SUPPORTED_CHAIN_IDS,WC_SUPPORTED_METHODS,WC_SUPPORTED_OPTIONAL_METHODS,WaypointConnector,requestInjectedConnectors,requestLegacyRoninProvider,requestProviders,requestRoninProvider,requestRoninWalletConnectConnector,requestRoninWalletConnectProvider,requestRoninWalletConnector,requestSafeConnector,requestSafeProvider,requestWaypointConnector,requestWaypointProvider};