@layerswap/widget 0.1.20 → 1.0.0-alpha1.1

package/dist/lib/wallets/connectors/EthereumProvider.js

@@ -1,455 +0,0 @@
-import { EventEmitter } from "events";
-import { getAccountsFromNamespaces, getSdkError, isValidArray } from "@walletconnect/utils";
-import { UniversalProvider, } from "@walletconnect/universal-provider";
-import { STORAGE_KEY, REQUIRED_METHODS, REQUIRED_EVENTS, RPC_URL, OPTIONAL_METHODS, OPTIONAL_EVENTS, } from "./constants";
-export function getRpcUrl(chainId, rpc) {
-    let rpcUrl;
-    if (rpc.rpcMap) {
-        rpcUrl = rpc.rpcMap[getEthereumChainId([chainId])];
-    }
-    return rpcUrl;
-}
-export function getEthereumChainId(chains) {
-    return Number(chains[0].split(":")[1]);
-}
-export function toHexChainId(chainId) {
-    return `0x${chainId.toString(16)}`;
-}
-export function buildNamespaces(params) {
-    const { chains, optionalChains, methods, optionalMethods, events, optionalEvents, rpcMap } = params;
-    if (!isValidArray(chains)) {
-        throw new Error("Invalid chains");
-    }
-    const required = {
-        chains,
-        methods: methods || REQUIRED_METHODS,
-        events: events || REQUIRED_EVENTS,
-        rpcMap: {
-            ...(chains.length
-                ? { [getEthereumChainId(chains)]: rpcMap[getEthereumChainId(chains)] }
-                : {}),
-        },
-    };
-    // make a list of events and methods that require additional permissions
-    // so we know if we should to include the required chains in the optional namespace
-    const eventsRequiringPermissions = events?.filter((event) => !REQUIRED_EVENTS.includes(event));
-    const methodsRequiringPermissions = methods?.filter((event) => !REQUIRED_METHODS.includes(event));
-    if (!optionalChains &&
-        !optionalEvents &&
-        !optionalMethods &&
-        !eventsRequiringPermissions?.length &&
-        !methodsRequiringPermissions?.length) {
-        return { required: chains.length ? required : undefined };
-    }
-    /*
-     * decides whether or not to include the required chains in the optional namespace
-     * use case: if there is a single chain as required but additional methods/events as optional
-     */
-    const shouldIncludeRequiredChains = (eventsRequiringPermissions?.length && methodsRequiringPermissions?.length) || !optionalChains;
-    const optional = {
-        chains: [
-            ...new Set(shouldIncludeRequiredChains ? required.chains.concat(optionalChains || []) : optionalChains),
-        ],
-        methods: [
-            ...new Set(required.methods.concat(optionalMethods?.length ? optionalMethods : OPTIONAL_METHODS)),
-        ],
-        events: [
-            ...new Set(required.events.concat(optionalEvents?.length ? optionalEvents : OPTIONAL_EVENTS)),
-        ],
-        rpcMap,
-    };
-    return {
-        required: chains.length ? required : undefined,
-        optional: optionalChains.length ? optional : undefined,
-    };
-}
-export class EthereumProvider {
-    constructor() {
-        this.events = new EventEmitter();
-        this.namespace = "eip155";
-        this.accounts = [];
-        this.chainId = 1;
-        this.STORAGE_KEY = STORAGE_KEY;
-        this.on = (event, listener) => {
-            this.events.on(event, listener);
-            return this;
-        };
-        this.once = (event, listener) => {
-            this.events.once(event, listener);
-            return this;
-        };
-        this.removeListener = (event, listener) => {
-            this.events.removeListener(event, listener);
-            return this;
-        };
-        this.off = (event, listener) => {
-            this.events.off(event, listener);
-            return this;
-        };
-        this.parseAccount = (payload) => {
-            return this.isCompatibleChainId(payload) ? this.parseAccountId(payload).address : payload;
-        };
-        // assigned during initialize
-        this.signer = {};
-        this.rpc = {};
-    }
-    static async init(opts) {
-        const provider = new EthereumProvider();
-        await provider.initialize(opts);
-        return provider;
-    }
-    async request(args, expiry) {
-        return await this.signer.request(args, this.formatChainId(this.chainId), expiry);
-    }
-    sendAsync(args, callback, expiry) {
-        this.signer.sendAsync(args, callback, this.formatChainId(this.chainId), expiry);
-    }
-    get connected() {
-        if (!this.signer.client)
-            return false;
-        return this.signer.client.core.relayer.connected;
-    }
-    get connecting() {
-        if (!this.signer.client)
-            return false;
-        return this.signer.client.core.relayer.connecting;
-    }
-    async enable() {
-        if (!this.session)
-            await this.connect();
-        const accounts = await this.request({ method: "eth_requestAccounts" });
-        return accounts;
-    }
-    async connect(opts) {
-        if (!this.signer.client) {
-            throw new Error("Provider not initialized. Call init() first");
-        }
-        this.loadConnectOpts(opts);
-        const { required, optional } = buildNamespaces(this.rpc);
-        try {
-            const session = await new Promise(async (resolve, reject) => {
-                if (this.rpc.showQrModal) {
-                    this.modal?.subscribeModal((state) => {
-                        // the modal was closed so reject the promise
-                        if (!state.open && !this.signer.session) {
-                            this.signer.abortPairingAttempt();
-                            reject(new Error("Connection request reset. Please try again."));
-                        }
-                    });
-                }
-                await this.signer
-                    .connect({
-                    namespaces: {
-                        ...(required && {
-                            [this.namespace]: required,
-                        }),
-                    },
-                    ...(optional && {
-                        optionalNamespaces: {
-                            [this.namespace]: optional,
-                        },
-                    }),
-                    pairingTopic: opts?.pairingTopic,
-                })
-                    .then((session) => {
-                    resolve(session);
-                })
-                    .catch((error) => {
-                    reject(new Error(error.message));
-                });
-            });
-            if (!session)
-                return;
-            const accounts = getAccountsFromNamespaces(session.namespaces, [this.namespace]);
-            // if no required chains are set, use the approved accounts to fetch chainIds
-            this.setChainIds(this.rpc.chains.length ? this.rpc.chains : accounts);
-            this.setAccounts(accounts);
-            this.events.emit("connect", { chainId: toHexChainId(this.chainId) });
-        }
-        catch (error) {
-            this.signer.logger.error(error);
-            throw error;
-        }
-        finally {
-            if (this.modal)
-                this.modal.closeModal();
-        }
-    }
-    async authenticate(params, walletUniversalLink) {
-        if (!this.signer.client) {
-            throw new Error("Provider not initialized. Call init() first");
-        }
-        this.loadConnectOpts({
-            chains: params?.chains,
-        });
-        try {
-            const result = await new Promise(async (resolve, reject) => {
-                if (this.rpc.showQrModal) {
-                    this.modal?.subscribeModal((state) => {
-                        // the modal was closed so reject the promise
-                        if (!state.open && !this.signer.session) {
-                            this.signer.abortPairingAttempt();
-                            reject(new Error("Connection request reset. Please try again."));
-                        }
-                    });
-                }
-                await this.signer
-                    .authenticate({
-                    ...params,
-                    chains: this.rpc.chains,
-                }, walletUniversalLink)
-                    .then((result) => {
-                    resolve(result);
-                })
-                    .catch((error) => {
-                    reject(new Error(error.message));
-                });
-            });
-            const session = result.session;
-            if (session) {
-                const accounts = getAccountsFromNamespaces(session.namespaces, [this.namespace]);
-                // if no required chains are set, use the approved accounts to fetch chainIds as both contain <namespace>:<chainId>
-                this.setChainIds(this.rpc.chains.length ? this.rpc.chains : accounts);
-                this.setAccounts(accounts);
-                this.events.emit("connect", { chainId: toHexChainId(this.chainId) });
-            }
-            return result;
-        }
-        catch (error) {
-            this.signer.logger.error(error);
-            throw error;
-        }
-        finally {
-            if (this.modal)
-                this.modal.closeModal();
-        }
-    }
-    async disconnect() {
-        if (this.session) {
-            await this.signer.disconnect();
-        }
-        this.reset();
-    }
-    get isWalletConnect() {
-        return true;
-    }
-    get session() {
-        return this.signer.session;
-    }
-    // ---------- Protected --------------------------------------------- //
-    registerEventListeners() {
-        this.signer.on("session_event", (payload) => {
-            const { params } = payload;
-            const { event } = params;
-            if (event.name === "accountsChanged") {
-                this.accounts = this.parseAccounts(event.data);
-                this.events.emit("accountsChanged", this.accounts);
-            }
-            else if (event.name === "chainChanged") {
-                this.setChainId(this.formatChainId(event.data));
-            }
-            else {
-                this.events.emit(event.name, event.data);
-            }
-            this.events.emit("session_event", payload);
-        });
-        this.signer.on("chainChanged", (chainId) => {
-            const chain = parseInt(chainId);
-            this.chainId = chain;
-            this.events.emit("chainChanged", toHexChainId(this.chainId));
-            this.persist();
-        });
-        this.signer.on("session_update", (payload) => {
-            this.events.emit("session_update", payload);
-        });
-        this.signer.on("session_delete", (payload) => {
-            this.reset();
-            this.events.emit("session_delete", payload);
-            this.events.emit("disconnect", {
-                ...getSdkError("USER_DISCONNECTED"),
-                data: payload.topic,
-                name: "USER_DISCONNECTED",
-            });
-        });
-        this.signer.on("display_uri", (uri) => {
-            if (this.rpc.showQrModal) {
-                // to refresh the QR we have to close the modal and open it again
-                // until proper API is provided by walletconnect modal
-                this.modal?.closeModal();
-                this.modal?.openModal({ uri });
-            }
-            this.events.emit("display_uri", uri);
-        });
-    }
-    switchEthereumChain(chainId) {
-        this.request({
-            method: "wallet_switchEthereumChain",
-            params: [{ chainId: chainId.toString(16) }],
-        });
-    }
-    isCompatibleChainId(chainId) {
-        return typeof chainId === "string" ? chainId.startsWith(`${this.namespace}:`) : false;
-    }
-    formatChainId(chainId) {
-        return `${this.namespace}:${chainId}`;
-    }
-    parseChainId(chainId) {
-        return Number(chainId.split(":")[1]);
-    }
-    setChainIds(chains) {
-        const compatible = chains.filter((x) => this.isCompatibleChainId(x));
-        const chainIds = compatible.map((c) => this.parseChainId(c));
-        if (chainIds.length) {
-            this.chainId = chainIds[0];
-            this.events.emit("chainChanged", toHexChainId(this.chainId));
-            this.persist();
-        }
-    }
-    setChainId(chain) {
-        if (this.isCompatibleChainId(chain)) {
-            const chainId = this.parseChainId(chain);
-            this.chainId = chainId;
-            this.switchEthereumChain(chainId);
-        }
-    }
-    parseAccountId(account) {
-        const [namespace, reference, address] = account.split(":");
-        const chainId = `${namespace}:${reference}`;
-        return { chainId, address };
-    }
-    setAccounts(accounts) {
-        this.accounts = accounts
-            .filter((x) => this.parseChainId(this.parseAccountId(x).chainId) === this.chainId)
-            .map((x) => this.parseAccountId(x).address);
-        this.events.emit("accountsChanged", this.accounts);
-    }
-    getRpcConfig(opts) {
-        const requiredChains = opts?.chains ?? [];
-        const optionalChains = opts?.optionalChains ?? [];
-        const allChains = requiredChains.concat(optionalChains);
-        if (!allChains.length)
-            throw new Error("No chains specified in either `chains` or `optionalChains`");
-        const requiredMethods = requiredChains.length ? opts?.methods || REQUIRED_METHODS : [];
-        const requiredEvents = requiredChains.length ? opts?.events || REQUIRED_EVENTS : [];
-        const optionalMethods = opts?.optionalMethods || [];
-        const optionalEvents = opts?.optionalEvents || [];
-        const rpcMap = opts?.rpcMap || this.buildRpcMap(allChains, opts.projectId);
-        const qrModalOptions = opts?.qrModalOptions || undefined;
-        return {
-            chains: requiredChains?.map((chain) => this.formatChainId(chain)),
-            optionalChains: optionalChains.map((chain) => this.formatChainId(chain)),
-            methods: requiredMethods,
-            events: requiredEvents,
-            optionalMethods,
-            optionalEvents,
-            rpcMap,
-            showQrModal: Boolean(opts?.showQrModal),
-            qrModalOptions,
-            projectId: opts.projectId,
-            metadata: opts.metadata,
-        };
-    }
-    buildRpcMap(chains, projectId) {
-        const map = {};
-        chains.forEach((chain) => {
-            map[chain] = this.getRpcUrl(chain, projectId);
-        });
-        return map;
-    }
-    async initialize(opts) {
-        this.rpc = this.getRpcConfig(opts);
-        this.chainId = this.rpc.chains.length
-            ? getEthereumChainId(this.rpc.chains)
-            : getEthereumChainId(this.rpc.optionalChains);
-        this.signer = await UniversalProvider.init({
-            projectId: this.rpc.projectId,
-            metadata: this.rpc.metadata,
-            disableProviderPing: opts.disableProviderPing,
-            relayUrl: opts.relayUrl,
-            storageOptions: opts.storageOptions,
-            customStoragePrefix: opts.customStoragePrefix,
-            telemetryEnabled: opts.telemetryEnabled,
-        });
-        this.registerEventListeners();
-        await this.loadPersistedSession();
-        if (this.rpc.showQrModal) {
-            let WalletConnectModalClass;
-            try {
-                const { WalletConnectModal } = await import("@walletconnect/modal");
-                WalletConnectModalClass = WalletConnectModal;
-            }
-            catch {
-                throw new Error("To use QR modal, please install @walletconnect/modal package");
-            }
-            if (WalletConnectModalClass) {
-                try {
-                    this.modal = new WalletConnectModalClass({
-                        projectId: this.rpc.projectId,
-                        ...this.rpc.qrModalOptions,
-                    });
-                }
-                catch (e) {
-                    this.signer.logger.error(e);
-                    throw new Error("Could not generate WalletConnectModal Instance");
-                }
-            }
-        }
-    }
-    loadConnectOpts(opts) {
-        if (!opts)
-            return;
-        const { chains, optionalChains, rpcMap } = opts;
-        if (chains && isValidArray(chains)) {
-            this.rpc.chains = chains.map((chain) => this.formatChainId(chain));
-            chains.forEach((chain) => {
-                this.rpc.rpcMap[chain] = rpcMap?.[chain] || this.getRpcUrl(chain);
-            });
-        }
-        if (optionalChains && isValidArray(optionalChains)) {
-            this.rpc.optionalChains = [];
-            this.rpc.optionalChains = optionalChains?.map((chain) => this.formatChainId(chain));
-            optionalChains.forEach((chain) => {
-                this.rpc.rpcMap[chain] = rpcMap?.[chain] || this.getRpcUrl(chain);
-            });
-        }
-    }
-    getRpcUrl(chainId, projectId) {
-        const providedRpc = this.rpc.rpcMap?.[chainId];
-        return (providedRpc ||
-            `${RPC_URL}?chainId=eip155:${chainId}&projectId=${projectId || this.rpc.projectId}`);
-    }
-    async loadPersistedSession() {
-        if (!this.session)
-            return;
-        try {
-            const chainId = await this.signer.client.core.storage.getItem(`${this.STORAGE_KEY}/chainId`);
-            // cater to both inline & nested namespace formats
-            const namespace = this.session.namespaces[`${this.namespace}:${chainId}`]
-                ? this.session.namespaces[`${this.namespace}:${chainId}`]
-                : this.session.namespaces[this.namespace];
-            this.setChainIds(chainId ? [this.formatChainId(chainId)] : namespace?.accounts);
-            this.setAccounts(namespace?.accounts);
-        }
-        catch (error) {
-            this.signer.logger.error("Failed to load persisted session, clearing state...");
-            this.signer.logger.error(error);
-            await this.disconnect().catch((error) => this.signer.logger.warn(error));
-        }
-    }
-    reset() {
-        this.chainId = 1;
-        this.accounts = [];
-    }
-    persist() {
-        if (!this.session)
-            return;
-        this.signer.client.core.storage.setItem(`${this.STORAGE_KEY}/chainId`, this.chainId);
-    }
-    parseAccounts(payload) {
-        if (typeof payload === "string" || payload instanceof String) {
-            return [this.parseAccount(payload)];
-        }
-        return payload.map((account) => this.parseAccount(account));
-    }
-}
-export default EthereumProvider;

