@agoric/vats 0.15.2-dev-822ab08.0 → 0.15.2-dev-4685ea9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vats",
-  "version": "0.15.2-dev-822ab08.0+822ab08",
+  "version": "0.15.2-dev-4685ea9.0+4685ea9",
   "description": "Agoric's Vat library",
   "type": "module",
   "main": "./index.js",
@@ -22,20 +22,20 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-822ab08.0+822ab08",
-    "@agoric/cosmic-proto": "0.4.1-dev-822ab08.0+822ab08",
-    "@agoric/ertp": "0.16.3-dev-822ab08.0+822ab08",
-    "@agoric/governance": "0.10.4-dev-822ab08.0+822ab08",
-    "@agoric/internal": "0.3.3-dev-822ab08.0+822ab08",
-    "@agoric/network": "0.1.1-dev-822ab08.0+822ab08",
-    "@agoric/notifier": "0.6.3-dev-822ab08.0+822ab08",
-    "@agoric/store": "0.9.3-dev-822ab08.0+822ab08",
-    "@agoric/swingset-vat": "0.32.3-dev-822ab08.0+822ab08",
-    "@agoric/time": "0.3.3-dev-822ab08.0+822ab08",
-    "@agoric/vat-data": "0.5.3-dev-822ab08.0+822ab08",
-    "@agoric/vow": "0.1.1-dev-822ab08.0+822ab08",
-    "@agoric/zoe": "0.26.3-dev-822ab08.0+822ab08",
-    "@agoric/zone": "0.2.3-dev-822ab08.0+822ab08",
+    "@agoric/assert": "0.6.1-dev-4685ea9.0+4685ea9",
+    "@agoric/cosmic-proto": "0.4.1-dev-4685ea9.0+4685ea9",
+    "@agoric/ertp": "0.16.3-dev-4685ea9.0+4685ea9",
+    "@agoric/governance": "0.10.4-dev-4685ea9.0+4685ea9",
+    "@agoric/internal": "0.3.3-dev-4685ea9.0+4685ea9",
+    "@agoric/network": "0.1.1-dev-4685ea9.0+4685ea9",
+    "@agoric/notifier": "0.6.3-dev-4685ea9.0+4685ea9",
+    "@agoric/store": "0.9.3-dev-4685ea9.0+4685ea9",
+    "@agoric/swingset-vat": "0.32.3-dev-4685ea9.0+4685ea9",
+    "@agoric/time": "0.3.3-dev-4685ea9.0+4685ea9",
+    "@agoric/vat-data": "0.5.3-dev-4685ea9.0+4685ea9",
+    "@agoric/vow": "0.1.1-dev-4685ea9.0+4685ea9",
+    "@agoric/zoe": "0.26.3-dev-4685ea9.0+4685ea9",
+    "@agoric/zone": "0.2.3-dev-4685ea9.0+4685ea9",
     "@endo/base64": "^1.0.5",
     "@endo/far": "^1.1.2",
     "@endo/import-bundle": "^1.1.2",
@@ -47,7 +47,7 @@
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-822ab08.0+822ab08",
+    "@agoric/swingset-liveslots": "0.10.3-dev-4685ea9.0+4685ea9",
     "@endo/bundle-source": "^3.2.3",
     "@endo/init": "^1.1.2",
     "ava": "^5.3.0",
@@ -81,5 +81,5 @@
   "typeCoverage": {
     "atLeast": 91.33
   },
-  "gitHead": "822ab08b63f3bb737372eb6c3a4fad1fbf22e09f"
+  "gitHead": "4685ea97ebea26b2aad1f75f9d553558156eb5f6"
 }

package/src/localchain.d.ts

