const loadConfig = getConfig().then(async cfg => {

    if ($state.connection === Connection.Connected) {

    } else if ($state.connection === Connection.Disconnected) {

      // Update the session state if we're already connected to WalletConnect

      // from a previous session.

      if (!amount || amount === "0") { return [false, "Not able to withdraw zero tokens"]; }

      if (toWei(amount).gt(maxWithdrawAmount)) return [false, `Reduce amount, max withdrawal is ${formatEther(maxWithdrawAmount)}`];

      let currentTime = new Date().getTime();

      // Converting a 10 digit to 13 digit timestamp by multiplying by 1000

      // since JS doesn't display a correct Date string when passing a 10 digit timestamp.

      let nextAvailableWithdraw = lastWithdrawal.add(timelock).mul(1000);

  }

  $: if ($session) {

  }

</script>

    try {

      if ($session) {

        state.status = Status.Signing;

        state.status = Status.Pending;

        await tx.wait();

        state.status = Status.Success;

      </span>

      <!-- User Session -->

      <div class="siwe">

          {#if siweSession}

            <div class="session-info">

              <span class="signed-in text-small">Signed in as</span>

  state.set(State.Withdrawing);

  await tx.wait();

  state.set(State.Withdrawn);

}

import type { Readable } from "svelte/store";

import type { BigNumber } from 'ethers';

import type { TransactionReceipt, TransactionResponse } from '@ethersproject/providers';

import { Unreachable, assert, assertEq } from "@app/error";

import type { TypedDataSigner } from '@ethersproject/abstract-signer';

import type { WalletConnectSigner } from "./WalletConnectSigner";

  | { state: 'fail'; hash: string; blockHash: string; blockNumber: number; error: string }

  | null;

// Defines the type of signer we are using in the current session.

// Allows us to guard certain functionality for a specific signer.

  MetaMask

}

export type State =

    { connection: Connection.Disconnected }

  | { connection: Connection.Connecting }

export interface Session {

  address: string;

  siwe: { [key: string]: SeedSession };

  tokenBalance: BigNumber | null; // `null` means it isn't loaded yet.

  tx: TxState;

  connectWalletConnect(config: Config): Promise<void>;

  updateBalance(n: BigNumber): void;

  connectSeed(seed: { id: string; session: SeedSession }): void;

  setTxSigning(): void;

  setTxPending(tx: TransactionResponse): void;

  setTxConfirmed(tx: TransactionReceipt): void;

  setChangedAccount(address: string, signer: Signer): void;

}

export const loadState = (initial: State): Store => {

  const store = writable<State>(initial);

  // Loads from localStorage all active seed sessions.

  return {

    subscribe: store.subscribe,

    connectMetamask: async (config: Config) => {

      assert(config.metamask.signer);

      // We use config.metamask.signer here, because config.signer is still null on page reload.

      const signer = config.metamask.signer;

      // Re-connect using previous session.

      if (config.metamask.connected) {

        const metamask = config.metamask.session;

        const tokenBalance: BigNumber = await config.token.balanceOf(metamask.address);

        store.set({ connection: Connection.Connected, session });

        config.setSigner(signer);

      config.setSigner(signer);

      try {

        config.walletConnect.state.set({ state: "close" });

        const tokenBalance: BigNumber = await config.token.balanceOf(address);

        store.set({

          connection: Connection.Connected,

    },

    connectWalletConnect: async (config: Config) => {

      store.set({ connection: Connection.Connecting });

      // We fetch the walletConnect signer here, because config.signer is still null on page reload.

      const signer = config.getWalletConnectSigner();

        await config.walletConnect.client.connect();

        console.log("WalletConnect: connected.");

        const tokenBalance: BigNumber = await config.token.balanceOf(address);

        const network = ethers.providers.getNetwork(

          signer.walletConnect.chainId

        );

          }

          try {

            // Check the current chainId, and request Metamask to change, or reload the window to get the correct chain.

            if (chainId !== config.network.chainId) {

                await window.ethereum.request({

                  method: 'wallet_switchEthereumChain',

                  params: [{ chainId: ethers.utils.hexValue(chainId) }]

                });

              } else {

                window.location.reload();

              }

            }

      });

    },

      const state = get(store);

      const addr = state.session.address;

      try {

        state.session.tokenBalance = tokenBalance;

        store.set(state);

            // In case of locking Metamask the accountsChanged event returns undefined.

            // To prevent out of sync state, the wallet gets disconnected.

            if (address === undefined) {

              disconnectMetamask();

            } else {

              s.session.address = address;

              // We only save the session to localStorage if we use a MetaMask signer

              // WalletConnect does their own session persistance.

            }

            return s;

          default:

// Updates state when user changes accounts

window.ethereum?.on("accountsChanged", async ([address]: string) => {

  // Only allow user to change accounts with Metamask if they are connected with Metamask.

    return;

  }

});

export async function changeAccounts(address: string, signer: Signer): Promise<void> {

  state.setChangedAccount(address, signer);

}

export function loadSeedSessions(): { [key: string]: SeedSession } {