"@gnosis.pm/safe-core-sdk": "^0.3.1",

        "@gnosis.pm/safe-core-sdk-types": "^0.1.1",

        "@gnosis.pm/safe-service-client": "^0.1.1",

    "node_modules/@gnosis.pm/safe-core-sdk": {

      "version": "0.3.1",

      "resolved": "https://registry.npmjs.org/@gnosis.pm/safe-core-sdk/-/safe-core-sdk-0.3.1.tgz",

      "integrity": "sha512-L0na+KSAnicO4B9MtzPu90kwThZ2PHd11CHSRzhJ7l4oIOGB4a/KyPohcOzXTO9Vz3yDIELPlbcW5IEasUk6ag==",

      "dependencies": {

        "@gnosis.pm/safe-core-sdk-types": "^0.1.1",

        "ethereumjs-util": "^7.0.10"

      }

    },

    "node_modules/@gnosis.pm/safe-core-sdk-types": {

      "version": "0.1.1",

      "resolved": "https://registry.npmjs.org/@gnosis.pm/safe-core-sdk-types/-/safe-core-sdk-types-0.1.1.tgz",

      "integrity": "sha512-PghXGDaI5Foq37nZGmI90U2OKMeGtxh5KqkDqou9aFHwGVa/nf9HRQPxG9/XUzcyfe9OlKttDlJnR3XnC3dSDw=="

    },

    "node_modules/@gnosis.pm/safe-service-client": {

      "version": "0.1.1",

      "resolved": "https://registry.npmjs.org/@gnosis.pm/safe-service-client/-/safe-service-client-0.1.1.tgz",

      "integrity": "sha512-7oQxcs1xTYdS+ZxqFPe44zlu7uzF654QNxI8XSMMnQ11sai7jgoMlom0ucRcWLp1cKATYMNA9+yUgPYYmTRgqA==",

      "dependencies": {

        "@gnosis.pm/safe-core-sdk-types": "^0.1.0",

        "axios": "^0.21.1"

      }

    },

    "node_modules/@types/bn.js": {

      "version": "5.1.1",

      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.1.tgz",

      "integrity": "sha512-qNrYbZqMx0uJAfKnKclPh+dTwK33KfLHYqtyODwd5HnXOjnkhc4qgn3BrK6RWyGZm5+sIFE7Q7Vz6QQtJB7w7g==",

      "dependencies": {

        "@types/node": "*"

      }

    },

    "node_modules/axios": {

      "version": "0.21.4",

      "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.4.tgz",

      "integrity": "sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==",

      "dependencies": {

        "follow-redirects": "^1.14.0"

      }

    },

      "integrity": "sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ=="

      "integrity": "sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ=="

    "node_modules/ethereumjs-util": {

      "version": "7.1.5",

      "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz",

      "integrity": "sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==",

      "dependencies": {

        "@types/bn.js": "^5.1.0",

        "bn.js": "^5.1.2",

        "create-hash": "^1.1.2",

        "ethereum-cryptography": "^0.1.3",

        "rlp": "^2.2.4"

      },

      "engines": {

        "node": ">=10.0.0"

      }

    },

    "node_modules/follow-redirects": {

      "version": "1.15.2",

      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",

      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",

      "funding": [

        {

          "type": "individual",

          "url": "https://github.com/sponsors/RubenVerborgh"

        }

      ],

      "engines": {

        "node": ">=4.0"

      },

      "peerDependenciesMeta": {

        "debug": {

          "optional": true

        }

      }

    },

      "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA=="

    "@gnosis.pm/safe-core-sdk": {

      "version": "0.3.1",

      "resolved": "https://registry.npmjs.org/@gnosis.pm/safe-core-sdk/-/safe-core-sdk-0.3.1.tgz",

      "integrity": "sha512-L0na+KSAnicO4B9MtzPu90kwThZ2PHd11CHSRzhJ7l4oIOGB4a/KyPohcOzXTO9Vz3yDIELPlbcW5IEasUk6ag==",

      "requires": {

        "@gnosis.pm/safe-core-sdk-types": "^0.1.1",

        "ethereumjs-util": "^7.0.10"

      }

    },

    "@gnosis.pm/safe-core-sdk-types": {

      "version": "0.1.1",

      "resolved": "https://registry.npmjs.org/@gnosis.pm/safe-core-sdk-types/-/safe-core-sdk-types-0.1.1.tgz",

      "integrity": "sha512-PghXGDaI5Foq37nZGmI90U2OKMeGtxh5KqkDqou9aFHwGVa/nf9HRQPxG9/XUzcyfe9OlKttDlJnR3XnC3dSDw=="

    },

    "@gnosis.pm/safe-service-client": {

      "version": "0.1.1",

      "resolved": "https://registry.npmjs.org/@gnosis.pm/safe-service-client/-/safe-service-client-0.1.1.tgz",

      "integrity": "sha512-7oQxcs1xTYdS+ZxqFPe44zlu7uzF654QNxI8XSMMnQ11sai7jgoMlom0ucRcWLp1cKATYMNA9+yUgPYYmTRgqA==",

      "requires": {

        "@gnosis.pm/safe-core-sdk-types": "^0.1.0",

        "axios": "^0.21.1"

      }

    },

    "@types/bn.js": {

      "version": "5.1.1",

      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.1.tgz",

      "integrity": "sha512-qNrYbZqMx0uJAfKnKclPh+dTwK33KfLHYqtyODwd5HnXOjnkhc4qgn3BrK6RWyGZm5+sIFE7Q7Vz6QQtJB7w7g==",

      "requires": {

        "@types/node": "*"

      }

    },

    "axios": {

      "version": "0.21.4",

      "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.4.tgz",

      "integrity": "sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==",

      "requires": {

        "follow-redirects": "^1.14.0"

      }

    },

      "integrity": "sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ=="

      "integrity": "sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ=="

    "ethereumjs-util": {

      "version": "7.1.5",

      "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz",

      "integrity": "sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==",

      "requires": {

        "@types/bn.js": "^5.1.0",

        "bn.js": "^5.1.2",

        "create-hash": "^1.1.2",

        "ethereum-cryptography": "^0.1.3",

        "rlp": "^2.2.4"

      }

    },

    "follow-redirects": {

      "version": "1.15.2",

      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",

      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA=="

    },

      "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA=="

    "@gnosis.pm/safe-core-sdk": "^0.3.1",

    "@gnosis.pm/safe-core-sdk-types": "^0.1.1",

    "@gnosis.pm/safe-service-client": "^0.1.1",

  import TransferOwnership from "@app/components/TransferOwnership.svelte";

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

  import { getBalance, Profile, ProfileType } from "@app/profile";

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

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

  let transferOwnerForm: typeof SvelteComponent | null = null;

  const transferOwnership = () => {

    transferOwnerForm = TransferOwnership;

  };

  $: account = $session && $session.address;

  $: isOwner = (org: Org): boolean =>

    $session ? utils.isAddressEqual(org.owner, $session.address) : false;

  $: getOrgTreasury = async (

    org: Org,

  ): Promise<Array<utils.Token> | undefined> => {

    const addressType = await utils.identifyAddress(org.owner, config);

    // We query the org treasury only for Gnosis Safes, to maintain some privacy for EOA org owners.

    if (addressType === utils.AddressType.Safe) {

      try {

        const tokens = await utils.getTokens(org.owner, config);

        const balance = await getBalance(org.owner, config);

        if (!balance.isZero()) {

          // To maintain the format we hardcode the ETH specs.

          return [

            {

              balance,

              decimals: 18,

              logo: "",

              name: "Ethereum",

              symbol: "ETH",

            },

            ...tokens,

          ];

        } else {

          return tokens;

        }

      } catch (e) {

        console.error(e);

      }

    }

  };

  $: isOrgAuthorized = async (org: Org): Promise<boolean> => {

    if ($session) {

      if (isOwner(org)) {

        return true;

      }

      return await org.isMember($session.address, config);

    }

    return false;

  };

  .members {

    margin-top: 2rem;

    align-items: center;

    display: flex;

    flex-wrap: wrap;

  }

  .members.loading {

    padding-bottom: 1rem;

  }

  .members .member {

    display: flex;

    align-items: center;

    margin-right: 2rem;

    margin-bottom: 1rem;

  }

  .members .member:last-child {

    margin-right: 0;

  }

  .members .member-icon {

    width: 2rem;

    height: 2rem;

    margin-right: 1rem;

  }

    .members .member {

      margin-right: 1rem;

    }

        <div class="desktop">

          {#await account && profile.org.isMember(account, config) then isMember}

            {#if isOwner(profile.org) || isMember}

              <Button

                variant="secondary"

                size="small"

                on:click={transferOwnership}>

                Transfer

              </Button>

            {/if}

          {/await}

        </div>

        <!-- Org Treasury -->

        {#await getOrgTreasury(profile.org) then tokens}

          {#if tokens && tokens.length > 0}

            <div class="label">Treasury</div>

            <div>

              {#each tokens as token}

                {` ${utils.formatBalance(token.balance, token.decimals)} ${

                  token.symbol

                } `}

              {/each}

            </div>

            <div class="desktop" />

          {/if}

        {/await}

          <div class="desktop">

            {#await isOrgAuthorized(profile.org)}

              <!-- Loading -->

            {:then authorized}

              {#if authorized}

                <Button variant="secondary" size="small" on:click={setName}>

                  Set

                </Button>

              {/if}

            {/await}

          </div>

        <!-- Quorum -->

        {#await profile.org.getSafe(config) then safe}

          {#if safe}

            <div class="label">Quorum</div>

            <div>

              {safe.threshold}

              <span class="faded">of</span>

              {safe.owners.length}

            </div>

            <div class="desktop" />

          {/if}

        {/await}

          {#if isUserAuthorized(profile.address)}

    {#if profile.org}

      {#await profile.org.getMembers(config)}

        <Loading center />

      {:then members}

        {#if members.length > 0}

          <!-- We don't need to catch errors here, since it's not defined by user input and defaults to ETH addresses -->

          {#await Profile.getMulti(members, config)}

            <div class="members loading">

              <Loading small />

            </div>

          {:then members}

            <div class="members">

              {#each members as profile}

                <div class="member">

                  <div class="member-icon">

                    <Link to="/{profile.address}">

                      <Avatar

                        source={profile.avatar ?? profile.address}

                        title={profile.address} />

                    </Link>

                  </div>

                  <div class="desktop">

                    <Address

                      address={profile.address}

                      compact

                      resolve

                      noBadge

                      noAvatar

                      {profile}

                      {config} />

                  </div>

                </div>

              {/each}

            </div>

          {/await}

        {/if}

      {:catch err}

        <Message error>

          <span class="txt-bold">Error:</span>

          failed to load org members: {err.message}.

        </Message>

      {/await}

    {:else}

      {#await Org.getOrgsByMember(profile.address, config)}

        <Loading center />

      {:then orgs}

        {#if orgs.length > 0}

          <div class="members">

            {#each orgs as org}

              <div class="member">

                <!-- We don't need to catch errors here, since it's not defined by user input and defaults to ETH addresses -->

                {#await Profile.get(org.address, ProfileType.Minimal, config)}

                  <Loading small margins />

                {:then profile}

                  <div class="member-icon">

                    <Link to="/{profile.address}">

                      <Avatar

                        source={profile.avatar ?? profile.address}

                        title={profile.address} />

                    </Link>

                  </div>

                  <div class="desktop">

                    <Address

                      address={profile.address}

                      compact

                      resolve

                      noBadge

                      noAvatar

                      {profile}

                      {config} />

                  </div>

                {/await}

              </div>

            {/each}

          </div>

        {/if}

      {:catch err}

        <Message error>

          <span class="txt-bold">Error:</span>

          failed to load orgs: {err.message}.

        </Message>

      {/await}

    {/if}

    entity={profile.org ?? new User(profile.address)}

  <svelte:component

    this={transferOwnerForm}

    org={profile.org}

    {config}

    on:close={() => (transferOwnerForm = null)} />

import type { TransactionResponse } from "@ethersproject/providers";

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

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

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

import type { Safe } from "@app/utils";

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

  safe?: Safe | null;

  constructor(

    address: string,

    owner: string,

    name?: string | null,

    safe?: Safe | null,

  ) {

    this.safe = safe;

  }

  async setName(name: string, config: Config): Promise<TransactionResponse> {

    assert(config.signer);

    const org = new ethers.Contract(

      this.address,

      config.abi.org,

      config.signer,

    );

    return org.setName(name, config.provider.network.ensAddress, {

      gasLimit: 200_000,

    });

  }

  async setNameMultisig(name: string, config: Config): Promise<void> {

    assert(config.signer);

    assert(config.safe.client);

    const safeAddress = ethers.utils.getAddress(this.owner);

    const orgAddress = ethers.utils.getAddress(this.address);

    const org = new ethers.Contract(

      this.address,

      config.abi.org,

      config.signer,

    );

    const unsignedTx = await org.populateTransaction.setName(

      name,

      config.provider.network.ensAddress,

    );

    const txData = unsignedTx.data;

    if (!txData) {

      throw new Error(

        "Org::setNameMultisig: Could not generate transaction for `setName` call",

      );

    }

    const safeTx = {

      to: orgAddress,

      value: ethers.constants.Zero.toString(),

      data: txData,

      operation: OperationType.Call,

    };

    await utils.proposeSafeTransaction(safeTx, safeAddress, config);

  }

  async setOwner(

    address: string,

    config: Config,

  ): Promise<TransactionResponse> {

    assert(config.signer);

    const org = new ethers.Contract(

      this.address,

      config.abi.org,

      config.signer,

    );

    return org.setOwner(address);

  }

  async setOwnerMultisig(owner: string, config: Config): Promise<void> {

    assert(config.signer);

    assert(config.safe.client);

    const safeAddress = ethers.utils.getAddress(this.owner);

    const orgAddress = ethers.utils.getAddress(this.address);

    const org = new ethers.Contract(

      this.address,

      config.abi.org,

      config.signer,

    );

    const unsignedTx = await org.populateTransaction.setOwner(owner);

    const txData = unsignedTx.data;

    if (!txData) {

      throw new Error(

        "Org::setOwnerMultisig: Could not generate transaction for `setOwner` call",

      );

    }

    const safeTx = {

      to: orgAddress,

      value: ethers.constants.Zero.toString(),

      data: txData,

      operation: OperationType.Call,

    };

    await utils.proposeSafeTransaction(safeTx, safeAddress, config);

  }

  async getMembers(config: Config): Promise<Array<string>> {

    if (this.safe) return this.safe.owners;

    const safe = await this.getSafe(config);

    if (safe) {

      return safe.owners;

    }

    return [];

  }

  async getSafe(config: Config): Promise<Safe | null> {

    if (this.safe) return this.safe;

    return utils.getSafe(this.owner, config);

  }

  async isMember(address: string, config: Config): Promise<boolean> {

    const members = await this.getMembers(config);

    return members.includes(address.toLowerCase());

      const safe = await utils.getSafe(owner, config);

        return new Org(resolved, owner, null, safe);

        return new Org(resolved, owner, addressOrName, safe);

  static async getOrgsByMember(

    _owner: string,

    _config: Config,

  ): Promise<Org[]> {

    return [];

  }

  // TODO: When transfering name, warn about transfering to org.

<script lang="ts" strictEvents>

  import type { Org } from "@app/base/orgs/Org";

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

  import { createEventDispatcher } from "svelte";

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

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

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

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

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

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

  import { formatAddress, isAddress } from "@app/utils";

  export let org: Org;

  export let config: Config;

  const dispatch = createEventDispatcher<{ close: boolean }>();

  let state:

    | "idle"

    // Single sig.

    | "signing"

    | "pending"

    | "success"

    // Multi sig.

    | "proposing"

    | "proposed"

    | "failed" = "idle";

  let newOwner: string = "";

  let errorMessage: string | null = null;

  let valid: boolean = false;

  let validationMessage: string | undefined = undefined;

  const onSubmit = async () => {

    if (!valid) {

      return;

    }

    try {

      if (org && (await utils.isSafe(org.owner, config))) {

        state = "proposing";

        await org.setOwnerMultisig(newOwner, config);

        state = "proposed";

      } else {

        state = "signing";

        const tx = await org.setOwner(newOwner, config);

        state = "pending";

        await tx.wait();

        state = "success";

      }

    } catch (error: unknown) {

      if (error instanceof Error) {

        errorMessage = error.message;

      } else {

        errorMessage = "Unknown error.";

      }

      console.error(error);

      state = "failed";

    }

  };

  function validate(address: string) {

    if (address === "") {

      return { valid: false };

    }

    if (state !== "idle") {

      return { valid: false };

    }

    if (!isAddress(address)) {

      return {

        valid: false,

        validationMessage: "Please enter a valid Ethereum address.",

      };

    }

    return { valid: true };

  }

  $: ({ valid, validationMessage } = validate(newOwner));

</script>

<style>

  .actions {

    gap: 1rem;

    display: flex;

    justify-content: center;

    margin-top: 2rem;

  }

  .message {

    padding-left: 1rem;

    padding-top: 1rem;

    word-break: break-all;

  }

</style>

{#if state === "success" && newOwner}

  <Modal floating small>

    <div slot="title">✅</div>

    <div slot="subtitle">

      The ownership of <span class="txt-bold">

        {formatAddress(org.address)}

      </span>

      was successfully transfered to

      <span class="txt-bold">{newOwner}</span>

      .

    </div>

    <div slot="actions">

      <Button variant="secondary" on:click={() => dispatch("close")}>

        Done

      </Button>

    </div>

  </Modal>

{:else if state === "proposed" && org}

  <Modal floating>

    <div slot="title">🪴</div>

    <div slot="subtitle">

      <p>

        The transaction to set the owner of <span class="txt-bold">

          {formatAddress(org.address)}

        </span>

        to

        <span class="txt-bold">{newOwner}</span>

        was proposed to:

      </p>

      <p><Address address={org.owner} {config} compact /></p>

    </div>

    <div slot="actions">

      <Button variant="secondary" on:click={() => dispatch("close")}>

        Done

      </Button>

    </div>

  </Modal>

{:else if state === "failed"}

  <Modal floating error small>

    <div slot="title">

      🔑

      <div>Transfer ownership</div>

    </div>

    <div slot="subtitle">

      <div class="message">

        {errorMessage}

      </div>

    </div>

    <div slot="actions" class="actions">

      <Button

        variant="negative"

        on:click={() => {

          state = "idle";

        }}>

        Back

      </Button>

    </div>

  </Modal>

{:else}

  <Modal floating>

    <div slot="title">

      🔑

      <div>Transfer ownership</div>

    </div>

    <div slot="subtitle">

      {#if state === "signing"}

        Please confirm the transaction in your wallet.

      {:else if state === "pending"}

        Waiting for transaction to be processed…

      {:else if state === "proposing" && org}

        Proposal is being submitted to the safe

        <span class="txt-bold">{formatAddress(org.owner)}</span>

        , please sign the transaction in your wallet.

      {:else if state === "idle"}

        Transfer the ownership of Org <span class="txt-bold">

          {formatAddress(org.address)}

        </span>

        to a new address.

      {/if}

    </div>

    <div slot="body" style="display: flex;justify-content: center;">

      {#if state === "idle"}

        <div style="position: absolute; text-align: left;">

          <div style="width: 31rem;">

            <TextInput

              autofocus

              {valid}

              {validationMessage}

              on:submit={onSubmit}

              disabled={state !== "idle"}

              bind:value={newOwner} />

          </div>

        </div>

      {:else if state === "pending" || state === "proposing" || state === "signing"}

        <Loading small center />

      {/if}

    </div>

    <div slot="actions" class="actions">

      {#if state === "signing"}

        <Button variant="text" on:click={() => dispatch("close")}>

          Cancel

        </Button>

      {:else if state === "pending"}

        <Button variant="text" on:click={() => dispatch("close")}>Close</Button>

      {:else}

        <Button variant="primary" on:click={onSubmit} disabled={!valid}>

          Submit

        </Button>

        <Button variant="text" on:click={() => dispatch("close")}>

          Cancel

        </Button>

      {/if}

    </div>

  </Modal>

{/if}

    "orgFactory": {

      "address": "0xa15bEb4876F20018b6b4A4116B7560c5fcC9336e"

    },

    "orgs": {

      "contractHash": "0x5c34bb0755876de98e801805e6685456eea739ad0abba1cc450a7ee0f2a70b74",

      "pinned": [

        "alt-clients.radicle.eth",

        "community.radicle.eth",

        "upstream.radicle.eth",

        "gnosisguild.radicle.eth",

        "grants.radicle.eth",

        "gip-editors.radicle.eth",

        "dxdao.radicle.eth"

      ]

    },

    "orgFactory": {

      "address": "0xF3D04e874D07d680e8b26332eEae5b9B1c263121"

    },

    "orgs": {

      "contractHash": "0x5c34bb0755876de98e801805e6685456eea739ad0abba1cc450a7ee0f2a70b74",

      "pinned": []

    },

    "orgFactory": [

      "function createOrg(address) returns (address)",

      "function createOrg(address[], uint256) returns (address)",

      "event OrgCreated(address, address)"

    ],

    "org": [

      "function owner() view returns (address)",

      "function setOwner(address)",

      "function setName(string, address) returns (bytes32)"

    ],

import SafeServiceClient from "@gnosis.pm/safe-service-client";

/// Gas limits for various transactions.

const gasLimits = {

  createOrg: 1_200_000,

};

  orgFactory: { address: string };

  orgs: { contractHash: string; pinned: string[] };

  gasLimits: { createOrg: number };

    client?: SafeServiceClient;

    this.orgFactory = cfg.orgFactory;

    this.orgs = cfg.orgs;

    this.safe.client = this.safe.api

      ? new SafeServiceClient(this.safe.api)

      : undefined;

    this.gasLimits = gasLimits;

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

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

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

  export let entity: Org | User;

  const org = Org.hasOwnProperty.call(entity, "owner") ? (entity as Org) : null;

  const label = org ? "org" : "profile";

    // Single-sig states.

    // Multi-sig states.

    Proposing,

    Proposed,

        if (org && (await utils.isSafe(org.owner, config))) {

          state = State.Proposing;

          await org.setNameMultisig(domain, config);

          state = State.Proposed;

        } else {

          state = State.Signing;

          const tx = await entity.setName(domain, config);

          state = State.Pending;

          await tx.wait();

          state = State.Success;

        }

{:else if state === State.Proposed && org}

  <Modal floating>

    <div slot="title">🪴</div>

    <div slot="subtitle">

      <p>

        The transaction to set the ENS name for <span class="txt-bold">

          {formatAddress(entity.address)}

        </span>

        to

        <span class="txt-bold">{name}.{config.registrar.domain}</span>

        was proposed to:

      </p>

      <p><Address address={org.owner} {config} compact /></p>

    </div>

    <div slot="actions">

      <Button variant="secondary" on:click={() => dispatch("close")}>

        Done

      </Button>

    </div>

  </Modal>

      {:else if state === State.Proposing && org}

        Proposal is being submitted

        <span class="txt-bold">{formatAddress(org.owner)}</span>

        , please sign the transaction in your wallet.

        {label}, such as a unique name, avatar and URL, and help make your {label}

// This shim is used as a stand-in for the node "stream" library, used by

// the "keccack" package depended on by @gnosis.pm/safe-core-sdk.

import * as streams from "@stardazed/streams";

// "Transform" is the old name for "TransformStream".

export const Transform = streams.TransformStream;

export default streams;

import type { TransactionResult } from "@gnosis.pm/safe-core-sdk";

import EthersSafe, { EthersAdapter } from "@gnosis.pm/safe-core-sdk";

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

  const safe = await isSafe(address, config);

  if (safe) {

    return AddressType.Safe;

  }

    if (ethers.utils.keccak256(bytes) === config.orgs.contractHash) {

      return AddressType.Org;

    }

// Check whether a Gnosis Safe exists at an address.

export async function isSafe(

  _address: string,

  _config: Config,

): Promise<boolean> {

  return false;

}

// Get a Gnosis Safe at an address.

export async function getSafe(

  _address: string,

  _config: Config,

): Promise<Safe | null> {

  return null;

}

// Propose a Gnosis Safe multi-sig transaction.

export async function proposeSafeTransaction(

  safeTx: SafeTransaction,

  safeAddress: string,

  config: Config,

): Promise<void> {

  assert(config.signer);

  assert(config.safe.client);

  const ethAdapter = new EthersAdapter({

    ethers,

    signer: config.signer,

  });

  const safeSdk = await EthersSafe.create({

    ethAdapter,

    safeAddress,

  });

  const estimation = await config.safe.client.estimateSafeTransaction(

    safeAddress,

    safeTx,

  );

  const transaction = await safeSdk.createTransaction({

    ...safeTx,

    safeTxGas: Number(estimation.safeTxGas),

  });

  const safeTxHash = await safeSdk.getTransactionHash(transaction);

  const signature = await safeSdk.signTransactionHash(safeTxHash);

  await config.safe.client.proposeTransaction(

    safeAddress,

    transaction.data,

    safeTxHash,

    signature,

  );

}

// Sign a Gnosis Safe multi-sig transaction.

export async function signSafeTransaction(

  safeAddress: string,

  safeTxHash: string,

  config: Config,

): Promise<SafeSignature> {

  assert(config.signer);

  const ethAdapter = new EthersAdapter({

    ethers,

    signer: config.signer,

  });

  const safeSdk = await EthersSafe.create({

    ethAdapter,

    safeAddress,

  });