@@ -1,3 +1,20 @@
+/**
+ * @import {BankManager, Bank} from './vat-bank.js';
+ * @import {ScopedBridgeManager} from './types.js';
+ */
+/** @import {TypedJson, ResponseTo} from '@agoric/cosmic-proto'; */
+/**
+ * @typedef {{
+ *   system: ScopedBridgeManager;
+ *   bank: Bank;
+ * }} AccountPowers
+ */
+/**
+ * @typedef {{
+ *   system: ScopedBridgeManager;
+ *   bankManager: BankManager;
+ * }} LocalChainPowers
+ */
 export const LocalChainAccountI: import("@endo/patterns").InterfaceGuard<{
     getAddress: import("@endo/patterns").MethodGuard;
     deposit: import("@endo/patterns").MethodGuard;
@@ -13,90 +30,99 @@ export const LocalChainI: import("@endo/patterns").InterfaceGuard<{
     query: import("@endo/patterns").MethodGuard;
     queryMany: import("@endo/patterns").MethodGuard;
 }>;
-export const LocalChainAdminI: import("@endo/patterns").InterfaceGuard<{
-    setPower: import("@endo/patterns").MethodGuard;
-}>;
 export function prepareLocalChainTools(zone: import("@agoric/base-zone").Zone): {
-    makeLocalChain: (initialPowers?: Partial<LocalChainPowers> | undefined) => import("@endo/exo").GuardedKit<{
-        admin: {
-            /**
-             * @template {keyof LocalChainPowers} K
-             * @param {K} name
-             * @param {LocalChainPowers[K]} [power]
-             */
-            setPower<K extends keyof LocalChainPowers>(name: K, power?: LocalChainPowers[K] | undefined): void;
-        };
-        public: {
-            /**
-             * Allocate a fresh address that doesn't correspond with a public key,
-             * and follows the ICA guidelines to help reduce collisions. See
-             * x/vlocalchain/keeper/keeper.go AllocateAddress for the use of the app
-             * hash and block data hash.
-             */
-            makeAccount(): Promise<import("@endo/exo").Guarded<{
-                getAddress(): Promise<string>;
-                /**
-                 * Deposit a payment into the bank purse that matches the alleged brand.
-                 * This is safe, since even if the payment lies about its brand, ERTP will
-                 * reject spoofed payment objects when depositing into a purse.
-                 *
-                 * @param {Payment} payment
-                 */
-                deposit(payment: Payment): Promise<import("@agoric/ertp/exported.js").NatAmount | import("@agoric/ertp/exported.js").CopySetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").SetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").CopyBagAmount<import("@endo/patterns").Key>>;
-                /**
-                 * Execute a batch of transactions and return the responses. Use
-                 * `typedJson()` on the arguments to get typed return values.
-                 *
-                 * @template {TypedJson[]} MT messages tuple (use const with multiple
-                 *   elements or it will be a mixed array)
-                 * @param {MT} messages
-                 * @returns {Promise<{ [K in keyof MT]: ResponseTo<MT[K]> }>}
-                 */
-                executeTx<MT extends {
-                    '@type': string;
-                }[]>(messages: MT): Promise<{ [K_1 in keyof MT]: ResponseTo<MT[K_1]>; }>;
-            }>>;
+    makeLocalChain: (powers: LocalChainPowers) => import("@endo/exo").Guarded<{
+        /**
+         * Allocate a fresh address that doesn't correspond with a public key, and
+         * follows the ICA guidelines to help reduce collisions. See
+         * x/vlocalchain/keeper/keeper.go AllocateAddress for the use of the app
+         * hash and block data hash.
+         */
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            getAddress(): Promise<string>;
             /**
-             * Make a single query to the local chain. Will reject with an error if
-             * the query fails. Otherwise, return the response as a JSON-compatible
-             * object.
+             * Deposit a payment into the bank purse that matches the alleged brand.
+             * This is safe, since even if the payment lies about its brand, ERTP will
+             * reject spoofed payment objects when depositing into a purse.
              *
-             * @param {import('@agoric/cosmic-proto').TypedJson} request
-             * @returns {Promise<import('@agoric/cosmic-proto').TypedJson>}
+             * @param {Payment} payment
              */
-            query(request: import("@agoric/cosmic-proto").TypedJson): Promise<import("@agoric/cosmic-proto").TypedJson>;
+            deposit(payment: Payment): Promise<import("@agoric/ertp/exported.js").NatAmount | import("@agoric/ertp/exported.js").CopySetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").SetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").CopyBagAmount<import("@endo/patterns").Key>>;
             /**
-             * Send a batch of query requests to the local chain. Unless there is a
-             * system error, will return all results to indicate their success or
-             * failure.
+             * Execute a batch of transactions and return the responses. Use
+             * `typedJson()` on the arguments to get typed return values.
              *
-             * @param {import('@agoric/cosmic-proto').TypedJson[]} requests
-             * @returns {Promise<
-             *   {
-             *     error?: string;
-             *     reply: import('@agoric/cosmic-proto').TypedJson;
-             *   }[]
-             * >}
+             * @template {TypedJson[]} MT messages tuple (use const with multiple
+             *   elements or it will be a mixed array)
+             * @param {MT} messages
+             * @returns {Promise<{ [K in keyof MT]: ResponseTo<MT[K]> }>}
              */
-            queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
-                error?: string;
-                reply: import("@agoric/cosmic-proto").TypedJson;
-            }[]>;
-        };
+            executeTx<MT extends {
+                '@type': string;
+            }[]>(messages: MT): Promise<{ [K in keyof MT]: ResponseTo<MT[K]>; }>;
+        }>>;
+        /**
+         * Make a single query to the local chain. Will reject with an error if
+         * the query fails. Otherwise, return the response as a JSON-compatible
+         * object.
+         *
+         * @param {import('@agoric/cosmic-proto').TypedJson} request
+         * @returns {Promise<import('@agoric/cosmic-proto').TypedJson>}
+         */
+        query(request: import("@agoric/cosmic-proto").TypedJson): Promise<import("@agoric/cosmic-proto").TypedJson>;
+        /**
+         * Send a batch of query requests to the local chain. Unless there is a
+         * system error, will return all results to indicate their success or
+         * failure.
+         *
+         * @param {import('@agoric/cosmic-proto').TypedJson[]} requests
+         * @returns {Promise<
+         *   {
+         *     error?: string;
+         *     reply: import('@agoric/cosmic-proto').TypedJson;
+         *   }[]
+         * >}
+         */
+        queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
+            error?: string;
+            reply: import("@agoric/cosmic-proto").TypedJson;
+        }[]>;
     }>;
 };
