@agoric/orchestration 0.1.1-calypso-dev-84eb287.0

package/src/internal.d.ts

@@ -0,0 +1,13 @@
+import type { Vow } from '@agoric/vow';
+/**
+ * Converts a function type that returns a Promise to a function type that
+ * returns a Vow. If the input is not a function returning a Promise, it
+ * preserves the original type.
+ *
+ * @template T - The type to transform
+ */
+export type PromiseToVow<T> = T extends (...args: infer Args) => Promise<infer R> ? (...args: Args) => Vow<R> : T extends (...args: infer Args) => infer R ? (...args: Args) => R : T;
+export type VowifyAll<T> = {
+    [K in keyof T]: PromiseToVow<T[K]>;
+};
+//# sourceMappingURL=internal.d.ts.map

package/src/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,CACtC,GAAG,IAAI,EAAE,MAAM,IAAI,KAChB,OAAO,CAAC,MAAM,CAAC,CAAC,GACjB,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,GACzB,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,IAAI,KAAK,MAAM,CAAC,GACxC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,GACpB,CAAC,CAAC;AAER,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;KACxB,CAAC,IAAI,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACnC,CAAC"}

package/src/internal.ts

@@ -0,0 +1,20 @@
+import type { Vow } from '@agoric/vow';
+
+/**
+ * Converts a function type that returns a Promise to a function type that
+ * returns a Vow. If the input is not a function returning a Promise, it
+ * preserves the original type.
+ *
+ * @template T - The type to transform
+ */
+export type PromiseToVow<T> = T extends (
+  ...args: infer Args
+) => Promise<infer R>
+  ? (...args: Args) => Vow<R>
+  : T extends (...args: infer Args) => infer R
+    ? (...args: Args) => R
+    : T;
+
+export type VowifyAll<T> = {
+  [K in keyof T]: PromiseToVow<T[K]>;
+};

package/src/orchestration-api.d.ts

