How to use the m.identity_server function in m

if (wkConfig['m.identity_server']) {
            isUrl = wkConfig['m.identity_server']['base_url'];
        }
    }

    if (serverName) {
        // We also do our own minimal .well-known validation to avoid pulling in the js-sdk
        try {
            const result = await fetch(`https://${serverName}/.well-known/matrix/client`);
            const wkConfig = await result.json();
            if (wkConfig && wkConfig['m.homeserver']) {
                hsUrl = wkConfig['m.homeserver']['base_url'];

                if (wkConfig['m.identity_server']) {
                    isUrl = wkConfig['m.identity_server']['base_url'];
                }
            }
        } catch (e) {
            console.error(e);
            return renderConfigError("Unable to fetch homeserver configuration");
        }
    }

    if (defaultHsUrl) {
        hsUrl = defaultHsUrl;
        isUrl = defaultIsUrl;
    }

    if (!hsUrl) {
        return renderConfigError("Unable to locate homeserver");
    }

export async function sendLoginRequest(hsUrl, isUrl, loginType, loginParams) {
    const client = Matrix.createClient({
        baseUrl: hsUrl,
        idBaseUrl: isUrl,
    });

    const data = await client.login(loginType, loginParams);

    const wellknown = data.well_known;
    if (wellknown) {
        if (wellknown["m.homeserver"] && wellknown["m.homeserver"]["base_url"]) {
            hsUrl = wellknown["m.homeserver"]["base_url"];
            console.log(`Overrode homeserver setting with ${hsUrl} from login response`);
        }
        if (wellknown["m.identity_server"] && wellknown["m.identity_server"]["base_url"]) {
            // TODO: should we prompt here?
            isUrl = wellknown["m.identity_server"]["base_url"];
            console.log(`Overrode IS setting with ${isUrl} from login response`);
        }
    }

    return {
        homeserverUrl: hsUrl,
        identityServerUrl: isUrl,
        userId: data.user_id,
        deviceId: data.device_id,
        accessToken: data.access_token,
    };
}

hsUrl = wkConfig['m.homeserver']['base_url'];

        if (wkConfig['m.identity_server']) {
            isUrl = wkConfig['m.identity_server']['base_url'];
        }
    }

    if (serverName) {
        // We also do our own minimal .well-known validation to avoid pulling in the js-sdk
        try {
            const result = await fetch(`https://${serverName}/.well-known/matrix/client`);
            const wkConfig = await result.json();
            if (wkConfig && wkConfig['m.homeserver']) {
                hsUrl = wkConfig['m.homeserver']['base_url'];

                if (wkConfig['m.identity_server']) {
                    isUrl = wkConfig['m.identity_server']['base_url'];
                }
            }
        } catch (e) {
            console.error(e);
            return renderConfigError("Unable to fetch homeserver configuration");
        }
    }

    if (defaultHsUrl) {
        hsUrl = defaultHsUrl;
        isUrl = defaultIsUrl;
    }

    if (!hsUrl) {
        return renderConfigError("Unable to locate homeserver");

return Promise.resolve(failingClientConfig);
            }

            // Step 5b: Verify there is an identity server listening on the provided
            // URL.
            const isResponse = await this._fetchWellKnownObject(
                `${isUrl}/_matrix/identity/api/v1`,
            );
            if (!isResponse || !isResponse.raw || isResponse.action !== "SUCCESS") {
                logger.error("Invalid /api/v1 response");
                failingClientConfig["m.identity_server"].error =
                    AutoDiscovery.ERROR_INVALID_IDENTITY_SERVER;

                // Supply the base_url to the caller because they may be ignoring
                // liveliness errors, like this one.
                failingClientConfig["m.identity_server"].base_url = isUrl;

                return Promise.resolve(failingClientConfig);
            }
        }

        // Step 6: Now that the identity server is valid, or never existed,
        // populate the IS section.
        if (isUrl && isUrl.length > 0) {
            clientConfig["m.identity_server"] = {
                state: AutoDiscovery.SUCCESS,
                error: null,
                base_url: isUrl,
            };
        }

        // Step 7: Copy any other keys directly into the clientConfig. This is for