+export type AccountPowers = {
+    system: ScopedBridgeManager;
+    bank: Bank;
+};
 export type LocalChainPowers = {
-    system: import("./types.js").ScopedBridgeManager;
-    bankManager: import("./vat-bank.js").BankManager;
+    system: ScopedBridgeManager;
+    bankManager: import("@endo/exo").Guarded<{
+        getAssetSubscription(): globalThis.IterableEachTopic<import("./vat-bank.js").AssetDescriptor>;
+        getRewardDistributorDepositFacet(denom: string, feeKit: AssetIssuerKit): globalThis.ERef<{
+            /**
+             * Deposit all the contents of payment
+             * into the purse that made this facet, returning the amount. If the optional
+             * argument `optAmount` does not equal the amount of digital assets in the
+             * payment, throw an error.
+             *
+             * If payment is a promise, throw an error.
+             */
+            receive: (args_0: globalThis.Payment, args_1?: globalThis.Pattern) => globalThis.ERef<globalThis.Amount>;
+        }>;
+        getModuleAccountAddress(moduleName: string): Promise<string | null>;
+        addAsset(denom: string, issuerName: string, proposedName: string, kit: AssetIssuerKit & {
+            payment?: ERef<Payment>;
+        }): Promise<void>;
+        getBankForAddress(address: string): Promise<Bank>;
+    }>;
 };
-export type PowerStore = MapStore<keyof LocalChainPowers, LocalChainPowers[keyof LocalChainPowers]>;
 export type LocalChainAccount = Awaited<ReturnType<Awaited<ReturnType<typeof prepareLocalChainAccount>>>>;
 export type LocalChainTools = ReturnType<typeof prepareLocalChainTools>;
-export type LocalChainKit = ReturnType<LocalChainTools["makeLocalChain"]>;
-export type LocalChain = LocalChainKit["public"];
+export type LocalChain = ReturnType<LocalChainTools["makeLocalChain"]>;
 import type { ResponseTo } from '@agoric/cosmic-proto';
+import type { ScopedBridgeManager } from './types.js';
+import type { Bank } from './vat-bank.js';
 /** @param {import('@agoric/base-zone').Zone} zone */