package/dist/lib/wallets/connectors/argent/index.d.ts

@@ -1,61 +0,0 @@
-import type { Compute, ExactPartial, Omit } from '@wagmi/core/internal';
-import type { EthereumProvider } from '@walletconnect/ethereum-provider';
-import { type Address, type ProviderConnectInfo } from 'viem';
-type EthereumProviderOptions = Parameters<(typeof EthereumProvider)['init']>[0];
-export type WalletConnectParameters = Compute<{
-    /**
-     * If a new chain is added to a previously existing configured connector `chains`, this flag
-     * will determine if that chain should be considered as stale. A stale chain is a chain that
-     * WalletConnect has yet to establish a relationship with (e.g. the user has not approved or
-     * rejected the chain).
-     *
-     * This flag mainly affects the behavior when a wallet does not support dynamic chain authorization
-     * with WalletConnect v2.
-     *
-     * If `true` (default), the new chain will be treated as a stale chain. If the user
-     * has yet to establish a relationship (approved/rejected) with this chain in their WalletConnect
-     * session, the connector will disconnect upon the dapp auto-connecting, and the user will have to
-     * reconnect to the dapp (revalidate the chain) in order to approve the newly added chain.
-     * This is the default behavior to avoid an unexpected error upon switching chains which may
-     * be a confusing user experience (e.g. the user will not know they have to reconnect
-     * unless the dapp handles these types of errors).
-     *
-     * If `false`, the new chain will be treated as a potentially valid chain. This means that if the user
-     * has yet to establish a relationship with the chain in their WalletConnect session, wagmi will successfully
-     * auto-connect the user. This comes with the trade-off that the connector will throw an error
-     * when attempting to switch to the unapproved chain if the wallet does not support dynamic session updates.
-     * This may be useful in cases where a dapp constantly
-     * modifies their configured chains, and they do not want to disconnect the user upon
-     * auto-connecting. If the user decides to switch to the unapproved chain, it is important that the
-     * dapp handles this error and prompts the user to reconnect to the dapp in order to approve
-     * the newly added chain.
-     *
-     * @default true
-     */
-    isNewChainsStale?: boolean;
-} & Omit<EthereumProviderOptions, 'chains' | 'events' | 'optionalChains' | 'optionalEvents' | 'optionalMethods' | 'methods' | 'rpcMap' | 'showQrModal'> & ExactPartial<Pick<EthereumProviderOptions, 'showQrModal'>>>;
-export declare function argent(parameters: WalletConnectParameters): import("@wagmi/core").CreateConnectorFn<import("@walletconnect/ethereum-provider").default, {
-    connect(parameters?: {
-        chainId?: number;
-        pairingTopic?: string;
-    }): Promise<{
-        accounts: readonly Address[];
-        chainId: number;
-    }>;
-    getNamespaceChainsIds(): number[];
-    getRequestedChainsIds(): Promise<number[]>;
-    isChainsStale(): Promise<boolean>;
-    onConnect(connectInfo: ProviderConnectInfo): void;
-    onDisplayUri(uri: string): void;
-    onSessionDelete(data: {
-        topic: string;
-    }): void;
-    setRequestedChainsIds(chains: number[]): void;
-    requestedChainsStorageKey: `${string}.requestedChains`;
-}, {
-    [x: `${string}.requestedChains`]: number[];
-}>;
-export declare namespace argent {
-    var type: "my_walletConnect";
-}
-export {};