@agoric/vats 0.15.1 → 0.15.2-calypso-dev-84eb287.0

package/src/bridge-target.js

@@ -0,0 +1,316 @@
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+
+import { BridgeHandlerI } from './bridge.js';
+
+/**
+ * @typedef {any} MostlyPureData ideally should be PureData, but that type is
+ *   too restrictive to work out-of-the-box.
+ */
+
+const { details: X, Fail } = assert;
+
+/**
+ * @typedef {object} TargetApp an object representing the app that receives
+ *   upcalls from the low-level TargetHost on the other side of a bridge
+ * @property {(obj: MostlyPureData) => Promise<MostlyPureData>} receiveUpcall
+ *   receive data from the TargetHost, and return a data result
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+export const TargetAppI = M.interface('TargetApp', {
+  receiveUpcall: M.callWhen(M.any()).returns(M.any()),
+});
+
+/**
+ * @typedef {object} TargetHost an object representing the host that receives
+ *   downcalls from the high-level TargetApp over a bridge
+ * @property {(obj: MostlyPureData) => Promise<MostlyPureData>} sendDowncall
+ *   send data to the TargetHost, which returns a data result
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+export const TargetHostI = M.interface('TargetHost', {
+  sendDowncall: M.callWhen(M.any()).returns(M.any()),
+});
+
+/**
+ * @typedef {object} AppTransformer an object for replacing a TargetApp,
+ *   generally with a wrapper that intercepts its inputs and/or results to
+ *   ensure conformance with a protocol and/or interface (e.g., an active tap
+ *   can encode results of the wrapped TargetApp into an acknowledgement
+ *   message)
+ * @property {(
+ *   app: ERef<TargetApp>,
+ *   targetHost: ERef<TargetHost>,
+ *   ...args: unknown[]
+ * ) => ERef<TargetApp>} wrapApp
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+export const AppTransformerI = M.interface('AppTransformer', {
+  wrapApp: M.callWhen(
+    M.await(M.remotable('TargetAppI')),
+    M.await(M.remotable('TargetHostI')),
+  )
+    .rest(M.any())
+    .returns(M.remotable('TargetAppI')),
+});
+
+/**
+ * @typedef {object} TargetRegistration is an ExoClass of its own, and each
+ *   instance is an attenuation of a BridgeTargetKit `targetRegistry` facet that
+ *   has access to internal state thereof but has been scoped down to a single
+ *   target.
+ * @property {() => Promise<void>} revoke performs unregistration (and sends the
+ *   corresponding "BRIDGE_TARGET_UNREGISTER" message to the targetHost).
+ * @property {(targetApp: ERef<TargetApp>) => Promise<void>} updateTargetApp
+ *   replaces the app associated with the target (but with no corresponding
+ *   message).
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+export const TargetRegistrationI = M.interface('TargetRegistration', {
+  updateTargetApp: M.callWhen(M.await(M.remotable('TargetAppI'))).returns(),
+  revoke: M.callWhen().returns(),
+});
+
+/**
+ * @typedef {object} TargetRegistry
+ * @property {(
+ *   target: string,
+ *   targetApp: ERef<TargetApp>,
+ *   args?: unknown[],
+ * ) => Promise<TargetRegistration>} register
+ * @property {(
+ *   target: string,
+ *   targetApp: ERef<TargetApp>,
+ *   args?: unknown[],
+ * ) => Promise<void>} reregister
+ * @property {(target: string) => Promise<void>} unregister
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+const TargetRegistryI = M.interface('TargetRegistry', {
+  register: M.callWhen(M.string(), M.await(M.remotable('TargetAppI')))
+    .optional(M.array())
+    .returns(M.remotable('TargetRegistration')),
+  reregister: M.callWhen(M.string(), M.await(M.remotable('TargetAppI')))
+    .optional(M.array())
+    .returns(),
+  unregister: M.callWhen(M.string()).returns(),
+});
+
+/** @param {import('@agoric/base-zone').Zone} zone */
+export const prepareTargetRegistration = zone =>
+  zone.exoClass(
+    'TargetRegistration',
+    TargetRegistrationI,
+    /**
+     * @param {string} target
+     * @param {TargetRegistry} registry
+     * @param {unknown[] | null} args
+     */
+    (target, registry, args) => ({
+      target,
+      /** @type {TargetRegistry | null} */
+      registry,
+      args,
+    }),
+    {
+      /**
+       * Atomically point the registration at a different app.
+       *
+       * @param {TargetApp} app new app to handle messages for the target
+       */
+      async updateTargetApp(app) {
+        const { target, registry, args } = this.state;
+        if (!registry) {
+          throw Fail`Registration for ${target} is already revoked`;
+        }
+        return E(registry).reregister(
+          target,
+          app,
+          /** @type {unknown[]} */ (args),
+        );
+      },
+      /** Atomically delete the registration. */
+      async revoke() {
+        const { target, registry } = this.state;
+        if (!registry) {
+          throw Fail`Registration for ${target} is already revoked`;
+        }
+        this.state.registry = null;
+        this.state.args = null;
+        return E(registry).unregister(target);
+      },
+    },
+  );
+
+/**
+ * A BridgeTargetKit is associated with a ScopedBridgeManager (essentially a
+ * specific named channel on a bridge, cf. {@link ./bridge.js}) and a particular
+ * inbound event type and an optional app transformer. It consists of three
+ * facets:
+ *
+ * - `targetHost` has a `downcall` method for sending outbound messages via the
+ *   bridge to the VM host.
+ * - `targetRegistry` has `register`, `reregister` and `unregister` methods to
+ *   register/reregister/unregister an "app" (or rather its transformation) with
+ *   a "target" corresponding to an address on the targetHost. Each target may
+ *   be associated with at most one app at any given time, and registration and
+ *   unregistration each send a message to the targetHost of the state change
+ *   (of type "BRIDGE_TARGET_REGISTER" and "BRIDGE_TARGET_UNREGISTER",
+ *   respectively). `reregister` is a method that atomically redirects the
+ *   target to a new (transformed) app.
+ * - `bridgeHandler` has a `fromBridge` method for receiving from the
+ *   ScopedBridgeManager inbound messages of the associated event type and
+ *   dispatching them to the app registered for their target.
+ *
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {ReturnType<typeof prepareTargetRegistration>} makeTargetRegistration
+ */
+export const prepareBridgeTargetKit = (zone, makeTargetRegistration) =>
+  zone.exoClassKit(
+    'BridgeTargetKit',
+    {
+      bridgeHandler: BridgeHandlerI,
+      targetHost: TargetHostI,
+      targetRegistry: TargetRegistryI,
+    },
+    /**
+     * @template {import('@agoric/internal').BridgeIdValue} T
+     * @param {import('./types').ScopedBridgeManager<T>} manager
+     * @param {string} inboundEventType
+     * @param {AppTransformer} [appTransformer]
+     */
+    (manager, inboundEventType, appTransformer = undefined) => ({
+      manager,
+      inboundEventType,
+      appTransformer,
+      /** @type {MapStore<string, ERef<TargetApp>>} */
+      targetToApp: zone.detached().mapStore('targetToApp'),
+    }),
+    {
+      bridgeHandler: {
+        fromBridge(obj) {
+          const { inboundEventType, targetToApp } = this.state;
+          const { type, target } = obj;
+
+          type === inboundEventType ||
+            Fail`Invalid inbound event type ${type}; expected ${inboundEventType}`;
+
+          target || Fail`Missing target property in ${obj}`;
+
+          const app = targetToApp.get(target);
+          return E(app).receiveUpcall(obj);
+        },
+      },
+      targetHost: {
+        async sendDowncall(obj) {
+          const { manager } = this.state;
+          return E(manager).toBridge(obj);
+        },
+      },
+      targetRegistry: {
+        /**
+         * Register an app to handle messages for a target.
+         *
+         * @param {string} target
+         * @param {TargetApp} app
+         * @param {unknown[]} [args]
+         * @returns {Promise<TargetRegistration>} power to set or delete the
+         *   registration
+         */
+        async register(target, app, args = []) {
+          const { targetHost } = this.facets;
+          const { appTransformer, targetToApp } = this.state;
+
+          // Because wrapping an app is async, we verify absence of an existing
+          // registration twice (once to avoid the unnecessary invocation and
+          // once inside `init`), but attempt to throw similar errors in both
+          // cases.
+          !targetToApp.has(target) || Fail`Target ${target} already registered`;
+          const wrappedApp = await (appTransformer
+            ? E(appTransformer).wrapApp(app, targetHost, ...args)
+            : app);
+          try {
+            targetToApp.init(target, wrappedApp);
+          } catch (cause) {
+            throw assert.error(
+              X`Target ${target} already registered`,
+              undefined,
+              { cause },
+            );
+          }
+
+          await E(targetHost).sendDowncall({
+            type: 'BRIDGE_TARGET_REGISTER',
+            target,
+          });
+
+          return makeTargetRegistration(
+            target,
+            this.facets.targetRegistry,
+            args,
+          );
+        },
+        /**
+         * Update the app that handles messages for a target.
+         *
+         * @param {string} target
+         * @param {TargetApp} app
+         * @param {unknown[]} [args]
+         * @returns {Promise<void>}
+         */
+        async reregister(target, app, args = []) {
+          const { targetHost } = this.facets;
+          const { appTransformer, targetToApp } = this.state;
+
+          // Because wrapping an app is async, we verify absence of an existing
+          // registration twice (once to avoid the unnecessary invocation and
+          // once inside `set`), but attempt to throw similar errors in both
+          // cases.
+          targetToApp.has(target) ||
+            Fail`Target ${target} is already unregistered`;
+          const wrappedApp = await (appTransformer
+            ? E(appTransformer).wrapApp(app, targetHost, ...args)
+            : app);
+          try {
+            targetToApp.set(target, wrappedApp);
+          } catch (cause) {
+            throw assert.error(
+              X`Target ${target} is already unregistered`,
+              undefined,
+              { cause },
+            );
+          }
+        },
+        /**
+         * Unregister the target, bypassing the attenuated `TargetRegistration`
+         * API.
+         *
+         * @param {string} target
+         * @returns {Promise<void>}
+         */
+        async unregister(target) {
+          const { targetHost } = this.facets;
+          const { targetToApp } = this.state;
+          targetToApp.has(target) || Fail`Target ${target} is already deleted`;
+          targetToApp.delete(target);
+          await E(targetHost).sendDowncall({
+            type: 'BRIDGE_TARGET_UNREGISTER',
+            target,
+          });
+        },
+      },
+    },
+  );
+harden(prepareBridgeTargetKit);
+
+/** @param {import('@agoric/base-zone').Zone} zone */
+export const prepareBridgeTargetModule = zone => {
+  const makeTargetRegistration = prepareTargetRegistration(zone);
+  const makeBridgeTargetKit = prepareBridgeTargetKit(
+    zone,
+    makeTargetRegistration,
+  );
+
+  return harden({ makeBridgeTargetKit });
+};
+harden(prepareBridgeTargetModule);