-declare function prepareLocalChainAccount(zone: import("@agoric/base-zone").Zone): (address: string, powers: PowerStore) => import("@endo/exo").Guarded<{
+declare function prepareLocalChainAccount(zone: import("@agoric/base-zone").Zone): (address: string, powers: AccountPowers) => import("@endo/exo").Guarded<{
     getAddress(): Promise<string>;
     /**
      * Deposit a payment into the bank purse that matches the alleged brand.

package/src/localchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AA+BA;;;;GAMG;AA4DH;;;;GAIG;AAEH;;;;GAIG;AAEH;;GAEG;AAsGI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;YA9EpC;;;;eAIG;qBAFQ,CAAC,uCAAD,CAAC;;;YAkBZ;;;;;eAKG;;;gBAzGL;;;;;;mBAMG;iCADQ,OAAO;gBAYlB;;;;;;;;mBAQG;0BADgD,EAAE;;+BAAF,EAAE,AADxC;;YA2FX;;;;;;;eAOG;2BAFQ,OAAO,sBAAsB,EAAE,SAAS,GACtC,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,CAAC;YAa9D;;;;;;;;;;;;eAYG;gCAPQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,GACxC,OAAO,CACnB;gBACA,KAAW,CAAC,EAAE,MAAM,CAAC;gBACrB,KAAW,EAAE,OAAO,sBAAsB,EAAE,SAAS,CAAC;aACjD,EAAE,CACJ;;;EAoBX;+BAhNY;IACZ,MAAU,EAAE,OAAO,YAAY,EAAE,mBAAmB,CAAC;IACrD,WAAe,EAAE,OAAO,eAAe,EAAE,WAAW,CAAC;CAClD;yBAES,QAAQ,CACpB,MAAU,gBAAgB,EAC1B,gBAAoB,CAAC,MAAM,gBAAgB,CAAC,CACzC;gCAgFS,OAAO,CACnB,UAAc,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CACjE;8BAyHU,UAAU,CAAC,OAAO,sBAAsB,CAAC;4BACzC,UAAU,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;yBAC7C,aAAa,CAAC,QAAQ,CAAC;gCAxNI,sBAAsB;AAgC/D,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC;;;;;;OAMG;qBADQ,OAAO;IAYlB;;;;;;;;OAQG;cADgD,EAAE;;mBAAF,EAAE,AADxC;GAmBhB"}
+{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH,mEAAmE;AAEnE;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;GAMG;AAwDH;;;;GAIG;AAEH;;;;GAIG;AAwEI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;QAxDtC;;;;;WAKG;;;YArEH;;;;;;eAMG;6BADQ,OAAO;YASlB;;;;;;;;eAQG;sBADgD,EAAE;;2BAAF,EAAE,AADxC;;QA0Db;;;;;;;WAOG;uBAFQ,OAAO,sBAAsB,EAAE,SAAS,GACtC,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,CAAC;QAa9D;;;;;;;;;;;;WAYG;4BAPQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,GACxC,OAAO,CACnB;YACA,KAAW,CAAC,EAAE,MAAM,CAAC;YACrB,KAAW,EAAE,OAAO,sBAAsB,EAAE,SAAS,CAAC;SACjD,EAAE,CACJ;;EAkBT;;;;;;;;;gEAKgua,cAAc;;;;;;;;;;;;+EAAgiD,cAAc,GAAE;YAAE,OAAQ,CAAC,EAAC,KAAM,OAAO,CAAC,CAAA;SAAE;;;;gCA3F9yd,OAAO,CACnB,UAAc,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CACjE;8BAuFU,UAAU,CAAC,OAAO,sBAAsB,CAAC;yBACzC,UAAU,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;gCAzKlB,sBAAsB;yCAHzB,YAAY;0BADd,eAAe;AA4BnD,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC;;;;;;OAMG;qBADQ,OAAO;IASlB;;;;;;;;OAQG;cADgD,EAAE;;mBAAF,EAAE,AADxC;GAkBhB"}

package/src/localchain.js

@@ -3,31 +3,28 @@ import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 import { AmountShape } from '@agoric/ertp';
 
-const { Fail, bare } = assert;
+const { Fail } = assert;
+
+/**
+ * @import {BankManager, Bank} from './vat-bank.js';
+ * @import {ScopedBridgeManager} from './types.js';
+ */
 
 /** @import {TypedJson, ResponseTo} from '@agoric/cosmic-proto'; */
 
 /**
  * @typedef {{
- *   system: import('./types.js').ScopedBridgeManager;
- *   bankManager: import('./vat-bank.js').BankManager;
- * }} LocalChainPowers
- *
- * @typedef {MapStore<
- *   keyof LocalChainPowers,
- *   LocalChainPowers[keyof LocalChainPowers]
- * >} PowerStore
+ *   system: ScopedBridgeManager;
+ *   bank: Bank;
+ * }} AccountPowers
  */
 
 /**
- * @template {keyof LocalChainPowers} K
- * @param {PowerStore} powers
- * @param {K} name
+ * @typedef {{
+ *   system: ScopedBridgeManager;
+ *   bankManager: BankManager;
+ * }} LocalChainPowers
  */
-const getPower = (powers, name) => {
-  powers.has(name) || Fail`need powers.${bare(name)} for this method`;
-  return /** @type {LocalChainPowers[K]} */ (powers.get(name));
-};
 
 export const LocalChainAccountI = M.interface('LocalChainAccount', {
   getAddress: M.callWhen().returns(M.string()),
@@ -44,9 +41,9 @@ const prepareLocalChainAccount = zone =>
     LocalChainAccountI,
     /**
      * @param {string} address
-     * @param {PowerStore} powers
+     * @param {AccountPowers} powers
      */
-    (address, powers) => ({ address, powers }),
+    (address, powers) => ({ address, ...powers, reserved: undefined }),
     {
       // Information that the account creator needs.
       async getAddress() {
@@ -60,14 +57,11 @@ const prepareLocalChainAccount = zone =>
        * @param {Payment} payment
        */
       async deposit(payment) {
-        const { address, powers } = this.state;
-
-        const bankManager = getPower(powers, 'bankManager');
+        const { bank } = this.state;
 
         const allegedBrand = await E(payment).getAllegedBrand();
-        const bankAcct = E(bankManager).getBankForAddress(address);
-        const allegedPurse = E(bankAcct).getPurse(allegedBrand);
-        return E(allegedPurse).deposit(payment);
+        const purse = E(bank).getPurse(allegedBrand);
+        return E(purse).deposit(payment);
       },
       /**
        * Execute a batch of transactions and return the responses. Use
@@ -79,7 +73,7 @@ const prepareLocalChainAccount = zone =>
        * @returns {Promise<{ [K in keyof MT]: ResponseTo<MT[K]> }>}
        */
       async executeTx(messages) {
-        const { address, powers } = this.state;
+        const { address, system } = this.state;
         messages.length > 0 || Fail`need at least one message to execute`;
 
         const obj = {
@@ -90,7 +84,6 @@ const prepareLocalChainAccount = zone =>
           address,
           messages,
         };
-        const system = getPower(powers, 'system');
         return E(system).toBridge(obj);
       },
     },
@@ -107,105 +100,71 @@ export const LocalChainI = M.interface('LocalChain', {
   queryMany: M.callWhen(M.arrayOf(M.record())).returns(M.arrayOf(M.record())),
 });
 
-export const LocalChainAdminI = M.interface('LocalChainAdmin', {
-  setPower: M.callWhen(M.string(), M.await(M.any())).returns(),
-});
-
 /**
  * @param {import('@agoric/base-zone').Zone} zone
  * @param {ReturnType<typeof prepareLocalChainAccount>} makeAccount
  */
 const prepareLocalChain = (zone, makeAccount) =>
-  zone.exoClassKit(
+  zone.exoClass(
     'LocalChain',
-    { public: LocalChainI, admin: LocalChainAdminI },
-    /** @param {Partial<LocalChainPowers>} [initialPowers] */
-    initialPowers => {
-      /** @type {PowerStore} */
-      const powers = zone.detached().mapStore('PowerStore');
-      if (initialPowers) {
-        for (const [name, power] of Object.entries(initialPowers)) {
-          powers.init(/** @type {keyof LocalChainPowers} */ (name), power);
-        }
-      }
-      return { powers };
+    LocalChainI,
+    /** @param {LocalChainPowers} powers */
+    powers => {
+      return { ...powers };
     },
     {
-      admin: {
-        /**
-         * @template {keyof LocalChainPowers} K
-         * @param {K} name
-         * @param {LocalChainPowers[K]} [power]
-         */
-        setPower(name, power) {
-          const { powers } = this.state;
-          if (power === undefined) {
-            // Remove from powers.
-            powers.delete(name);
-          } else if (powers.has(name)) {
-            // Replace an existing power.
-            powers.set(name, power);
-          } else {
-            // Add a new power.
-            powers.init(name, power);
-          }
-        },
+      /**
+       * Allocate a fresh address that doesn't correspond with a public key, and
+       * follows the ICA guidelines to help reduce collisions. See
+       * x/vlocalchain/keeper/keeper.go AllocateAddress for the use of the app
+       * hash and block data hash.
+       */
+      async makeAccount() {
+        const { system, bankManager } = this.state;
+        const address = await E(system).toBridge({
+          type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
+        });
+        const bank = await E(bankManager).getBankForAddress(address);
+        return makeAccount(address, { system, bank });
       },
-      public: {
-        /**
-         * Allocate a fresh address that doesn't correspond with a public key,
-         * and follows the ICA guidelines to help reduce collisions. See
-         * x/vlocalchain/keeper/keeper.go AllocateAddress for the use of the app
-         * hash and block data hash.
-         */
-        async makeAccount() {
-          const { powers } = this.state;
-          const system = getPower(powers, 'system');
-          const address = await E(system).toBridge({
-            type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
-          });
-          return makeAccount(address, powers);
-        },
-        /**
-         * Make a single query to the local chain. Will reject with an error if
-         * the query fails. Otherwise, return the response as a JSON-compatible
-         * object.
-         *
-         * @param {import('@agoric/cosmic-proto').TypedJson} request
-         * @returns {Promise<import('@agoric/cosmic-proto').TypedJson>}
-         */
-        async query(request) {
-          const requests = harden([request]);
-          const results = await E(this.facets.public).queryMany(requests);
-          results.length === 1 ||
-            Fail`expected exactly one result; got ${results}`;
-          const { error, reply } = results[0];
-          if (error) {
-            throw Fail`query failed: ${error}`;
-          }
-          return reply;
-        },
-        /**
-         * Send a batch of query requests to the local chain. Unless there is a
-         * system error, will return all results to indicate their success or
-         * failure.
-         *
-         * @param {import('@agoric/cosmic-proto').TypedJson[]} requests
-         * @returns {Promise<
-         *   {
-         *     error?: string;
-         *     reply: import('@agoric/cosmic-proto').TypedJson;
-         *   }[]
-         * >}
-         */
-        async queryMany(requests) {
-          const { powers } = this.state;
-          const system = getPower(powers, 'system');
-          return E(system).toBridge({
-            type: 'VLOCALCHAIN_QUERY_MANY',
-            messages: requests,
-          });
-        },
+      /**
+       * Make a single query to the local chain. Will reject with an error if
+       * the query fails. Otherwise, return the response as a JSON-compatible
+       * object.
+       *
+       * @param {import('@agoric/cosmic-proto').TypedJson} request
+       * @returns {Promise<import('@agoric/cosmic-proto').TypedJson>}
+       */
+      async query(request) {
+        const requests = harden([request]);
+        const results = await E(this.self).queryMany(requests);
+        results.length === 1 ||
+          Fail`expected exactly one result; got ${results}`;
+        const { error, reply } = results[0];
+        if (error) {
+          throw Fail`query failed: ${error}`;
+        }
+        return reply;
+      },
+      /**
+       * Send a batch of query requests to the local chain. Unless there is a
+       * system error, will return all results to indicate their success or
+       * failure.
+       *
+       * @param {import('@agoric/cosmic-proto').TypedJson[]} requests
+       * @returns {Promise<
+       *   {
+       *     error?: string;
+       *     reply: import('@agoric/cosmic-proto').TypedJson;
+       *   }[]
+       * >}
+       */
+      async queryMany(requests) {
+        const { system } = this.state;
+        return E(system).toBridge({
+          type: 'VLOCALCHAIN_QUERY_MANY',
+          messages: requests,
+        });
       },
     },
   );
@@ -220,5 +179,4 @@ export const prepareLocalChainTools = zone => {
 harden(prepareLocalChainTools);
 
 /** @typedef {ReturnType<typeof prepareLocalChainTools>} LocalChainTools */
-/** @typedef {ReturnType<LocalChainTools['makeLocalChain']>} LocalChainKit */
-/** @typedef {LocalChainKit['public']} LocalChain */
+/** @typedef {ReturnType<LocalChainTools['makeLocalChain']>} LocalChain */

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

@@ -1,13 +1,10 @@
-export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, bankManager, }, produce: { localchainVat, localchain, localchainAdmin: localchainAdminP, localchainBridgeManager, }, }: BootstrapPowers & {
+export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, bankManager, }, produce: { localchainVat, localchain, localchainBridgeManager }, }: BootstrapPowers & {
     consume: {
         loadCriticalVat: VatLoader<any>;
-        bridgeManager: import("../types").BridgeManager;
         localchainBridgeManager: import("../types").ScopedBridgeManager;
-        bankManager: Promise<import("../vat-bank.js").BankManager>;
     };
     produce: {
         localchain: Producer<any>;
-        localchainAdmin: Producer<any>;
         localchainVat: Producer<any>;
         localchainBridgeManager: Producer<any>;
     };
@@ -37,7 +34,6 @@ export function getManifestForLocalChain(_powers: any, { localchainRef }: {
             };
             produce: {
                 localchain: string;
-                localchainAdmin: string;
                 localchainVat: string;
                 localchainBridgeManager: string;
             };

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

@@ -1 +1 @@
-{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AA0BO,2QArBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,eAAqB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;QACtC,aAAmB,EAAE,OAAO,UAAU,EAAE,aAAa,CAAC;QACtD,uBAA6B,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC;QACtE,WAAiB,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,WAAW,CAAC,CAAC;KAC5D,CAAC;IACN,OAAW,EAAE;QACb,UAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChC,eAAqB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACrC,aAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACxC,CAAC;CACH;IAEgD,OAAO,EAAhD;QAAE,aAAa,EAAE,YAAY,CAAA;KAAE;kBAoFzC;AAUM,2EAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BL;6BA/HW;IACZ,UAAc,EAAE,IAAI,CAAC,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}
+{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AAuBO,uOAlBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,eAAqB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;QACtC,uBAA6B,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC;KACjE,CAAC;IACN,OAAW,EAAE;QACb,UAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChC,aAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACxC,CAAC;CACH;IAEgD,OAAO,EAAhD;QAAE,aAAa,EAAE,YAAY,CAAA;KAAE;kBA0DzC;AAUM,2EAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BL;6BApGW;IACZ,UAAc,EAAE,IAAI,CAAC,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}

package/src/proposals/localchain-proposal.js

@@ -6,13 +6,10 @@ import { BridgeId as BRIDGE_ID } from '@agoric/internal';
  * @param {BootstrapPowers & {
  *   consume: {
  *     loadCriticalVat: VatLoader<any>;
- *     bridgeManager: import('../types').BridgeManager;
  *     localchainBridgeManager: import('../types').ScopedBridgeManager;
- *     bankManager: Promise<import('../vat-bank.js').BankManager>;
  *   };
  *   produce: {
  *     localchain: Producer<any>;
- *     localchainAdmin: Producer<any>;
  *     localchainVat: Producer<any>;
  *     localchainBridgeManager: Producer<any>;
  *   };
@@ -32,12 +29,7 @@ export const setupLocalChainVat = async (
       localchainBridgeManager: localchainBridgeManagerP,
       bankManager,
     },
-    produce: {
-      localchainVat,
-      localchain,
-      localchainAdmin: localchainAdminP,
-      localchainBridgeManager,
-    },
+    produce: { localchainVat, localchain, localchainBridgeManager },
   },
   options,
 ) => {
@@ -74,34 +66,13 @@ export const setupLocalChainVat = async (
     );
   }
 
-  const { admin: localChainAdmin, public: newLocalChain } = await E(
-    vats.localchain,
-  ).makeLocalChain({
+  const newLocalChain = await E(vats.localchain).makeLocalChain({
     system: scopedManager,
+    bankManager: await bankManager,
   });
 
   localchain.reset();
   localchain.resolve(newLocalChain);
-  localchainAdminP.reset();
-  localchainAdminP.resolve(localChainAdmin);
-
-  /** @type {Record<string, Promise<void>>} */
-  const descToPromise = {
-    'bank manager power': bankManager.then(bm =>
-      E(localChainAdmin).setPower('bankManager', bm),
-    ),
-  };
-  void Promise.all(
-    Object.entries(descToPromise).map(([desc, p]) =>
-      p
-        .then(() =>
-          console.info(`Completed configuration of localchain with ${desc}`),
-        )
-        .catch(e =>
-          console.error(`Failed to configure localchain with ${desc}:`, e),
-        ),
-    ),
-  );
 };
 
 /**
@@ -131,7 +102,6 @@ export const getManifestForLocalChain = (_powers, { localchainRef }) => ({
       },
       produce: {
         localchain: 'localchain',
-        localchainAdmin: 'localchain',
         localchainVat: 'localchain',
         localchainBridgeManager: 'localchain',
       },

package/src/vat-localchain.d.ts

@@ -3,60 +3,50 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
      * Create a local chain that allows permissionlessly making fresh local
      * chain accounts, then using them to send chain queries and transactions.
      *
-     * @param {Partial<import('./localchain.js').LocalChainPowers>} [initialPowers]
+     * @param {import('./localchain.js').LocalChainPowers} powers
      */
-    makeLocalChain(initialPowers?: Partial<import("./localchain.js").LocalChainPowers> | undefined): import("@endo/exo").GuardedKit<{
-        admin: {
-            setPower<K extends keyof import("./localchain.js").LocalChainPowers>(name: K, power?: import("./localchain.js").LocalChainPowers[K] | undefined): void;
-        };
-        public: {
-            makeAccount(): Promise<import("@endo/exo").Guarded<{
-                getAddress(): Promise<string>;
-                deposit(payment: Payment): Promise<import("@agoric/ertp/exported.js").NatAmount | import("@agoric/ertp/exported.js").CopySetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").SetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").CopyBagAmount<import("@endo/patterns").Key>>;
-                executeTx<MT extends {
-                    '@type': string;
-                }[]>(messages: MT): Promise<{ [K_1 in keyof MT]: import("@agoric/cosmic-proto").ResponseTo<MT[K_1]>; }>;
-            }>>;
-            query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
+    makeLocalChain(powers: import("./localchain.js").LocalChainPowers): import("@endo/exo").Guarded<{
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            getAddress(): Promise<string>;
+            deposit(payment: Payment): Promise<import("@agoric/ertp/exported.js").NatAmount | import("@agoric/ertp/exported.js").CopySetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").SetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").CopyBagAmount<import("@endo/patterns").Key>>;
+            executeTx<MT extends {
                 '@type': string;
-            }>;
-            queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
-                error?: string | undefined;
-                reply: {
-                    '@type': string;
-                };
-            }[]>;
-        };
+            }[]>(messages: MT): Promise<{ [K in keyof MT]: import("@agoric/cosmic-proto").ResponseTo<MT[K]>; }>;
+        }>>;
+        query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
+            '@type': string;
+        }>;
+        queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
+            error?: string | undefined;
+            reply: {
+                '@type': string;
+            };
+        }[]>;
     }>;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     /**
      * Create a local chain that allows permissionlessly making fresh local
      * chain accounts, then using them to send chain queries and transactions.
      *
-     * @param {Partial<import('./localchain.js').LocalChainPowers>} [initialPowers]
+     * @param {import('./localchain.js').LocalChainPowers} powers
      */
-    makeLocalChain(initialPowers?: Partial<import("./localchain.js").LocalChainPowers> | undefined): import("@endo/exo").GuardedKit<{
-        admin: {
-            setPower<K extends keyof import("./localchain.js").LocalChainPowers>(name: K, power?: import("./localchain.js").LocalChainPowers[K] | undefined): void;
-        };
-        public: {
-            makeAccount(): Promise<import("@endo/exo").Guarded<{
-                getAddress(): Promise<string>;
-                deposit(payment: Payment): Promise<import("@agoric/ertp/exported.js").NatAmount | import("@agoric/ertp/exported.js").CopySetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").SetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").CopyBagAmount<import("@endo/patterns").Key>>;
-                executeTx<MT extends {
-                    '@type': string;
-                }[]>(messages: MT): Promise<{ [K_1 in keyof MT]: import("@agoric/cosmic-proto").ResponseTo<MT[K_1]>; }>;
-            }>>;
-            query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
+    makeLocalChain(powers: import("./localchain.js").LocalChainPowers): import("@endo/exo").Guarded<{
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            getAddress(): Promise<string>;
+            deposit(payment: Payment): Promise<import("@agoric/ertp/exported.js").NatAmount | import("@agoric/ertp/exported.js").CopySetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").SetAmount<import("@endo/patterns").Key> | import("@agoric/ertp/exported.js").CopyBagAmount<import("@endo/patterns").Key>>;
+            executeTx<MT extends {
+                '@type': string;
+            }[]>(messages: MT): Promise<{ [K in keyof MT]: import("@agoric/cosmic-proto").ResponseTo<MT[K]>; }>;
+        }>>;
+        query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
+            '@type': string;
+        }>;
+        queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
+            error?: string | undefined;
+            reply: {
                 '@type': string;
-            }>;
-            queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
-                error?: string | undefined;
-                reply: {
-                    '@type': string;
-                };
-            }[]>;
-        };
+            };
+        }[]>;
     }>;
 }>;
 export type LocalChainVat = ReturnType<typeof buildRootObject>;