"Invalid configuration: can only specify one of default_server_config, default_server_name, " +
            "or default_hs_url.",
        );
    }
    if (incompatibleOptions.length < 1) {
        return renderConfigError("Invalid configuration: no default server specified.");
    }

    let hsUrl = '';
    let isUrl = '';

    if (wkConfig && wkConfig['m.homeserver']) {
        hsUrl = wkConfig['m.homeserver']['base_url'];

        if (wkConfig['m.identity_server']) {
            isUrl = wkConfig['m.identity_server']['base_url'];
        }
    }

    if (serverName) {
        // We also do our own minimal .well-known validation to avoid pulling in the js-sdk
        try {
            const result = await fetch(`https://${serverName}/.well-known/matrix/client`);
            const wkConfig = await result.json();
            if (wkConfig && wkConfig['m.homeserver']) {
                hsUrl = wkConfig['m.homeserver']['base_url'];

                if (wkConfig['m.identity_server']) {
                    isUrl = wkConfig['m.identity_server']['base_url'];
                }
            }
        } catch (e) {

return renderConfigError(
            "Invalid configuration: can only specify one of default_server_config, default_server_name, " +
            "or default_hs_url.",
        );
    }
    if (incompatibleOptions.length < 1) {
        return renderConfigError("Invalid configuration: no default server specified.");
    }

    let hsUrl = '';
    let isUrl = '';

    if (wkConfig && wkConfig['m.homeserver']) {
        hsUrl = wkConfig['m.homeserver']['base_url'];

        if (wkConfig['m.identity_server']) {
            isUrl = wkConfig['m.identity_server']['base_url'];
        }
    }

    if (serverName) {
        // We also do our own minimal .well-known validation to avoid pulling in the js-sdk
        try {
            const result = await fetch(`https://${serverName}/.well-known/matrix/client`);
            const wkConfig = await result.json();
            if (wkConfig && wkConfig['m.homeserver']) {
                hsUrl = wkConfig['m.homeserver']['base_url'];

                if (wkConfig['m.identity_server']) {
                    isUrl = wkConfig['m.identity_server']['base_url'];
                }
            }

_tryDiscoverDefaultHomeserver: async function(serverName) {
        try {
            const discovery = await AutoDiscovery.findClientConfig(serverName);
            const state = discovery["m.homeserver"].state;
            if (state !== AutoDiscovery.SUCCESS) {
                console.error("Failed to discover homeserver on startup:", discovery);
                this.setState({
                    defaultServerDiscoveryError: discovery["m.homeserver"].error,
                    loadingDefaultHomeserver: false,
                });
            } else {
                const hsUrl = discovery["m.homeserver"].base_url;
                const isUrl = discovery["m.identity_server"].state === AutoDiscovery.SUCCESS
                    ? discovery["m.identity_server"].base_url
                    : "https://vector.im";
                this.setState({
                    defaultHsUrl: hsUrl,
                    defaultIsUrl: isUrl,
                    loadingDefaultHomeserver: false,
                });
            }
        } catch (e) {
            console.error(e);
            this.setState({
                defaultServerDiscoveryError: _t("Unknown error discovering homeserver"),
                loadingDefaultHomeserver: false,
            });
        }
    },

discoveryError: discovery["m.homeserver"].error,
                    findingHomeserver: false,
                });
            } else if (state === AutoDiscovery.PROMPT) {
                this.setState({
                    discoveryError: "",
                    findingHomeserver: false,
                });
            } else if (state === AutoDiscovery.SUCCESS) {
                this.setState({
                    discoveryError: "",
                    findingHomeserver: false,
                });
                this.onServerConfigChange({
                    hsUrl: discovery["m.homeserver"].base_url,
                    isUrl: discovery["m.identity_server"].state === AutoDiscovery.SUCCESS
                        ? discovery["m.identity_server"].base_url
                        : "",
                });
            } else {
                console.warn("Unknown state for m.homeserver in discovery response: ", discovery);
                this.setState({
                    discoveryError: _t("Unknown failure discovering homeserver"),
                    findingHomeserver: false,
                });
            }
        } catch (e) {
            console.error(e);
            this.setState({
                findingHomeserver: false,
                discoveryError: _t("Unknown error discovering homeserver"),
            });

findingHomeserver: false,
                });
            } else if (state === AutoDiscovery.PROMPT) {
                this.setState({
                    discoveryError: "",
                    findingHomeserver: false,
                });
            } else if (state === AutoDiscovery.SUCCESS) {
                this.setState({
                    discoveryError: "",
                    findingHomeserver: false,
                });
                this.onServerConfigChange({
                    hsUrl: discovery["m.homeserver"].base_url,
                    isUrl: discovery["m.identity_server"].state === AutoDiscovery.SUCCESS
                        ? discovery["m.identity_server"].base_url
                        : "",
                });
            } else {
                console.warn("Unknown state for m.homeserver in discovery response: ", discovery);
                this.setState({
                    discoveryError: _t("Unknown failure discovering homeserver"),
                    findingHomeserver: false,
                });
            }
        } catch (e) {
            console.error(e);
            this.setState({
                findingHomeserver: false,
                discoveryError: _t("Unknown error discovering homeserver"),
            });
        }

error: "Something went wrong",

            /**
             * The base URL clients should use to talk to the homeserver,
             * particularly for the login process. May be falsey if the
             * state is not AutoDiscovery.SUCCESS.
             */
            base_url: "https://matrix.org",
        };

        /**
         * The identity server configuration the client should use. This
         * will always be present on teh object.
         * @type {{state: string, base_url: string}} The configuration.
         */
        this["m.identity_server"] = {
            /**
             * The lookup result state. If this is anything other than
             * AutoDiscovery.SUCCESS then base_url may be falsey.
             */
            state: AutoDiscovery.PROMPT,

            /**
             * The base URL clients should use for interacting with the
             * identity server. May be falsey if the state is not
             * AutoDiscovery.SUCCESS.
             */
            base_url: "https://vector.im",
        };
    }
}