package/src/bridge.d.ts

@@ -1,5 +1,15 @@
-export const BridgeHandlerI: import("@endo/patterns").InterfaceGuard;
-export const BridgeScopedManagerI: import("@endo/patterns").InterfaceGuard;
-export const BridgeManagerI: import("@endo/patterns").InterfaceGuard;
-export function prepareBridgeManager(zone: import('@agoric/zone').Zone, D: DProxy): (bridgeDevice: BridgeDevice) => import('./types.js').BridgeManager;
+export function makeScopedBridge<BridgeId extends import("@agoric/internal").BridgeIdValue>(bridgeManager: ERef<import("./types.js").BridgeManager>, bridgeIdValue: BridgeId, handler?: import("@agoric/internal").Remote<import("./types.js").BridgeHandler, {}> | undefined): Promise<import("./types.js").ScopedBridgeManager<BridgeId>>;
+export const BridgeHandlerI: import("@endo/patterns").InterfaceGuard<{
+    fromBridge: import("@endo/patterns").MethodGuard;
+}>;
+export const BridgeScopedManagerI: import("@endo/patterns").InterfaceGuard<{
+    fromBridge: import("@endo/patterns").MethodGuard;
+    toBridge: import("@endo/patterns").MethodGuard;
+    initHandler: import("@endo/patterns").MethodGuard;
+    setHandler: import("@endo/patterns").MethodGuard;
+}>;
+export const BridgeManagerI: import("@endo/patterns").InterfaceGuard<{
+    register: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareBridgeManager(zone: import("@agoric/zone").Zone, D: DProxy): (bridgeDevice: BridgeDevice) => import("./types.js").BridgeManager;
 //# sourceMappingURL=bridge.d.ts.map

package/src/bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["bridge.js"],"names":[],"mappings":"AASA,qEAEG;AAEH,2EAKG;AAEH,qEAIG;AAmEI,2CAHI,OAAO,cAAc,EAAE,IAAI,KAC3B,MAAM,kBA2EJ,YAAY,KACV,OAAO,YAAY,EAAE,aAAa,CA2BhD"}
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["bridge.js"],"names":[],"mappings":"AAqBO,iCARiD,QAAQ,SAAnD,OAAQ,kBAAkB,EAAE,aAAc,iBAC5C,IAAI,CAAC,OAAO,YAAY,EAAE,aAAa,CAAC,iBACxC,QAAQ,oGAIN,OAAO,CAAC,OAAO,YAAY,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC,CAKrE;AAEH;;GAEG;AAEH;;;;;GAKG;AAEH;;GAIG;AAmEI,2CAHI,OAAO,cAAc,EAAE,IAAI,KAC3B,MAAM,kBAuFJ,YAAY,KACV,OAAO,YAAY,EAAE,aAAa,CA2BhD"}

