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

package/src/core/basic-behaviors.js

@@ -1,7 +1,6 @@
-// @ts-check
-
 import { AssetKind } from '@agoric/ertp';
 import { CONTRACT_ELECTORATE, ParamTypes } from '@agoric/governance';
+import { Stable, Stake } from '@agoric/internal/src/tokens.js';
 import {
   BridgeId,
   deeplyFulfilledObject,
@@ -15,19 +14,20 @@ import { Nat } from '@endo/nat';
 
 import { Fail, NonNullish } from '@agoric/assert';
 import { makeNameHubKit } from '../nameHub.js';
-import { Stable, Stake } from '../tokens.js';
 import { PowerFlags } from '../walletFlags.js';
 import { feeIssuerConfig, makeMyAddressNameAdminKit } from './utils.js';
+import { makeScopedBridge } from '../bridge.js';
+
+/** @import {GovernableStartFn, GovernanceFacetKit} from '@agoric/governance/src/types.js'; */
 
 const { details: X } = assert;
 
 /**
- * In golang/cosmos/app/app.go, we define
- * cosmosInitAction with type AG_COSMOS_INIT,
- * with the following shape.
+ * In golang/cosmos/app/app.go, we define cosmosInitAction with type
+ * AG_COSMOS_INIT, with the following shape.
  *
- * The uist supplyCoins value is taken from genesis,
- * thereby authorizing the minting an initial supply of RUN.
+ * The uist supplyCoins value is taken from genesis, thereby authorizing the
+ * minting an initial supply of RUN.
  */
 // eslint-disable-next-line no-unused-vars
 const bootMsgEx = {
@@ -40,21 +40,27 @@ const bootMsgEx = {
     { denom: 'ubld', amount: '1000000000000000' },
     { denom: 'uist', amount: '50000000000' },
   ],
+  swingsetPort: 4,
   vbankPort: 3,
   vibcPort: 2,
 };
 
 /**
- * TODO: review behaviors carefully for powers that go out of scope,
- * since we may want/need them later.
+ * TODO: review behaviors carefully for powers that go out of scope, since we
+ * may want/need them later.
  */
 
+/** @typedef {MapStore<string, CreateVatResults>} VatStore */
+
 /**
  * @param {BootstrapPowers & {
+ *   produce: {
+ *     loadVat: Producer<VatLoader>;
+ *     loadCriticalVat: Producer<VatLoader>;
+ *   };
  * }} powers
- *
- * @typedef {import('@agoric/swingset-vat').CreateVatResults} CreateVatResults as from createVatByName
- * @typedef {MapStore<string, CreateVatResults>} VatStore
+ * @import {CreateVatResults} from '@agoric/swingset-vat'
+ *   as from createVatByName
  */
 export const makeVatsFromBundles = async ({
   vats,
@@ -78,7 +84,7 @@ export const makeVatsFromBundles = async ({
       const vatInfoP = provideLazy(tmpStore, vatName, async _k => {
         if (bundleName) {
           console.info(`createVatByName(${bundleName})`);
-          /** @type { Promise<CreateVatResults> } */
+          /** @type {Promise<CreateVatResults>} */
           const vatInfo = E(svc).createVatByName(bundleName, {
             ...defaultVatCreationOptions,
             name: vatName,
@@ -88,7 +94,7 @@ export const makeVatsFromBundles = async ({
         console.info(`createVat(${bundleID})`);
         assert(bundleID);
         const bcap = await E(svc).getBundleCap(bundleID);
-        /** @type { Promise<CreateVatResults> } */
+        /** @type {Promise<CreateVatResults>} */
         const vatInfo = E(svc).createVat(bcap, {
           ...defaultVatCreationOptions,
           name: vatName,
@@ -134,7 +140,7 @@ export const produceStartUpgradable = async ({
   consume: { diagnostics, zoe },
   produce, // startUpgradable, contractKits
 }) => {
-  /** @type {MapStore<Instance, StartedInstanceKitWithLabel> } */
+  /** @type {MapStore<Instance, StartedInstanceKitWithLabel>} */
   const contractKits = zone.mapStore('ContractKits');
 
   /** @type {StartUpgradable} */
@@ -166,20 +172,19 @@ harden(produceStartUpgradable);
 
 /**
  * @template {GovernableStartFn} SF
- *
  * @param {{
- *   zoe: ERef<ZoeService>,
- *   governedContractInstallation: ERef<Installation<SF>>,
- *   issuerKeywordRecord?: IssuerKeywordRecord,
- *   terms: Record<string, unknown>,
- *   privateArgs: any, // TODO: connect with Installation type
- *   label: string,
+ *   zoe: ERef<ZoeService>;
+ *   governedContractInstallation: ERef<Installation<SF>>;
+ *   issuerKeywordRecord?: IssuerKeywordRecord;
+ *   terms: Record<string, unknown>;
+ *   privateArgs: any; // TODO: connect with Installation type
+ *   label: string;
  * }} zoeArgs
  * @param {{
- *   governedParams: Record<string, unknown>,
- *   timer: ERef<import('@agoric/time/src/types').TimerService>,
- *   contractGovernor: ERef<Installation>,
- *   economicCommitteeCreatorFacet: import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapPowers['consume']['economicCommitteeCreatorFacet']
+ *   governedParams: Record<string, unknown>;
+ *   timer: ERef<import('@agoric/time').TimerService>;
+ *   contractGovernor: ERef<Installation>;
+ *   economicCommitteeCreatorFacet: import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapPowers['consume']['economicCommitteeCreatorFacet'];
  * }} govArgs
  * @returns {Promise<GovernanceFacetKit<SF>>}
  */
@@ -257,10 +262,10 @@ const startGovernedInstance = async (
 
 /**
  * @param {BootstrapSpace & {
- *   zone: import('@agoric/zone').Zone,
+ *   zone: import('@agoric/zone').Zone;
  *   consume: {
- *     economicCommitteeCreatorFacet: import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapPowers['consume']['economicCommitteeCreatorFacet']
- *   }
+ *     economicCommitteeCreatorFacet: import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapPowers['consume']['economicCommitteeCreatorFacet'];
+ *   };
  * }} powers
  */
 export const produceStartGovernedUpgradable = async ({
@@ -276,7 +281,12 @@ export const produceStartGovernedUpgradable = async ({
     consume: { contractGovernor },
   },
 }) => {
-  /** @type {MapStore<Instance, GovernanceFacetKit<any> & {label: string}>} */
+  /**
+   * @type {MapStore<
+   *   Instance,
+   *   GovernanceFacetKit<any> & { label: string }
+   * >}
+   */
   const contractKits = zone.mapStore('GovernedContractKits');
 
   /** @type {startGovernedUpgradable} */
@@ -321,11 +331,7 @@ export const produceStartGovernedUpgradable = async ({
 harden(produceStartGovernedUpgradable);
 
 /**
- * @param { BootstrapPowers & {
- *   consume: { loadCriticalVat: ERef<VatLoader<ZoeVat>> }
- * }} powers
- *
- * @typedef {ERef<ReturnType<import('../vat-zoe.js').buildRootObject>>} ZoeVat
+ * @param {BootstrapPowers} powers
  */
 export const buildZoe = async ({
   consume: { vatAdminSvc, loadCriticalVat, client },
@@ -354,11 +360,7 @@ export const buildZoe = async ({
 harden(buildZoe);
 
 /**
- * @param {BootstrapPowers & {
- *   consume: { loadCriticalVat: ERef<VatLoader<PriceAuthorityVat>>},
- * }} powers
- *
- * @typedef {ERef<ReturnType<import('../vat-priceAuthority.js').buildRootObject>>} PriceAuthorityVat
+ * @param {BootstrapPowers} powers
  */
 export const startPriceAuthorityRegistry = async ({
   consume: { loadCriticalVat, client },
@@ -398,9 +400,7 @@ export const makeOracleBrands = async ({
 };
 harden(makeOracleBrands);
 
-/**
- * @param {BootstrapPowers & NamedVatPowers} powers
- */
+/** @param {BootstrapPowers & NamedVatPowers} powers */
 export const produceBoard = async ({
   consume: { client },
   produce: { board: pBoard },
@@ -416,10 +416,7 @@ harden(produceBoard);
 
 /**
  * @deprecated use produceBoard
- *
- * @param {BootstrapPowers & {
- *   consume: { loadCriticalVat: ERef<VatLoader<BoardVat>>
- * }}} powers
+ * @param {BootstrapPowers} powers
  */
 export const makeBoard = async ({
   consume: { loadCriticalVat, client },
@@ -436,12 +433,11 @@ harden(makeBoard);
 /**
  * Produce the remote namesByAddress hierarchy.
  *
- * namesByAddress is a NameHub for each provisioned client,
- * available, for example, as `E(home.namesByAddress).lookup('agoric1...')`.
- * `depositFacet` as in `E(home.namesByAddress).lookup('agoric1...', 'depositFacet')`
- * is reserved for use by the Agoric wallet. Each client
- * is given `home.myAddressNameAdmin`, which they can use to
- * assign (update / reserve) any other names they choose.
+ * namesByAddress is a NameHub for each provisioned client, available, for
+ * example, as `E(home.namesByAddress).lookup('agoric1...')`. `depositFacet` as
+ * in `E(home.namesByAddress).lookup('agoric1...', 'depositFacet')` is reserved
+ * for use by the Agoric wallet. Each client is given `home.myAddressNameAdmin`,
+ * which they can use to assign (update / reserve) any other names they choose.
  *
  * @param {BootstrapPowers} powers
  */
@@ -564,8 +560,8 @@ export const installBootContracts = async ({
 /**
  * Mint IST genesis supply.
  *
- * @param { BootstrapPowers & {
- *   vatParameters: { argv: { bootMsg?: typeof bootMsgEx }},
+ * @param {BootstrapPowers & {
+ *   vatParameters: { argv: { bootMsg?: typeof bootMsgEx } };
  * }} powers
  */
 export const mintInitialSupply = async ({
@@ -586,7 +582,11 @@ export const mintInitialSupply = async ({
   ) || { amount: '0' };
   const bootstrapPaymentValue = Nat(BigInt(centralBootstrapSupply.amount));
 
-  /** @type {Awaited<ReturnType<typeof import('../centralSupply.js').start>>} */
+  /**
+   * @type {Awaited<
+   *   ReturnType<typeof import('../centralSupply.js').start>
+   * >}
+   */
   const { creatorFacet } = await E(zoe).startInstance(
     centralSupply,
     {},
@@ -603,9 +603,7 @@ harden(mintInitialSupply);
 /**
  * Add IST (with initialSupply payment), BLD (with mint) to BankManager.
  *
- * @param { BootstrapSpace & {
- *   consume: { loadCriticalVat: ERef<VatLoader<BankVat>> },
- * }} powers
+ * @param {BootstrapSpace} powers
  */
 export const addBankAssets = async ({
   consume: {
@@ -644,14 +642,16 @@ export const addBankAssets = async ({
   });
 
   const bldBrand = await E(bldIssuer).getBrand();
-  const bldKit = harden({ mint: bldMint, issuer: bldIssuer, brand: bldBrand });
+  const bldKit = /** @type {IssuerKit<'nat'>} */ (
+    harden({ mint: bldMint, issuer: bldIssuer, brand: bldBrand })
+  );
   bldIssuerKit.resolve(bldKit);
 
   const assetAdmin = E(agoricNamesAdmin).lookupAdmin('vbankAsset');
 
   const bridgeManager = await bridgeManagerP;
   const bankBridgeManager =
-    bridgeManager && E(bridgeManager).register(BridgeId.BANK);
+    bridgeManager && makeScopedBridge(bridgeManager, BridgeId.BANK);
   const bankMgr = await E(E(loadCriticalVat)('bank')).makeBankManager(
     bankBridgeManager,
     assetAdmin,
@@ -692,7 +692,7 @@ export const addBankAssets = async ({
 };
 harden(addBankAssets);
 
-/** @type {import('./lib-boot').BootstrapManifest} */
+/** @type {import('./lib-boot.js').BootstrapManifest} */
 export const BASIC_BOOTSTRAP_PERMITS = {
   bridgeCoreEval: true, // Needs all the powers.
   [makeOracleBrands.name]: {

package/src/core/boot-chain.d.ts

@@ -1,60 +1,194 @@
+export namespace modules {
+    let behaviors: {
+        bridgeCoreEval: (allPowers: BootstrapPowers) => Promise<void>;
+        makeProvisioner: ({ consume: { clientCreator, loadCriticalVat }, vats: { comms, vattp }, produce: { provisioning }, }: BootstrapPowers) => Promise<void>;
+        noProvisioner: ({ produce: { provisioning } }: BootstrapPowers) => Promise<void>;
+        bridgeProvisioner: ({ consume: { provisioning: provisioningP, provisionBridgeManager: provisionBridgeManagerP, provisionWalletBridgeManager: provisionWalletBridgeManagerP, }, }: BootstrapPowers) => Promise<void>;
+        setupClientManager: ({ produce: { client, clientCreator: clientCreatorP } }: BootstrapSpace, { template, }?: {
+            template?: Record<string, unknown>;
+        }) => Promise<void>;
+        startTimerService: ({ devices: { timer: timerDevice }, vats: { timer: timerVat }, consume: { client }, produce: { chainTimerService: produceTimer }, brand: { produce: { timer }, }, }: BootstrapPowers) => Promise<void>;
+        makeBridgeManager: ({ consume: { loadCriticalVat }, devices: { bridge }, produce: { bridgeManager: bridgeManagerP, provisionBridgeManager, provisionWalletBridgeManager, walletBridgeManager, }, }: BootDevices<ChainDevices> & BootstrapSpace) => Promise<void>;
+        makeChainStorage: ({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP }, produce: { chainStorage: chainStorageP, storageBridgeManager: storageBridgeManagerP, }, }: BootstrapSpace) => Promise<void>;
+        produceHighPrioritySendersManager: ({ consume: { loadCriticalVat, storageBridgeManager: storageBridgeManagerP }, produce: { highPrioritySendersManager: managerP }, }: BootstrapSpace) => Promise<void>;
+        publishAgoricNamesToChainStorage: ({ consume: { chainStorage: rootP }, namedVat: { consume: { agoricNames, board: vatBoard }, }, }: BootstrapPowers & NamedVatPowers) => Promise<void>;
+        publishAgoricNames: ({ consume: { agoricNamesAdmin, board, chainStorage: rootP } }: BootstrapPowers, { options: { agoricNamesOptions } }?: {
+            options?: {
+                agoricNamesOptions?: {
+                    topLevel?: string[];
+                };
+            };
+        }) => Promise<void>;
+        connectChainFaucet: ({ consume: { client } }: BootstrapPowers) => Promise<void>;
+        makeVatsFromBundles: ({ vats, devices, consume: { vatStore }, produce: { vatAdminSvc, loadVat, loadCriticalVat }, }: BootstrapPowers & {
+            produce: {
+                loadVat: Producer<VatLoader>;
+                loadCriticalVat: Producer<VatLoader>;
+            };
+        }) => Promise<void>;
+        produceDiagnostics: ({ produce }: Pick<ChainBootstrapSpace, "produce">) => Promise<void>;
+        produceStartUpgradable: ({ zone, consume: { diagnostics, zoe }, produce, }: BootstrapSpace & {
+            zone: import("@agoric/base-zone").Zone;
+        }) => Promise<void>;
+        produceStartGovernedUpgradable: ({ zone, consume: { chainTimerService, diagnostics, economicCommitteeCreatorFacet, zoe, }, produce, installation: { consume: { contractGovernor }, }, }: BootstrapSpace & {
+            zone: import("@agoric/base-zone").Zone;
+            consume: {
+                economicCommitteeCreatorFacet: import("@agoric/inter-protocol/src/proposals/econ-behaviors.js").EconomyBootstrapPowers["consume"]["economicCommitteeCreatorFacet"];
+            };
+        }) => Promise<void>;
+        buildZoe: ({ consume: { vatAdminSvc, loadCriticalVat, client }, produce: { zoe, feeMintAccess }, brand: { produce: { Invitation: invitationBrand }, }, issuer: { produce: { Invitation: invitationIssuer }, }, }: BootstrapPowers) => Promise<void>;
+        startPriceAuthorityRegistry: ({ consume: { loadCriticalVat, client }, produce, }: BootstrapPowers) => Promise<void>;
+        makeOracleBrands: ({ namedVat: { consume: { agoricNames }, }, oracleBrand: { produce: { USD }, }, }: BootstrapPowers & NamedVatPowers) => Promise<void>;
+        produceBoard: ({ consume: { client }, produce: { board: pBoard }, namedVat: { consume: { board: vatBoard }, }, }: BootstrapPowers & NamedVatPowers) => Promise<void>;
+        makeBoard: ({ consume: { loadCriticalVat, client }, produce: { board: { resolve: resolveBoard }, }, }: BootstrapPowers) => Promise<void>;
+        produceNamesByAddress: ({ consume: { agoricNames, provisioning: provisioningOptP, client }, produce: { namesByAddress, namesByAddressAdmin }, }: BootstrapPowers) => Promise<void>;
+        makeAddressNameHubs: ({ consume: { agoricNames: agoricNamesP, client }, produce, }: BootstrapSpace) => Promise<void>;
+        makeClientBanks: ({ consume: { namesByAddressAdmin, client, bankManager, walletFactoryStartResult, }, }: BootstrapSpace) => Promise<void>;
+        installBootContracts: ({ consume: { vatAdminSvc, zoe }, installation: { produce: { centralSupply, mintHolder }, }, }: BootstrapSpace) => Promise<void>;
+        mintInitialSupply: ({ vatParameters: { argv: { bootMsg }, }, consume: { feeMintAccess: feeMintAccessP, zoe }, produce: { initialSupply }, installation: { consume: { centralSupply }, }, }: BootstrapPowers & {
+            vatParameters: {
+                argv: {
+                    bootMsg?: {
+                        type: string;
+                        chainID: string;
+                        storagePort: number;
+                        supplyCoins: {
+                            denom: string;
+                            amount: string;
+                        }[];
+                        swingsetPort: number;
+                        vbankPort: number;
+                        vibcPort: number;
+                    };
+                };
+            };
+        }) => Promise<void>;
+        addBankAssets: ({ consume: { agoricNamesAdmin, initialSupply, bridgeManager: bridgeManagerP, loadCriticalVat, startUpgradable, zoe, }, produce: { bankManager, bldIssuerKit }, installation: { consume: { mintHolder }, }, issuer: { produce: produceIssuer }, brand: { produce: produceBrand }, }: BootstrapSpace) => Promise<void>;
+    };
+    let utils: {
+        agoricNamesReserved: { [P in keyof WellKnownName]: { [P2 in WellKnownName[P]]: string; }; };
+        feeIssuerConfig: FeeIssuerConfig;
+        addRemote: (addr: string, { vats: { comms, vattp } }: {
+            vats: {
+                vattp: VattpVat;
+                comms: CommsVatRoot;
+            };
+        }) => Promise<void>;
+        callProperties: (builders: ((...args: any) => Record<string, unknown>)[], ...args: unknown[]) => Record<string, unknown>;
+        extract: (template: true | string | Record<string, any>, specimen: unknown, path?: string[] | undefined) => any;
+        extractPowers: (permit: true | string | Record<string, any>, allPowers: unknown) => any;
+        runModuleBehaviors: ({ allPowers, behaviors, manifest, makeConfig, }: {
+            allPowers: unknown;
+            behaviors: Record<string, unknown>;
+            manifest: Record<string, Record<string, unknown>>;
+            makeConfig: (name: string, permit: Record<string, unknown>) => unknown;
+        }) => Promise<any[]>;
+        makePromiseSpaceForNameHub: (nameAdmin: ERef<import("../types.js").NameAdmin>, log?: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        } | undefined) => PromiseSpaceOf<any, {}, {}>;
+        makeWellKnownSpaces: (parentAdmin: ERef<import("../types.js").NameAdmin>, log?: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        } | undefined, kinds?: string[] | undefined) => Promise<WellKnownSpaces>;
+        makeAgoricNamesAccess: (log?: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        } | undefined, reserved?: Record<string, Record<string, unknown>>) => Promise<{
+            agoricNames: import("../types.js").NameHub;
+            agoricNamesAdmin: import("../types.js").NameAdmin;
+            spaces: WellKnownSpaces;
+        }>;
+        makeMyAddressNameAdminKit: (address: string) => {
+            nameHub: import("../types.js").NameHub<any>;
+            myAddressNameAdmin: import("../types.js").MyAddressNameAdmin;
+        };
+        makeVatSpace: (svc: ERef<ReturnType<Awaited<VatAdminVat>["createVatAdminService"]>>, criticalVatKey: unknown, log?: ((...args: any) => void) | undefined, label?: string | undefined) => {
+            space: {
+                consume: {
+                    agoricNames: Promise<{
+                        getNameHub: () => import("../types.js").NameHub<any>;
+                        getNameHubKit: () => import("../types.js").NameHubKit;
+                        publishNameHubs: (nameStorage: ERef<StorageNode>, vatBoard: ERef<BoardVat>, kinds: string[]) => Promise<void>;
+                        provideInertBrand: (keyword: string, displayInfo: DisplayInfo) => any;
+                    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                        getNameHub: () => import("../types.js").NameHub<any>;
+                        getNameHubKit: () => import("../types.js").NameHubKit;
+                        publishNameHubs: (nameStorage: ERef<StorageNode>, vatBoard: ERef<BoardVat>, kinds: string[]) => Promise<void>;
+                        provideInertBrand: (keyword: string, displayInfo: DisplayInfo) => any;
+                    }>>;
+                    board: Promise<{
+                        getBoard: () => import("@endo/exo").Guarded<{
+                            getId(value: import("@endo/pass-style").RemotableObject): string;
+                            getValue(id: BoardId): import("@endo/pass-style").RemotableObject;
+                            lookup(...path: string[]): Promise<any>;
+                            has(val: import("@endo/pass-style").RemotableObject): boolean;
+                            ids(): string[];
+                            getPublishingMarshaller(): import("@endo/exo").Guarded<{
+                                toCapData(val: any): import("@endo/marshal").CapData<string>;
+                                fromCapData(data: any): any;
+                                serialize(data: any): import("@endo/marshal").CapData<string>;
+                                unserialize(data: any): any;
+                            }>;
+                            getReadonlyMarshaller(): import("@endo/exo").Guarded<{
+                                toCapData(val: any): import("@endo/marshal").CapData<string | null>;
+                                fromCapData(data: any): any;
+                                serialize(data: any): import("@endo/marshal").CapData<string | null>;
+                                unserialize(data: any): any;
+                            }>;
+                        }>;
+                        makePublishingRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>;
+                        makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>;
+                    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                        getBoard: () => import("@endo/exo").Guarded<{
+                            getId(value: import("@endo/pass-style").RemotableObject): string;
+                            getValue(id: BoardId): import("@endo/pass-style").RemotableObject;
+                            lookup(...path: string[]): Promise<any>;
+                            has(val: import("@endo/pass-style").RemotableObject): boolean;
+                            ids(): string[];
+                            getPublishingMarshaller(): import("@endo/exo").Guarded<{
+                                toCapData(val: any): import("@endo/marshal").CapData<string>;
+                                fromCapData(data: any): any;
+                                serialize(data: any): import("@endo/marshal").CapData<string>;
+                                unserialize(data: any): any;
+                            }>;
+                            getReadonlyMarshaller(): import("@endo/exo").Guarded<{
+                                toCapData(val: any): import("@endo/marshal").CapData<string | null>;
+                                fromCapData(data: any): any;
+                                serialize(data: any): import("@endo/marshal").CapData<string | null>;
+                                unserialize(data: any): any;
+                            }>;
+                        }>;
+                        makePublishingRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>;
+                        makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>;
+                    }>>;
+                };
+            };
+            durableStore: globalThis.MapStore<any, any>;
+        };
+    };
+}
+/** @typedef {typeof modules} BootstrapModules */
 export const MANIFEST: import("./lib-boot.js").BootstrapManifest;
-export function buildRootObject(vatPowers: import("@agoric/swingset-vat").TerminationVatPowers & {
+export function buildRootObject(vatPowers: VatPowers & {
     D: DProxy;
     logger: (msg: any) => void;
 }, vatParameters: {
-    coreProposalCode?: string;
-}, baggage: MapStore<string, unknown>): {
+    coreProposalCodeSteps?: string[];
+}, baggage: import("@agoric/vat-data").Baggage): {
     bootstrap: (vats: SwingsetVats, devices: SoloDevices | ChainDevices) => Promise<void>;
     consumeItem: (name: any) => Promise<unknown>;
     produceItem: (name: any, resolution: any) => void;
     resetItem: (name: any) => void;
-    messageVat: ({ name, methodName, args }: {
-        name: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => Promise<any>;
-    messageVatObject: ({ presence, methodName, args }: {
-        presence: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => Promise<any>;
-    messageVatObjectSendOnly: ({ presence, methodName, args }: {
-        presence: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => void;
-    awaitVatObject: ({ presence, path, rawOutput }: {
-        presence: any;
-        path?: any[] | undefined;
-        rawOutput?: boolean | undefined;
-    }) => Promise<any>;
+    awaitVatObject: (presence: any, path?: any[]) => Promise<any>;
     snapshotStore: <K, V>(store: MapStore<K, V>) => [K, V][];
-} & import("@endo/eventual-send").RemotableBrand<{}, {
+} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     bootstrap: (vats: SwingsetVats, devices: SoloDevices | ChainDevices) => Promise<void>;
     consumeItem: (name: any) => Promise<unknown>;
     produceItem: (name: any, resolution: any) => void;
     resetItem: (name: any) => void;
-    messageVat: ({ name, methodName, args }: {
-        name: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => Promise<any>;
-    messageVatObject: ({ presence, methodName, args }: {
-        presence: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => Promise<any>;
-    messageVatObjectSendOnly: ({ presence, methodName, args }: {
-        presence: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => void;
-    awaitVatObject: ({ presence, path, rawOutput }: {
-        presence: any;
-        path?: any[] | undefined;
-        rawOutput?: boolean | undefined;
-    }) => Promise<any>;
+    awaitVatObject: (presence: any, path?: any[]) => Promise<any>;
     snapshotStore: <K, V>(store: MapStore<K, V>) => [K, V][];
 }>;
+export type BootstrapModules = typeof modules;
 //# sourceMappingURL=boot-chain.d.ts.map

package/src/core/boot-chain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boot-chain.d.ts","sourceRoot":"","sources":["boot-chain.js"],"names":[],"mappings":"AAqBA,iEAAiD;AAc1C;OARC,MAAM;0BACQ,IAAI;kBAEf;IACV,gBAAoB,CAAC,EAAE,MAAM,CAAC;CAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAeH"}
+{"version":3,"file":"boot-chain.d.ts","sourceRoot":"","sources":["boot-chain.js"],"names":[],"mappings":";;;;;;;oBAkD2uK,CAAC;;;;;;;;mBAA07N,CAAC;kCAA6B,CAAC;4BAAqB,CAAC;;;;;;;;;;;;;yBAAjnS,mBAAc;;;yBAA0/G,mBAAc;;+CAA6D,OAAQ,wDAAwD,mCAAmC;;;;;;;;;;;;;;;2BAAguQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;qCAA59Z,GAAG;;;;;;;;;4DAAilG,aAAa;;;;uDAAkpB,aAAa;;;;;;;;gCAA2xC,aAAa;qCAAyC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iGAApoH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA/B1gH,iDAAiD;AAEjD,iEAAiD;AAc1C,2CATI,SAAS,GAAG;IACtB,CAAK,EAAE,MAAM,CAAC;IACd,MAAU,EAAE,CAAC,GAAG,KAAA,KAAK,IAAI,CAAC;CACvB,iBACO;IACV,qBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC,WACO,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;;;;GAc5C;+BA5Ba,OAAO,OAAO"}

package/src/core/boot-chain.js

@@ -1,4 +1,3 @@
-// @ts-check
 import { makeDurableZone } from '@agoric/zone/durable.js';
 import { makeBootstrap } from './lib-boot.js';
 
@@ -14,10 +13,11 @@ const {
 } = chainBehaviorsPlus;
 const behaviors = { ...basicBehaviors, ...chainBehaviors };
 
-const modules = {
+export const modules = {
   behaviors: { ...behaviors },
   utils: { ...utils },
 };
+/** @typedef {typeof modules} BootstrapModules */
 
 export const MANIFEST = CHAIN_BOOTSTRAP_MANIFEST;
 
@@ -25,11 +25,11 @@ export const MANIFEST = CHAIN_BOOTSTRAP_MANIFEST;
  * Build root object of the bootstrap vat.
  *
  * @param {VatPowers & {
- *   D: DProxy,
- *   logger: (msg) => void,
+ *   D: DProxy;
+ *   logger: (msg) => void;
  * }} vatPowers
  * @param {{
- *   coreProposalCode?: string,
+ *   coreProposalCodeSteps?: string[];
  * }} vatParameters
  * @param {import('@agoric/vat-data').Baggage} baggage
  */

package/src/core/boot-sim.d.ts

@@ -1,62 +1,24 @@
 export const MANIFEST: {
     [x: string]: import("./lib-boot.js").BootstrapManifestPermit;
 };
-export function buildRootObject(vatPowers: import("@agoric/swingset-vat").TerminationVatPowers & {
+export function buildRootObject(vatPowers: VatPowers & {
     D: DProxy;
     logger: (msg: any) => void;
 }, vatParameters: {
-    coreProposalCode?: string;
+    coreProposalCodeSteps?: string[];
 }): {
     bootstrap: (vats: SwingsetVats, devices: SoloDevices | ChainDevices) => Promise<void>;
     consumeItem: (name: any) => Promise<unknown>;
     produceItem: (name: any, resolution: any) => void;
     resetItem: (name: any) => void;
-    messageVat: ({ name, methodName, args }: {
-        name: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => Promise<any>;
-    messageVatObject: ({ presence, methodName, args }: {
-        presence: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => Promise<any>;
-    messageVatObjectSendOnly: ({ presence, methodName, args }: {
-        presence: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => void;
-    awaitVatObject: ({ presence, path, rawOutput }: {
-        presence: any;
-        path?: any[] | undefined;
-        rawOutput?: boolean | undefined;
-    }) => Promise<any>;
+    awaitVatObject: (presence: any, path?: any[]) => Promise<any>;
     snapshotStore: <K, V>(store: MapStore<K, V>) => [K, V][];
-} & import("@endo/eventual-send").RemotableBrand<{}, {
+} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     bootstrap: (vats: SwingsetVats, devices: SoloDevices | ChainDevices) => Promise<void>;
     consumeItem: (name: any) => Promise<unknown>;
     produceItem: (name: any, resolution: any) => void;
     resetItem: (name: any) => void;
-    messageVat: ({ name, methodName, args }: {
-        name: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => Promise<any>;
-    messageVatObject: ({ presence, methodName, args }: {
-        presence: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => Promise<any>;
-    messageVatObjectSendOnly: ({ presence, methodName, args }: {
-        presence: any;
-        methodName: any;
-        args?: any[] | undefined;
-    }) => void;
-    awaitVatObject: ({ presence, path, rawOutput }: {
-        presence: any;
-        path?: any[] | undefined;
-        rawOutput?: boolean | undefined;
-    }) => Promise<any>;
+    awaitVatObject: (presence: any, path?: any[]) => Promise<any>;
     snapshotStore: <K, V>(store: MapStore<K, V>) => [K, V][];
 }>;
 //# sourceMappingURL=boot-sim.d.ts.map

package/src/core/boot-sim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boot-sim.d.ts","sourceRoot":"","sources":["boot-sim.js"],"names":[],"mappings":"AAgBA;;EAGE;AAiBK;OAPC,MAAM;0BACQ,IAAI;kBAEf;IACV,gBAAoB,CAAC,EAAE,MAAM,CAAC;CAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMH"}
+{"version":3,"file":"boot-sim.d.ts","sourceRoot":"","sources":["boot-sim.js"],"names":[],"mappings":"AAeA;;EAGE;AAiBK,2CARI,SAAS,GAAG;IACtB,CAAK,EAAE,MAAM,CAAC;IACd,MAAU,EAAE,CAAC,GAAG,KAAA,KAAK,IAAI,CAAC;CACvB,iBACO;IACV,qBAAyB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC;;;;;;;;;;;;;;GAMH"}

package/src/core/boot-sim.js

@@ -1,4 +1,3 @@
-// @ts-check
 import { makeBootstrap } from './lib-boot.js';
 
 import * as basicBehaviorsPlus from './basic-behaviors.js';
@@ -27,11 +26,11 @@ const modules = harden({ behaviors: { ...behaviors }, utils: { ...utils } });
  * Build root object of the bootstrap vat for the simulated chain.
  *
  * @param {VatPowers & {
- *   D: DProxy,
- *   logger: (msg) => void,
+ *   D: DProxy;
+ *   logger: (msg) => void;
  * }} vatPowers
  * @param {{
- *   coreProposalCode?: string,
+ *   coreProposalCodeSteps?: string[];
  * }} vatParameters
  */
 export const buildRootObject = (vatPowers, vatParameters) => {