@@ -0,0 +1,158 @@
+/**
+ * @file General API of orchestration
+ * - must not have chain-specific types without runtime narrowing by chain id
+ * - should remain relatively stable.
+ */
+import type { Amount, Brand, NatAmount, Payment } from '@agoric/ertp/src/types.js';
+import type { LocalChainAccount } from '@agoric/vats/src/localchain.js';
+import type { Timestamp } from '@agoric/time';
+import type { ChainInfo, CosmosChainAccountMethods, CosmosChainInfo, IBCMsgTransferOptions, KnownChains } from './types.js';
+/**
+ * A denom that designates a path to a token type on some blockchain.
+ *
+ * Multiple denoms may designate the same underlying base denom (e.g., `uist`,
+ * `uatom`) on different Chains or on the same Chain via different paths. On
+ * Cosmos chains, all but the base denom are IBC style denoms, but that may vary
+ * across other chains. All the denoms that designate the same underlying base
+ * denom form an equivalence class, along with the unique Brand on the local
+ * Chain. Some operations accept any member of the equivalence class to
+ * effectively designate the corresponding token type on the target chain.
+ */
+export type Denom = string;
+/**
+ * In many cases, either a denom string or a local Brand can be used to
+ * designate a remote token type.
+ */
+export type DenomArg = Denom | Brand;
+/**
+ * Count of some fungible token on some blockchain.
+ *
+ * @see {@link Orchestrator.asAmount} to convert to an Amount surjectively
+ */
+export type DenomAmount = {
+    denom: Denom;
+    value: bigint;
+};
+/** Amounts can be provided as pure data using denoms or as ERTP Amounts */
+export type AmountArg = DenomAmount | Amount;
+/** An address on some blockchain, e.g., cosmos, eth, etc. */
+export type ChainAddress = {
+    /** e.g. 1 for Ethereum, agoric-3 for Agoric, cosmoshub-4 for Cosmos */
+    chainId: string;
+    address: string;
+    addressEncoding: 'bech32' | 'ethereum';
+};
+export type OrchestrationAccount<CI extends ChainInfo> = OrchestrationAccountI & (CI extends CosmosChainInfo ? CosmosChainAccountMethods<CI> : never);
+/**
+ * An object for access the core functions of a remote chain.
+ *
+ * Note that "remote" can mean the local chain; it's just that
+ * accounts are treated as remote/arms length for consistency.
+ */
+export interface Chain<CI extends ChainInfo> {
+    getChainInfo: () => Promise<CI>;
+    /**
+     * Creates a new account on the remote chain.
+     * @returns an object that controls a new remote account on Chain
+     */
+    makeAccount: () => Promise<OrchestrationAccount<CI>>;
+}
+/**
+ * Provided in the callback to `orchestrate()`.
+ */
+export interface Orchestrator {
+    getChain: <C extends string>(chainName: C) => Promise<Chain<C extends keyof KnownChains ? KnownChains[C] : any>>;
+    makeLocalAccount: () => Promise<LocalChainAccount>;
+    /**
+     * For a denom, return information about a denom including the equivalent
+     * local Brand, the Chain on which the denom is held, and the Chain that
+     * issues the corresponding asset.
+     * @param denom
+     */
+    getBrandInfo: <HoldingChain extends keyof KnownChains, IssuingChain extends keyof KnownChains>(denom: Denom) => {
+        /** The well-known Brand on Agoric for the direct asset */
+        brand?: Brand;
+        /** The Chain at which the argument `denom` exists (where the asset is currently held) */
+        chain: Chain<KnownChains[HoldingChain]>;
+        /** The Chain that is the issuer of the underlying asset */
+        base: Chain<KnownChains[IssuingChain]>;
+        /** the Denom for the underlying asset on its issuer chain */
+        baseDenom: Denom;
+    };
+    /**
+     * Convert an amount described in native data to a local, structured Amount.
+     * @param amount - the described amount
+     * @returns the Amount in local structuerd format
+     */
+    asAmount: (amount: DenomAmount) => NatAmount;
+}
+/**
+ * An object that supports high-level operations for an account on a remote chain.
+ */
+export interface OrchestrationAccountI {
+    /**
+     * @returns the address of the account on the remote chain
+     */
+    getAddress: () => ChainAddress;
+    /** @returns an array of amounts for every balance in the account. */
+    getBalances: () => Promise<DenomAmount[]>;
+    /** @returns the balance of a specific denom for the account. */
+    getBalance: (denom: DenomArg) => Promise<DenomAmount>;
+    /**
+     * Transfer amount to another account on the same chain. The promise settles when the transfer is complete.
+     * @param toAccount - the account to send the amount to. MUST be on the same chain
+     * @param amount - the amount to send
+     * @returns void
+     */
+    send: (toAccount: ChainAddress, amount: AmountArg) => Promise<void>;
+    /**
+     * Transfer an amount to another account, typically on another chain.
+     * The promise settles when the transfer is complete.
+     * @param amount - the amount to transfer. Can be provided as pure data using denoms or as ERTP Amounts.
+     * @param destination - the account to transfer the amount to.
+     * @param [opts] - an optional memo to include with the transfer, which could drive custom PFM behavior, and timeout parameters
+     * @returns void
+     *
+     * TODO document the mapping from the address to the destination chain.
+     */
+    transfer: (amount: AmountArg, destination: ChainAddress, opts?: IBCMsgTransferOptions) => Promise<void>;
+    /**
+     * Transfer an amount to another account in multiple steps. The promise settles when
+     * the entire path of the transfer is complete.
+     * @param amount - the amount to transfer
+     * @param msg - the transfer message, including follow-up steps
+     * @returns void
+     */
+    transferSteps: (amount: AmountArg, msg: TransferMsg) => Promise<void>;
+    /**
+     * deposit payment from zoe to the account. For remote accounts,
+     * an IBC Transfer will be executed to transfer funds there.
+     */
+    deposit: (payment: Payment<'nat'>) => Promise<void>;
+}
+/**
+ * Internal structure for TransferMsgs.
+ * The type must be able to express transfers across different chains and transports.
+ *
+ * NOTE Expected to change, so consider an opaque structure.
+ */
+export type TransferMsg = {
+    toAccount: ChainAddress;
+    timeout?: Timestamp;
+    next?: TransferMsg;
+    data?: object;
+};
+export type AfterAction = {
+    destChain: string;
+    destAddress: ChainAddress;
+};
+export type SwapExact = {
+    amountIn: Amount;
+    amountOut: Amount;
+};
+export type SwapMaxSlippage = {
+    amountIn: Amount;
+    brandOut: Brand;
+    slippage: number;
+};
+//# sourceMappingURL=orchestration-api.d.ts.map