package/src/bridge.js

@@ -1,12 +1,29 @@
-// @ts-check
-
 import { M } from '@agoric/store';
-import '@agoric/store/exported.js';
 import { E } from '@endo/far';
-import './core/types.js';
 
 const { Fail, details: X } = assert;
 
+/**
+ * Helper to type the registered scoped bridge correctly.
+ *
+ * FIXME: This is needed because `register` is not an async function, so
+ * `E(x).register` needs to reconstruct its return value as a Promise, which
+ * loses the function's genericity. If `register` was async, we could use its
+ * type directly, and it would remain generic.
+ *
+ * @template {import('@agoric/internal').BridgeIdValue} BridgeId
+ * @param {ERef<import('./types.js').BridgeManager>} bridgeManager
+ * @param {BridgeId} bridgeIdValue
+ * @param {import('@agoric/internal').Remote<
+ *   import('./types.js').BridgeHandler
+ * >} [handler]
+ * @returns {Promise<import('./types.js').ScopedBridgeManager<BridgeId>>}
+ */
+export const makeScopedBridge = (bridgeManager, bridgeIdValue, handler) =>
+  /** @type {Promise<import('./types.js').ScopedBridgeManager<BridgeId>>} */ (
+    E(bridgeManager).register(bridgeIdValue, handler)
+  );
+
 export const BridgeHandlerI = M.interface('BridgeHandler', {
   fromBridge: M.call(M.any()).returns(M.promise()),
 });
