import { link } from 'svelte-routing';

  import { ethers } from 'ethers';

  import { safeLink, explorerLink, identifyAddress, formatAddress, AddressType, parseEnsLabel } from '@app/utils';

  import Loading from '@app/Loading.svelte';

  import Avatar from "@app/Avatar.svelte";

  import type { Config } from '@app/config';

  onMount(async () => {

    identifyAddress(address, config).then((t: AddressType) => addressType = t);

    if (resolve && !profile) {

    }

  });

  $: addressLabel = profile?.name ? compact ? parseEnsLabel(profile.name, config) : profile.name : checksumAddress;

  import Logo from '@app/Logo.svelte';

  import Connect from '@app/Connect.svelte';

  import type { Config } from '@app/config';

  import Avatar from "./Avatar.svelte";

  export let session: Session | null;

        on:mouseout={() => sessionButtonHover = false}

        on:blur={() => sessionButtonHover = false}

      >

          <Loading small center />

        {:then profile}

          {#if sessionButtonHover}

import type { ContractReceipt } from '@ethersproject/contracts';

import { OperationType } from "@gnosis.pm/safe-core-sdk-types";

import { assert } from '@app/error';

import * as utils from '@app/utils';

import type { Config } from '@app/config';

    return projects;

  }

  }

  static async getAnchor(orgAddr: string, urn: string, config: Config): Promise<string | null> {

  // Return the org profile if there is one, otherwise try to get the profile

  // of its owner.

    if (profile.ens) { // Orgs only use ENS for profile information.

      return profile;

    const org = await Org.get(address, config);

    if (org) {

      if (ownerProfile.ens || ownerProfile.idx) {

        return ownerProfile;

  import { Org } from '@app/base/orgs/Org';

  import TransferOwnership from '@app/base/orgs/TransferOwnership.svelte';

  export let address: string;

  export let config: Config;

{:then org}

  {#if org}

    <main>

        <div class="centered">

          <Loading center />

        </div>

          {#if members.length > 0}

            <div class="members">

              {#each members as address}

                  <Loading small />

                {:then profile}

                  <div class="member">

<script lang="ts">

  import { navigate } from 'svelte-routing';

  import type { Config } from '@app/config';

  import * as proj from '@app/project';

  import Loading from '@app/Loading.svelte';

  import Address from '@app/Address.svelte';

  export let commit: string;

  export let config: Config;

  export let path: string;

  // When the component is loaded the first time, the blob is yet to be loaded.

  let state: State = { status: Status.Idle };

    const blob = await loadBlob(path);

    getBlob = new Promise(resolve => resolve(blob));

  };

  const fetchTree = async (path: string) => {

  // This is reactive to respond to path changes that don't originate from this

  // component, eg. when using the browser's "back" button.

  $: getBlob = loadBlob(path);

  $: loadingPath = state.status == Status.Loading ? state.path : null;

</script>

        </div>

      {/if}

      <div class="anchor">

          {#await getAnchor}

            <Loading small margins />

          {:then anchor}

            {#if anchor === commit}

              <span class="anchor-widget">

                <span class="anchor-label">anchored</span>

              </span>

            {:else}

              <span class="anchor-widget not-anchored">

  import Modal from '@app/Modal.svelte';

  import Avatar from '@app/Avatar.svelte';

  import { Org } from '@app/base/orgs/Org';

  import Browser from './Browser.svelte';

  export let path: string;

  let projectRoot = proj.path({ urn, org, commit });

    if (org) {

    } else {

      resolve(null);

    }

    const cfg = seed ? config.withSeed(seed) : config;

    const info = await proj.getInfo(urn, cfg);

  });

  const back = () => window.history.back();

      <div class="urn">{urn}</div>

      <div class="description">{result.project.meta.description}</div>

    </header>

      commit={commit || result.project.head}

      config={result.config} />

  {:catch}

      .then(async r => {

        if (r) {

          let reverseRecord = false;

          }

          fields = [

                  + "For this name to be correctly associated with the address, "

                  + "a reverse record should be set."

              ),

            { name: "url", label: "URL", validate: "url", placeholder: "https://acme.org",

              description: "A homepage or other URL associated with this name.",

            { name: "avatar", validate: "url", placeholder: "https://acme.org/avatar.png",

              description: "An avatar or square image associated with this name.",

            { name: "twitter", validate: "handle", placeholder: "Twitter username, eg. 'acme'",

              description: "The Twitter handle associated with this name.",

            { name: "github", validate: "handle", label: "GitHub", placeholder: "GitHub username, eg. 'acme'",

              description: "The GitHub username associated with this name.",

            { name: "seed.id", label: "Seed ID", placeholder: "hynkyn...3nrzc@seed.acme.org:8887",

              description: "The ID of a Radicle Link node that hosts entities associated with this name.",

            { name: "seed.api", label: "Seed API", validate: "url", placeholder: "https://seed.acme.org:8888",

              description: "The HTTP address of a node that serves Radicle entities over HTTP.",

          ];

          state = { status: Status.Found, registration: r };

        } else {

import { assert } from '@app/error';

export interface Registration {

  owner: string;

  address: string | null;

  seedId: string | null;

  seedApi: string | null;

  avatar: string | null;

  twitter: string | null;

  github: string | null;

}

export enum State {

    meta.map(r => r.status == "fulfilled" ? r.value : null);

  return {

    owner,

    resolver,

  };

}

export function registrar(config: Config): ethers.Contract {

  return new ethers.Contract(config.registrar.address, config.abi.registrar, config.provider);

}

  import Icon from '@app/Icon.svelte';

  import Address from '@app/Address.svelte';

  import Avatar from '@app/Avatar.svelte';

  import Loading from '@app/Loading.svelte';

  import { Org } from '@app/base/orgs/Org';

  import Message from '@app/Message.svelte';

  }

</style>

  <Loading fadeIn />

{:then profile}

  <main>

import { ethers } from "ethers";

import type { BasicProfile } from "@ceramicstudio/idx-constants";

import {

  formatCAIP10Address, formatIpfsFile, resolveEnsProfile, resolveIdxProfile, parseUsername,

import type { Config } from "./config";

export interface IProfile {

  idx: BasicProfile | null;

}

export class Profile {

  profile: IProfile;

  address: string;

  }

  // Get the ENS profile

    return this.profile.ens;

  }

  }

  // Keeping this function private since the desired entrypoint is .get()

    const profile: IProfile = { ens: null, idx: null };

    try {

    try {

      const [ens, idx] = await Promise.allSettled([

        resolveIdxProfile(formatCAIP10Address(address, "eip155", config.network.chainId), config)

      ]);

  }

  static async getMulti(addresses: string[], config: Config): Promise<Profile[]> {

    const profiles = await Promise.all(profilePromises);

    return profiles.map(profile => { return new Profile(...profile); });

  }

  static async get(

    address: string,

    config: Config,

  ): Promise<Profile> {

    return new Profile(...profile);

  }

}

import type { Config } from '@app/config';

import config from "@app/config.json";

import { assert } from '@app/error';

import type { BasicProfile } from "@ceramicstudio/idx-constants";

export enum AddressType {

  Contract,

}

// Resolves an ENS profile or return null

  const name = await config.provider.lookupAddress(address);

  if (name) {

  }

  return null;

}