package/src/orchestration-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestration-api.d.ts","sourceRoot":"","sources":["orchestration-api.ts"],"names":[],"mappings":"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"}

package/src/orchestration-api.ts

@@ -0,0 +1,201 @@
+/* eslint-disable no-use-before-define */
+/**
+ * @file General API of orchestration
+ * - must not have chain-specific types without runtime narrowing by chain id
+ * - should remain relatively stable.
+ */
+import type {
+  Amount,
+  Brand,
+  NatAmount,
+  Payment,
+} from '@agoric/ertp/src/types.js';
+import type { LocalChainAccount } from '@agoric/vats/src/localchain.js';
+import type { Timestamp } from '@agoric/time';
+import type {
+  ChainInfo,
+  CosmosChainAccountMethods,
+  CosmosChainInfo,
+  IBCMsgTransferOptions,
+  KnownChains,
+} from './types.js';
+
+/**
+ * A denom that designates a path to a token type on some blockchain.
+ *
+ * Multiple denoms may designate the same underlying base denom (e.g., `uist`,
+ * `uatom`) on different Chains or on the same Chain via different paths. On
+ * Cosmos chains, all but the base denom are IBC style denoms, but that may vary
+ * across other chains. All the denoms that designate the same underlying base
+ * denom form an equivalence class, along with the unique Brand on the local
+ * Chain. Some operations accept any member of the equivalence class to
+ * effectively designate the corresponding token type on the target chain.
+ */
+export type Denom = string; // ibc/... or uist
+
+// ??? when multiple Denoms provide paths to the same remote token type,
+// should the brand be 1:1 with that equivalence class or each Denom?
+/**
+ * In many cases, either a denom string or a local Brand can be used to
+ * designate a remote token type.
+ */
+export type DenomArg = Denom | Brand;
+
+/**
+ * Count of some fungible token on some blockchain.
+ *
+ * @see {@link Orchestrator.asAmount} to convert to an Amount surjectively
+ */
+export type DenomAmount = {
+  denom: Denom;
+  value: bigint; // Nat
+};
+
+/** Amounts can be provided as pure data using denoms or as ERTP Amounts */
+export type AmountArg = DenomAmount | Amount;
+
+/** An address on some blockchain, e.g., cosmos, eth, etc. */
+export type ChainAddress = {
+  /** e.g. 1 for Ethereum, agoric-3 for Agoric, cosmoshub-4 for Cosmos */
+  chainId: string;
+  address: string;
+  // TODO what's the right way to scope the address? it's not chainId
+  addressEncoding: 'bech32' | 'ethereum';
+};
+
+export type OrchestrationAccount<CI extends ChainInfo> = OrchestrationAccountI &
+  (CI extends CosmosChainInfo ? CosmosChainAccountMethods<CI> : never);
+
+/**
+ * An object for access the core functions of a remote chain.
+ *
+ * Note that "remote" can mean the local chain; it's just that
+ * accounts are treated as remote/arms length for consistency.
+ */
+export interface Chain<CI extends ChainInfo> {
+  getChainInfo: () => Promise<CI>;
+
+  // "makeAccount" suggests an operation within a vat
+  /**
+   * Creates a new account on the remote chain.
+   * @returns an object that controls a new remote account on Chain
+   */
+  makeAccount: () => Promise<OrchestrationAccount<CI>>;
+  // FUTURE supply optional port object; also fetch port object
+
+  // TODO provide a way to get the local denom/brand/whatever for this chain
+}
+
+/**
+ * Provided in the callback to `orchestrate()`.
+ */
+export interface Orchestrator {
+  getChain: <C extends string>(
+    chainName: C,
+  ) => Promise<Chain<C extends keyof KnownChains ? KnownChains[C] : any>>;
+
+  makeLocalAccount: () => Promise<LocalChainAccount>;
+  /**
+   * For a denom, return information about a denom including the equivalent
+   * local Brand, the Chain on which the denom is held, and the Chain that
+   * issues the corresponding asset.
+   * @param denom
+   */
+  getBrandInfo: <
+    HoldingChain extends keyof KnownChains,
+    IssuingChain extends keyof KnownChains,
+  >(
+    denom: Denom,
+  ) => {
+    /** The well-known Brand on Agoric for the direct asset */
+    brand?: Brand;
+    /** The Chain at which the argument `denom` exists (where the asset is currently held) */
+    chain: Chain<KnownChains[HoldingChain]>;
+    /** The Chain that is the issuer of the underlying asset */
+    base: Chain<KnownChains[IssuingChain]>;
+    /** the Denom for the underlying asset on its issuer chain */
+    baseDenom: Denom;
+  };
+  // TODO preload the mapping so this can be synchronous
+  /**
+   * Convert an amount described in native data to a local, structured Amount.
+   * @param amount - the described amount
+   * @returns the Amount in local structuerd format
+   */
+  asAmount: (amount: DenomAmount) => NatAmount;
+}
+
+/**
+ * An object that supports high-level operations for an account on a remote chain.
+ */
+export interface OrchestrationAccountI {
+  /**
+   * @returns the address of the account on the remote chain
+   */
+  getAddress: () => ChainAddress;
+
+  /** @returns an array of amounts for every balance in the account. */
+  getBalances: () => Promise<DenomAmount[]>;
+
+  /** @returns the balance of a specific denom for the account. */
+  getBalance: (denom: DenomArg) => Promise<DenomAmount>;
+
+  /**
+   * Transfer amount to another account on the same chain. The promise settles when the transfer is complete.
+   * @param toAccount - the account to send the amount to. MUST be on the same chain
+   * @param amount - the amount to send
+   * @returns void
+   */
+  send: (toAccount: ChainAddress, amount: AmountArg) => Promise<void>;
+
+  /**
+   * Transfer an amount to another account, typically on another chain.
+   * The promise settles when the transfer is complete.
+   * @param amount - the amount to transfer. Can be provided as pure data using denoms or as ERTP Amounts.
+   * @param destination - the account to transfer the amount to.
+   * @param [opts] - an optional memo to include with the transfer, which could drive custom PFM behavior, and timeout parameters
+   * @returns void
+   *
+   * TODO document the mapping from the address to the destination chain.
+   */
+  transfer: (
+    amount: AmountArg,
+    destination: ChainAddress,
+    opts?: IBCMsgTransferOptions,
+  ) => Promise<void>;
+
+  /**
+   * Transfer an amount to another account in multiple steps. The promise settles when
+   * the entire path of the transfer is complete.
+   * @param amount - the amount to transfer
+   * @param msg - the transfer message, including follow-up steps
+   * @returns void
+   */
+  transferSteps: (amount: AmountArg, msg: TransferMsg) => Promise<void>;
+  /**
+   * deposit payment from zoe to the account. For remote accounts,
+   * an IBC Transfer will be executed to transfer funds there.
+   */
+  deposit: (payment: Payment<'nat'>) => Promise<void>;
+}
+
+/**
+ * Internal structure for TransferMsgs.
+ * The type must be able to express transfers across different chains and transports.
+ *
+ * NOTE Expected to change, so consider an opaque structure.
+ */
+export type TransferMsg = {
+  toAccount: ChainAddress;
+  timeout?: Timestamp;
+  next?: TransferMsg;
+  data?: object;
+};
+
+export type AfterAction = { destChain: string; destAddress: ChainAddress };
+export type SwapExact = { amountIn: Amount; amountOut: Amount };
+export type SwapMaxSlippage = {
+  amountIn: Amount;
+  brandOut: Brand;
+  slippage: number;
+};