package/src/vat-localchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vat-localchain.d.ts","sourceRoot":"","sources":["vat-localchain.js"],"names":[],"mappings":"AAMO;IAKH;;;;;OAKG;;;uFAQ8kH,CAAC;;;;;iCAArqF,OAAO;;;+BAA8sB,EAAE;;2BAAkvG,OAAO,sBAAsB,EAAE,SAAS;;;gCAAwtB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;IAbhqL;;;;;OAKG;;;;;;;;;;;;;0DAQk5J,SAAS;;;+DAAuvB,SAAS;;;;;;;;GAHjqL;4BAEa,UAAU,CAAC,OAAO,eAAe,CAAC"}
+{"version":3,"file":"vat-localchain.d.ts","sourceRoot":"","sources":["vat-localchain.js"],"names":[],"mappings":"AAMO;IAKH;;;;;OAKG;2BADQ,OAAO,iBAAiB,EAAE,gBAAgB;;;6BAS+sB,OAAO;;;2BAA+iB,EAAE;;uBAA6oE,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;IAbpsI;;;;;OAKG;2BADQ,OAAO,iBAAiB,EAAE,gBAAgB;;;;;;;;sDASm7G,SAAS;;;2DAAwsB,SAAS;;;;;;;GAHrsI;4BAEa,UAAU,CAAC,OAAO,eAAe,CAAC"}

package/src/vat-localchain.js

@@ -13,10 +13,10 @@ export const buildRootObject = (_vatPowers, _args, baggage) => {
      * Create a local chain that allows permissionlessly making fresh local
      * chain accounts, then using them to send chain queries and transactions.
      *
-     * @param {Partial<import('./localchain.js').LocalChainPowers>} [initialPowers]
+     * @param {import('./localchain.js').LocalChainPowers} powers
      */
-    makeLocalChain(initialPowers = {}) {
-      return makeLocalChain(initialPowers);
+    makeLocalChain(powers) {
+      return makeLocalChain(powers);
     },
   });
 };