Function makeChainHub

Make a new ChainHub in the zone (or in the heap if no zone is provided).

The resulting object is an Exo singleton. It has no precious state. It's only state is a cache of queries to agoricNames and whatever info was provided in registration calls. When you need a newer version you can simply make a hub hub and repeat the registrations.

  • makeChainHub(agoricNames, vowTools): Guarded<{
        getAsset(denom: string): undefined | DenomDetail;
        getChainInfo<K>(chainName: K): Vow<ActualChainInfo<K>>;
        getChainsAndConnection<C1, C2>(primaryName: C1, counterName: C2): Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]>;
        getConnectionInfo(primary: string | {
            chainId: string;
        }, counter: string | {
            chainId: string;
        }): Vow<IBCConnectionInfo>;
        getDenom(brand: Brand): undefined | string;
        registerAsset(denom: string, detail: DenomDetail): void;
        registerChain(name: string, chainInfo: Readonly<{
            chainId: string;
            connections?: Record<string, IBCConnectionInfo>;
            icqEnabled?: boolean;
            stakingTokens?: readonly {
                denom: string;
            }[];
        }>): void;
        registerConnection(primaryChainId: string, counterpartyChainId: string, connectionInfo: IBCConnectionInfo): void;
    }>

  • Parameters

    • agoricNames: Remote<NameHub>
    • vowTools: {
          allVows: ((maybeVows: unknown[]) => Vow<any[]>);
          asPromise: AsPromiseFunction;
          asVow: (<T>(fn: ((...args: any[]) => Awaited<T> | Vow<Awaited<T>> | PromiseVow<T>)) => Vow<Awaited<T>>);
          makeVowKit: (<T>() => VowKit<T>);
          retriable: (<F>(fnZone: Zone, name: string, fn: F) => F extends ((...args: Args) => Promise<R>)
              ? ((...args: Args) => Vow<R>)
              : never);
          watch: (<T, TResult1, TResult2, C>(specimenP: EVow<T>, watcher?: Watcher<T, TResult1, TResult2, C>, ...watcherArgs: C) => Vow<Narrowest>);
          when: (<T, TResult1, TResult2>(specimenP: T, onFulfilled?: ((value: EUnwrap<T>) => TResult1 | PromiseLike<TResult1>), onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>)) => Promise<TResult1 | TResult2>);
      }
      • allVows: ((maybeVows: unknown[]) => Vow<any[]>)
          • (maybeVows): Vow<any[]>

          • Vow-tolerant implementation of Promise.all.

            Parameters

            • maybeVows: unknown[]

            Returns Vow<any[]>

      • asPromise: AsPromiseFunction
      • asVow: (<T>(fn: ((...args: any[]) => Awaited<T> | Vow<Awaited<T>> | PromiseVow<T>)) => Vow<Awaited<T>>)
          • <T>(fn): Vow<Awaited<T>>

          • Helper function that coerces the result of a function to a Vow. Helpful for scenarios like a synchronously thrown error.

            Type Parameters

            • T extends unknown

            Parameters

            • fn: ((...args: any[]) => Awaited<T> | Vow<Awaited<T>> | PromiseVow<T>)
                • (...args): Awaited<T> | Vow<Awaited<T>> | PromiseVow<T>

                • Parameters

                  • Rest...args: any[]

                  Returns Awaited<T> | Vow<Awaited<T>> | PromiseVow<T>

            Returns Vow<Awaited<T>>

      • makeVowKit: (<T>() => VowKit<T>)
          • <T>(): VowKit<T>

          • Type Parameters

            • T

            Returns VowKit<T>

      • retriable: (<F>(fnZone: Zone, name: string, fn: F) => F extends ((...args: Args) => Promise<R>)
            ? ((...args: Args) => Vow<R>)
            : never)
          • <F>(fnZone, name, fn): F extends ((...args: Args) => Promise<R>)
                ? ((...args: Args) => Vow<R>)
                : never

          • TODO FIXME make this real Create a function that retries the given function if the underlying functions rejects due to upgrade disconnection.

            Type Parameters

            • F extends ((...args: any[]) => Promise<any>)

            Parameters

            • fnZone: Zone

              the zone for the named function

            • name: string
            • fn: F

            Returns F extends ((...args: Args) => Promise<R>)
                ? ((...args: Args) => Vow<R>)
                : never

      • watch: (<T, TResult1, TResult2, C>(specimenP: EVow<T>, watcher?: Watcher<T, TResult1, TResult2, C>, ...watcherArgs: C) => Vow<Narrowest>)
          • <T, TResult1, TResult2, C>(specimenP, watcher?, ...watcherArgs): Vow<Narrowest>

          • Type Parameters

            • T = any
            • TResult1 = T
            • TResult2 = never
            • C extends any[] = any[]

              watcher args

            Parameters

            Returns Vow<Narrowest>

      • when: (<T, TResult1, TResult2>(specimenP: T, onFulfilled?: ((value: EUnwrap<T>) => TResult1 | PromiseLike<TResult1>), onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>)) => Promise<TResult1 | TResult2>)

    Returns Guarded<{
        getAsset(denom: string): undefined | DenomDetail;
        getChainInfo<K>(chainName: K): Vow<ActualChainInfo<K>>;
        getChainsAndConnection<C1, C2>(primaryName: C1, counterName: C2): Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, IBCConnectionInfo]>;
        getConnectionInfo(primary: string | {
            chainId: string;
        }, counter: string | {
            chainId: string;
        }): Vow<IBCConnectionInfo>;
        getDenom(brand: Brand): undefined | string;
        registerAsset(denom: string, detail: DenomDetail): void;
        registerChain(name: string, chainInfo: Readonly<{
            chainId: string;
            connections?: Record<string, IBCConnectionInfo>;
            icqEnabled?: boolean;
            stakingTokens?: readonly {
                denom: string;
            }[];
        }>): void;
        registerConnection(primaryChainId: string, counterpartyChainId: string, connectionInfo: IBCConnectionInfo): void;
    }>

Settings

Member Visibility