package/src/proposals/orchestration-proposal.d.ts

@@ -0,0 +1,53 @@
+export function setupOrchestrationVat({ consume: { loadCriticalVat, portAllocator: portAllocatorP }, produce: { orchestrationVat, orchestration, orchestrationKit: orchestrationKitP, }, }: BootstrapPowers & {
+    consume: {
+        portAllocator: PortAllocator;
+    };
+    produce: {
+        orchestration: Producer<any>;
+        orchestrationKit: Producer<any>;
+        orchestrationVat: Producer<any>;
+    };
+}, options: {
+    options: {
+        orchestrationRef: VatSourceRef;
+    };
+}): Promise<void>;
+export function initChainInfo({ consume: { agoricNamesAdmin, chainStorage: chainStorageP }, }: BootstrapPowers): Promise<void>;
+export function addOrchestrationToClient({ consume: { client, orchestration } }: BootstrapPowers & {
+    consume: {
+        orchestration: OrchestrationService;
+    };
+}, _options: object): Promise<void>;
+export function getManifestForOrchestration(_powers: any, { orchestrationRef }: {
+    orchestrationRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                loadCriticalVat: boolean;
+                portAllocator: string;
+                agoricNamesAdmin?: undefined;
+                chainStorage?: undefined;
+            };
+            produce: {
+                orchestration: string;
+                orchestrationKit: string;
+                orchestrationVat: string;
+            };
+        } | {
+            consume: {
+                agoricNamesAdmin: boolean;
+                chainStorage: boolean;
+                loadCriticalVat?: undefined;
+                portAllocator?: undefined;
+            };
+            produce?: undefined;
+        };
+    };
+    options: {
+        orchestrationRef: any;
+    };
+};
+import type { PortAllocator } from '@agoric/network';
+import type { OrchestrationService } from '../service.js';
+//# sourceMappingURL=orchestration-proposal.d.ts.map