@@ -34,17 +51,17 @@ const BridgeManagerIKit = harden({
   }),
 });
 
-/**
- * @param {import('@agoric/zone').Zone} zone
- */
+/** @param {import('@agoric/zone').Zone} zone */
 const prepareScopedManager = zone => {
   const makeScopedManager = zone.exoClass(
     'BridgeScopedManager',
     BridgeScopedManagerI,
     /**
      * @param {string} bridgeId
-     * @param {{ outbound: (bridgeId: string, obj: unknown) => Promise<any> }} toBridge
-     * @param {import('./types').BridgeHandler} [inboundHandler]
+     * @param {{
+     *   outbound: (bridgeId: string, obj: unknown) => Promise<any>;
+     * }} toBridge
+     * @param {import('./types.js').BridgeHandler} [inboundHandler]
      */
     (bridgeId, toBridge, inboundHandler) => ({
       bridgeId,
@@ -93,14 +110,16 @@ export const prepareBridgeManager = (zone, D) => {
   const makeScopedManager = prepareScopedManager(zone);
 
   /**
-   * Create a bridge manager for multiplexing messages to and from a bridge device
-   * using string-named channels.
+   * Create a bridge manager for multiplexing messages to and from a bridge
+   * device using string-named channels.
    *
    * @param {BridgeDevice} bridgeDevice The bridge to manage
    * @returns {{
-   *   manager: import('./types.js').BridgeManager,
-   *   privateInbounder: { inbound(srcID: string, obj: unknown): void },
-   *   privateOutbounder: { outbound(dstID: string, obj: unknown): Promise<any> },
+   *   manager: import('./types.js').BridgeManager;
+   *   privateInbounder: { inbound(srcID: string, obj: unknown): void };
+   *   privateOutbounder: {
+   *     outbound(dstID: string, obj: unknown): Promise<any>;
+   *   };
    * }}
    */
   const makeBridgeManagerKit = zone.exoClassKit(
@@ -108,7 +127,12 @@ export const prepareBridgeManager = (zone, D) => {
     BridgeManagerIKit,
     /** @param {BridgeDevice} bridgeDevice */
     bridgeDevice => ({
-      /** @type {MapStore<string, ReturnType<ReturnType<typeof prepareScopedManager>>>} */
+      /**
+       * @type {MapStore<
+       *   string,
+       *   ReturnType<ReturnType<typeof prepareScopedManager>>
+       * >}
+       */
       scopedManagers: zone.detached().mapStore('scopedManagers'),
       bridgeDevice,
     }),
@@ -156,7 +180,12 @@ export const prepareBridgeManager = (zone, D) => {
     },
   );
 
-  /** @type {MapStore<BridgeDevice, ReturnType<typeof makeBridgeManagerKit>>} */
+  /**
+   * @type {MapStore<
+   *   BridgeDevice,
+   *   ReturnType<typeof makeBridgeManagerKit>
+   * >}
+   */
   const bridgeToManagerKit = zone.mapStore('bridgeToManagerKit');
 
   /**

package/src/centralSupply.d.ts

@@ -4,9 +4,9 @@ export function start(zcf: ZCF<{
     feeMintAccess: FeeMintAccess;
 }): Promise<{
     creatorFacet: {
-        getBootstrapPayment: () => Payment<any>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getBootstrapPayment: () => Payment<any>;
+        getBootstrapPayment: () => globalThis.Payment<any>;
+    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        getBootstrapPayment: () => globalThis.Payment<any>;
     }>;
 }>;
 export type CentralSupplyContract = ContractOf<typeof start>;

package/src/centralSupply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"centralSupply.d.ts","sourceRoot":"","sources":["centralSupply.js"],"names":[],"mappings":"AAeO;2BALoB,MAAM;;IAGK,aAAa,EAAxC,aAAa;;;;;;;GA0BvB;oCAGa,WAAW,YAAY,CAAC"}
+{"version":3,"file":"centralSupply.d.ts","sourceRoot":"","sources":["centralSupply.js"],"names":[],"mappings":"AAaO,2BANI,GAAG,CAAC;IACd,qBAAyB,EAAE,MAAM,CAAC;CAC/B,CAAC,qBAEF;IAAmC,aAAa,EAAxC,aAAa;CACvB;;;;;;GAyBA;oCAGa,UAAU,CAAC,OAAO,KAAK,CAAC"}

package/src/centralSupply.js

@@ -1,14 +1,12 @@
-// @ts-check
-
 import { AmountMath } from '@agoric/ertp';
 import { E, Far } from '@endo/far';
 
 /**
- * The sole purpose of this contract is to mint the initial
- * supply of the central currency, RUN.
+ * The sole purpose of this contract is to mint the initial supply of the
+ * central currency, RUN.
  *
  * @param {ZCF<{
- *  bootstrapPaymentValue: bigint,
+ *   bootstrapPaymentValue: bigint;
  * }>} zcf
  * @param {object} privateArgs
  * @param {FeeMintAccess} privateArgs.feeMintAccess

package/src/core/README.md

@@ -1,7 +1,7 @@
 # Core vats and supports
 
 This directory contains modules that build vats that boot other vats. If that's all it did, it could terminate but it also has persistent responsibilities:
-- hold the `CORE_EVAL` bridge handler
+- hold the `CORE_EVAL` bridge handler (see `bridgeCoreEval` in [chain-behaviors.js](./chain-behaviors.js)
 - hold a PrioritySenderManager handed out to some contracts
 
 Bootstrap vats must not hold precious state (see https://github.com/Agoric/agoric-sdk/issues/4548). These state aren't _precious_ because they can be reconstructed.

package/src/core/basic-behaviors.d.ts

@@ -1,31 +1,24 @@
-export function makeVatsFromBundles({ vats, devices, consume: { vatStore }, produce: { vatAdminSvc, loadVat, loadCriticalVat }, }: BootstrapPowers & {}): Promise<void>;
-export function produceDiagnostics({ produce }: Pick<ChainBootstrapSpace, 'produce'>): Promise<void>;
-export function produceStartUpgradable({ zone, consume: { diagnostics, zoe }, produce, }: BootstrapSpace & {
-    zone: import('@agoric/zone').Zone;
-}): Promise<void>;
-export function produceStartGovernedUpgradable({ zone, consume: { chainTimerService, diagnostics, economicCommitteeCreatorFacet, zoe, }, produce, installation: { consume: { contractGovernor }, }, }: BootstrapSpace & {
-    zone: import('@agoric/zone').Zone;
-    consume: {
-        economicCommitteeCreatorFacet: import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapPowers['consume']['economicCommitteeCreatorFacet'];
+export function makeVatsFromBundles({ vats, devices, consume: { vatStore }, produce: { vatAdminSvc, loadVat, loadCriticalVat }, }: BootstrapPowers & {
+    produce: {
+        loadVat: Producer<VatLoader>;
+        loadCriticalVat: Producer<VatLoader>;
     };
 }): Promise<void>;
-export function buildZoe({ consume: { vatAdminSvc, loadCriticalVat, client }, produce: { zoe, feeMintAccess }, brand: { produce: { Invitation: invitationBrand }, }, issuer: { produce: { Invitation: invitationIssuer }, }, }: BootstrapPowers & {
-    consume: {
-        loadCriticalVat: ERef<VatLoader<ZoeVat>>;
-    };
+export function produceDiagnostics({ produce }: Pick<ChainBootstrapSpace, "produce">): Promise<void>;
+export function produceStartUpgradable({ zone, consume: { diagnostics, zoe }, produce, }: BootstrapSpace & {
+    zone: import("@agoric/zone").Zone;
 }): Promise<void>;
-export function startPriceAuthorityRegistry({ consume: { loadCriticalVat, client }, produce, }: BootstrapPowers & {
+export function produceStartGovernedUpgradable({ zone, consume: { chainTimerService, diagnostics, economicCommitteeCreatorFacet, zoe, }, produce, installation: { consume: { contractGovernor }, }, }: BootstrapSpace & {
+    zone: import("@agoric/zone").Zone;
     consume: {
-        loadCriticalVat: ERef<VatLoader<PriceAuthorityVat>>;
+        economicCommitteeCreatorFacet: import("@agoric/inter-protocol/src/proposals/econ-behaviors.js").EconomyBootstrapPowers["consume"]["economicCommitteeCreatorFacet"];
     };
 }): Promise<void>;
+export function buildZoe({ consume: { vatAdminSvc, loadCriticalVat, client }, produce: { zoe, feeMintAccess }, brand: { produce: { Invitation: invitationBrand }, }, issuer: { produce: { Invitation: invitationIssuer }, }, }: BootstrapPowers): Promise<void>;
+export function startPriceAuthorityRegistry({ consume: { loadCriticalVat, client }, produce, }: BootstrapPowers): Promise<void>;
 export function makeOracleBrands({ namedVat: { consume: { agoricNames }, }, oracleBrand: { produce: { USD }, }, }: BootstrapPowers & NamedVatPowers): Promise<void>;
 export function produceBoard({ consume: { client }, produce: { board: pBoard }, namedVat: { consume: { board: vatBoard }, }, }: BootstrapPowers & NamedVatPowers): Promise<void>;
-export function makeBoard({ consume: { loadCriticalVat, client }, produce: { board: { resolve: resolveBoard }, }, }: BootstrapPowers & {
-    consume: {
-        loadCriticalVat: ERef<VatLoader<BoardVat>>;
-    };
-}): Promise<void>;
+export function makeBoard({ consume: { loadCriticalVat, client }, produce: { board: { resolve: resolveBoard }, }, }: BootstrapPowers): Promise<void>;
 export function produceNamesByAddress({ consume: { agoricNames, provisioning: provisioningOptP, client }, produce: { namesByAddress, namesByAddressAdmin }, }: BootstrapPowers): Promise<void>;
 export function makeAddressNameHubs({ consume: { agoricNames: agoricNamesP, client }, produce, }: BootstrapSpace): Promise<void>;
 export function makeClientBanks({ consume: { namesByAddressAdmin, client, bankManager, walletFactoryStartResult, }, }: BootstrapSpace): Promise<void>;
@@ -37,30 +30,22 @@ export function mintInitialSupply({ vatParameters: { argv: { bootMsg }, }, consu
         };
     };
 }): Promise<void>;
-export function addBankAssets({ consume: { agoricNamesAdmin, initialSupply, bridgeManager: bridgeManagerP, loadCriticalVat, startUpgradable, zoe, }, produce: { bankManager, bldIssuerKit }, installation: { consume: { mintHolder }, }, issuer: { produce: produceIssuer }, brand: { produce: produceBrand }, }: BootstrapSpace & {
-    consume: {
-        loadCriticalVat: ERef<VatLoader<BankVat>>;
-    };
-}): Promise<void>;
-/** @type {import('./lib-boot').BootstrapManifest} */
-export const BASIC_BOOTSTRAP_PERMITS: import('./lib-boot').BootstrapManifest;
-/**
- * as from createVatByName
- */
-export type CreateVatResults = import('@agoric/swingset-vat').CreateVatResults;
+export function addBankAssets({ consume: { agoricNamesAdmin, initialSupply, bridgeManager: bridgeManagerP, loadCriticalVat, startUpgradable, zoe, }, produce: { bankManager, bldIssuerKit }, installation: { consume: { mintHolder }, }, issuer: { produce: produceIssuer }, brand: { produce: produceBrand }, }: BootstrapSpace): Promise<void>;
+/** @type {import('./lib-boot.js').BootstrapManifest} */
+export const BASIC_BOOTSTRAP_PERMITS: import("./lib-boot.js").BootstrapManifest;
 export type VatStore = MapStore<string, CreateVatResults>;
-export type ZoeVat = ERef<ReturnType<typeof import("../vat-zoe.js").buildRootObject>>;
-export type PriceAuthorityVat = ERef<ReturnType<typeof import("../vat-priceAuthority.js").buildRootObject>>;
 declare namespace bootMsgEx {
-    const type: string;
-    const chainID: string;
-    const storagePort: number;
-    const supplyCoins: {
+    let type: string;
+    let chainID: string;
+    let storagePort: number;
+    let supplyCoins: {
         denom: string;
         amount: string;
     }[];
-    const vbankPort: number;
-    const vibcPort: number;
+    let swingsetPort: number;
+    let vbankPort: number;
+    let vibcPort: number;
 }
+import type { CreateVatResults } from '@agoric/swingset-vat';
 export {};
 //# sourceMappingURL=basic-behaviors.d.ts.map

package/src/core/basic-behaviors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basic-behaviors.d.ts","sourceRoot":"","sources":["basic-behaviors.js"],"names":[],"mappings":"AA0DO,mIANI,eAAe,GAAG,EACzB,iBA6DH;AAIM,gDADK,KAAK,mBAAmB,EAAE,SAAS,CAAC,iBAW/C;AAGM,0FADK,cAAc,GAAG;IAAE,IAAI,EAAE,OAAO,cAAc,EAAE,IAAI,CAAA;CAAE,iBAiCjE;AAsGM,uMAPI,cAAc,GAAG;IAC3B,IAAQ,EAAE,OAAO,cAAc,EAAE,IAAI,CAAC;IACtC,OAAW,EAAE;QACb,6BAAmC,EAAE,OAAO,wDAAwD,EAAE,sBAAsB,CAAC,SAAS,CAAC,CAAC,+BAA+B,CAAC,CAAA;KACnK,CAAA;CACF,iBAwDH;AAUM,gOANK,eAAe,GAAG;IAC7B,OAAW,EAAE;QAAE,eAAe,EAAE,KAAK,UAAU,MAAM,CAAC,CAAC,CAAA;KAAE,CAAA;CACtD,iBA2BH;AAUM,gGANI,eAAe,GAAG;IAC5B,OAAW,EAAE;QAAE,eAAe,EAAE,KAAK,UAAU,iBAAiB,CAAC,CAAC,CAAA;KAAC,CAAC;CACjE,iBAkBH;AAQM,mHAFI,eAAe,GAAG,cAAc,iBAe1C;AAMM,gIAFI,eAAe,GAAG,cAAc,iBAY1C;AAUM,qHAJI,eAAe,GAAG;IAC5B,OAAW,EAAE;QAAE,eAAe,EAAE,KAAK,UAAU,QAAQ,CAAC,CAAC,CAAA;KACtD,CAAA;CAAC,iBAWJ;AAeM,+JAFI,eAAe,iBAwBzB;AAQM,kGAFI,cAAc,iBA6BxB;AAIM,uHADK,cAAc,iBAkCzB;AAIM,oIADK,cAAc,iBAiBzB;AASM,0MAJK,eAAe,GAAG;IAC7B,aAAiB,EAAE;QAAE,IAAI,EAAE;YAAE,OAAO,CAAC,EAAE,gBAAgB,CAAA;SAAE,CAAA;KAAC,CAAC;CACxD,iBA+BH;AAUM,kTAJK,cAAc,GAAG;IAC5B,OAAW,EAAE;QAAE,eAAe,EAAE,KAAK,UAAU,OAAO,CAAC,CAAC,CAAA;KAAE,CAAC;CACxD,iBAoFH;AAGD,qDAAqD;AACrD,sCADW,OAAO,YAAY,EAAE,iBAAiB,CA0I/C;;;;+BAzwBW,OAAO,sBAAsB,EAAE,gBAAgB;uBAC/C,SAAS,MAAM,EAAE,gBAAgB,CAAC;qBA+QlC,KAAK,0DAAmD,CAAC;gCAiCzD,KAAK,qEAA8D,CAAC"}
+{"version":3,"file":"basic-behaviors.d.ts","sourceRoot":"","sources":["basic-behaviors.js"],"names":[],"mappings":"AAgEO,mIATI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,OAAa,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;QACnC,eAAqB,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;KACtC,CAAC;CACH,iBA4DH;AAIM,gDADK,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC,iBAW/C;AAGM,0FADK,cAAc,GAAG;IAAE,IAAI,EAAE,OAAO,cAAc,EAAE,IAAI,CAAA;CAAE,iBAiCjE;AAqGM,uMAPI,cAAc,GAAG;IAC3B,IAAQ,EAAE,OAAO,cAAc,EAAE,IAAI,CAAC;IACtC,OAAW,EAAE;QACb,6BAAmC,EAAE,OAAO,wDAAwD,EAAE,sBAAsB,CAAC,SAAS,CAAC,CAAC,+BAA+B,CAAC,CAAC;KACpK,CAAC;CACH,iBA6DH;AAMM,gOAFI,eAAe,iBAyBzB;AAMM,gGAFI,eAAe,iBAgBzB;AAQM,mHAFI,eAAe,GAAG,cAAc,iBAe1C;AAIM,gIADK,eAAe,GAAG,cAAc,iBAW3C;AAOM,qHAFI,eAAe,iBAWzB;AAcM,+JAFI,eAAe,iBAwBzB;AAQM,kGAFI,cAAc,iBA6BxB;AAIM,uHADK,cAAc,iBAkCzB;AAIM,oIADK,cAAc,iBAiBzB;AASM,0MAJI,eAAe,GAAG;IAC5B,aAAiB,EAAE;QAAE,IAAI,EAAE;YAAE,OAAO,CAAC,EAAE,OAAO,SAAS,CAAA;SAAE,CAAA;KAAE,CAAC;CACzD,iBAmCH;AAQM,kTAFI,cAAc,iBAsFxB;AAGD,wDAAwD;AACxD,sCADW,OAAO,eAAe,EAAE,iBAAiB,CA0IlD;uBA5wBY,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;;;;;;;;;;;;;sCASb,sBAAsB"}