package/src/proposals/orchestration-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestration-proposal.d.ts","sourceRoot":"","sources":["orchestration-proposal.js"],"names":[],"mappings":"AA4BO,4LAZI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,aAAmB,EAAE,aAAa,CAAC;KAC9B,CAAC;IACN,OAAW,EAAE;QACb,aAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,gBAAsB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACtC,gBAAsB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACjC,CAAC;CACH,WACO;IAAE,OAAO,EAAE;QAAE,gBAAgB,EAAE,YAAY,CAAA;KAAE,CAAA;CAAE,iBAiCzD;AAoEM,+FAFI,eAAe,iBAYzB;AAWM,iFAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,aAAmB,EAAE,oBAAoB,CAAC;KACrC,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBL;mCAxK8B,iBAAiB;0CACV,eAAe"}

package/src/proposals/orchestration-proposal.js

@@ -0,0 +1,179 @@
+import { makeTracer } from '@agoric/internal';
+import { E, Far } from '@endo/far';
+import { makeMarshal } from '@endo/marshal';
+import { Fail } from '@agoric/assert';
+import { registerChainNamespace } from '../chain-info.js';
+import { CHAIN_KEY, CONNECTIONS_KEY } from '../exos/chain-hub.js';
+
+const trace = makeTracer('CoreEvalOrchestration', true);
+
+/**
+ * @import {PortAllocator} from '@agoric/network';
+ * @import {OrchestrationService} from '../service.js'
+ * @import {OrchestrationVat} from '../vat-orchestration.js'
+ */
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     portAllocator: PortAllocator;
+ *   };
+ *   produce: {
+ *     orchestration: Producer<any>;
+ *     orchestrationKit: Producer<any>;
+ *     orchestrationVat: Producer<any>;
+ *   };
+ * }} powers
+ * @param {{ options: { orchestrationRef: VatSourceRef } }} options
+ */
+export const setupOrchestrationVat = async (
+  {
+    consume: { loadCriticalVat, portAllocator: portAllocatorP },
+    produce: {
+      orchestrationVat,
+      orchestration,
+      orchestrationKit: orchestrationKitP,
+    },
+  },
+  options,
+) => {
+  const { orchestrationRef } = options.options;
+  const vats = {
+    orchestration: E(loadCriticalVat)('orchestration', orchestrationRef),
+  };
+  // don't proceed if loadCriticalVat fails
+  await Promise.all(Object.values(vats));
+
+  orchestrationVat.reset();
+  orchestrationVat.resolve(vats.orchestration);
+
+  const portAllocator = await portAllocatorP;
+
+  const newOrchestrationKit = await E(vats.orchestration).makeOrchestrationKit({
+    portAllocator,
+  });
+
+  orchestration.reset();
+  orchestration.resolve(newOrchestrationKit.public);
+  orchestrationKitP.reset();
+  orchestrationKitP.resolve(newOrchestrationKit);
+};
+
+/**
+ * Similar to publishAgoricNamesToChainStorage but publishes a node per chain
+ * instead of one list of entries
+ */
+
+/**
+ * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
+ * @param {ERef<StorageNode | null>} chainStorageP
+ */
+const publishChainInfoToChainStorage = async (
+  agoricNamesAdmin,
+  chainStorageP,
+) => {
+  const chainStorage = await chainStorageP;
+  if (!chainStorage) {
+    console.warn('no chain storage, not registering chain info');
+    return;
+  }
+
+  const agoricNamesNode = await E(chainStorage).makeChildNode('agoricNames');
+
+  /**
+   * @param {string} subpath
+   */
+  const echoNameUpdates = async subpath => {
+    const chainNamesNode = E(agoricNamesNode).makeChildNode(subpath);
+    const { nameAdmin } = await E(agoricNamesAdmin).provideChild(subpath);
+
+    /**
+     * Previous entries, to prevent redundant updates
+     *
+     * @type {Record<string, string>} chainName => stringified chainInfo
+     */
+    const prev = {};
+
+    // XXX cannot be changed until we upgrade vat-agoricNames to allow it
+    await E(nameAdmin).onUpdate(
+      // XXX will live on the heap in the bootstrap vat. When we upgrade or kill
+      // that this handler will sever and vat-agoricNames will need to be upgraded
+      // to allow changing the handler, or to use pubsub mechanics instead.
+      Far('chain info writer', {
+        write(entries) {
+          // chainInfo has no cap data but we need to marshal bigints
+          const marshalData = makeMarshal(_val => Fail`data only`);
+          for (const [chainName, info] of entries) {
+            const value = JSON.stringify(marshalData.toCapData(info));
+            if (prev[chainName] === value) {
+              continue;
+            }
+            const chainNode = E(chainNamesNode).makeChildNode(chainName);
+            prev[chainName] = value;
+            void E(chainNode)
+              .setValue(value)
+              .catch(() => delete prev[chainName]);
+          }
+        },
+      }),
+    );
+  };
+  await echoNameUpdates(CHAIN_KEY);
+  await echoNameUpdates(CONNECTIONS_KEY);
+};
+
+/**
+ * @param {BootstrapPowers} powers
+ */
+export const initChainInfo = async ({
+  consume: { agoricNamesAdmin, chainStorage: chainStorageP },
+}) => {
+  trace('init-chainInfo');
+
+  // First set up callback to write updates to vstorage
+  await publishChainInfoToChainStorage(agoricNamesAdmin, chainStorageP);
+
+  // Now register the names
+  await registerChainNamespace(agoricNamesAdmin, trace);
+};
+harden(initChainInfo);
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     orchestration: OrchestrationService;
+ *   };
+ * }} powers
+ * @param {object} _options
+ */
+export const addOrchestrationToClient = async (
+  { consume: { client, orchestration } },
+  _options,
+) => {
+  return E(client).assignBundle([_a => ({ orchestration })]);
+};
+
+export const getManifestForOrchestration = (_powers, { orchestrationRef }) => ({
+  manifest: {
+    [setupOrchestrationVat.name]: {
+      consume: {
+        loadCriticalVat: true,
+        portAllocator: 'portAllocator',
+      },
+      produce: {
+        orchestration: 'orchestration',
+        orchestrationKit: 'orchestrationKit',
+        orchestrationVat: 'orchestrationVat',
+      },
+    },
+    [initChainInfo.name]: {
+      consume: {
+        agoricNamesAdmin: true,
+        chainStorage: true,
+      },
+    },
+  },
+  options: {
+    orchestrationRef,
+  },
+});

package/src/proposals/revise-chain-info.d.ts

@@ -0,0 +1,21 @@
+export function reviseChainInfo({ consume: { agoricNamesAdmin } }: BootstrapPowers, { options: { chainInfo } }: {
+    options: {
+        chainInfo: Record<string, CosmosChainInfo>;
+    };
+}): Promise<void>;
+export function getManifestForReviseChains(_powers: any, { chainInfo }: {
+    chainInfo: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNamesAdmin: boolean;
+            };
+        };
+    };
+    options: {
+        chainInfo: any;
+    };
+};
+import type { CosmosChainInfo } from '../types.js';
+//# sourceMappingURL=revise-chain-info.d.ts.map

package/src/proposals/revise-chain-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revise-chain-info.d.ts","sourceRoot":"","sources":["revise-chain-info.js"],"names":[],"mappings":"AAeO,mEAHI,eAAe,8BACf;IAAE,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;KAAE,CAAA;CAAE,iBAgBrE;AAGM;;;;;;;;;;;;;EAWL;qCAtCiC,aAAa"}