@agoric/vats 0.15.2-dev-65d19fe.0 → 0.15.2-dev-accf269.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vats",
-  "version": "0.15.2-dev-65d19fe.0+65d19fe",
+  "version": "0.15.2-dev-accf269.0+accf269",
   "description": "Agoric's Vat library",
   "type": "module",
   "main": "./index.js",
@@ -22,18 +22,18 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-65d19fe.0+65d19fe",
-    "@agoric/ertp": "0.16.3-dev-65d19fe.0+65d19fe",
-    "@agoric/governance": "0.10.4-dev-65d19fe.0+65d19fe",
-    "@agoric/internal": "0.3.3-dev-65d19fe.0+65d19fe",
-    "@agoric/network": "0.1.1-dev-65d19fe.0+65d19fe",
-    "@agoric/notifier": "0.6.3-dev-65d19fe.0+65d19fe",
-    "@agoric/store": "0.9.3-dev-65d19fe.0+65d19fe",
-    "@agoric/swingset-vat": "0.32.3-dev-65d19fe.0+65d19fe",
-    "@agoric/time": "0.3.3-dev-65d19fe.0+65d19fe",
-    "@agoric/vat-data": "0.5.3-dev-65d19fe.0+65d19fe",
-    "@agoric/zoe": "0.26.3-dev-65d19fe.0+65d19fe",
-    "@agoric/zone": "0.2.3-dev-65d19fe.0+65d19fe",
+    "@agoric/assert": "0.6.1-dev-accf269.0+accf269",
+    "@agoric/ertp": "0.16.3-dev-accf269.0+accf269",
+    "@agoric/governance": "0.10.4-dev-accf269.0+accf269",
+    "@agoric/internal": "0.3.3-dev-accf269.0+accf269",
+    "@agoric/network": "0.1.1-dev-accf269.0+accf269",
+    "@agoric/notifier": "0.6.3-dev-accf269.0+accf269",
+    "@agoric/store": "0.9.3-dev-accf269.0+accf269",
+    "@agoric/swingset-vat": "0.32.3-dev-accf269.0+accf269",
+    "@agoric/time": "0.3.3-dev-accf269.0+accf269",
+    "@agoric/vat-data": "0.5.3-dev-accf269.0+accf269",
+    "@agoric/zoe": "0.26.3-dev-accf269.0+accf269",
+    "@agoric/zone": "0.2.3-dev-accf269.0+accf269",
     "@endo/far": "^1.0.4",
     "@endo/import-bundle": "^1.0.4",
     "@endo/marshal": "^1.3.0",
@@ -44,7 +44,7 @@
     "jessie.js": "^0.3.2"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-65d19fe.0+65d19fe",
+    "@agoric/swingset-liveslots": "0.10.3-dev-accf269.0+accf269",
     "@endo/bundle-source": "^3.1.0",
     "@endo/init": "^1.0.4",
     "ava": "^5.3.0",
@@ -77,5 +77,5 @@
   "typeCoverage": {
     "atLeast": 89.52
   },
-  "gitHead": "65d19fe3db9d7365a1bb80cbe3554735aa5704db"
+  "gitHead": "accf269881172476c07506de498adb204637884b"
 }

package/src/localchain.d.ts

@@ -1,22 +1,79 @@
 export const LocalChainAccountI: import("@endo/patterns").InterfaceGuard<{
     getAddress: import("@endo/patterns").MethodGuard;
+    deposit: import("@endo/patterns").MethodGuard;
     executeTx: import("@endo/patterns").MethodGuard;
-    allBalances: import("@endo/patterns").MethodGuard;
 }>;
 export const LocalChainI: import("@endo/patterns").InterfaceGuard<{
     createAccount: import("@endo/patterns").MethodGuard;
     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: (system: import("./types.js").ScopedBridgeManager) => import("@endo/exo/src/exo-makers.js").Guarded<{
-        createAccount(): Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
-            getAddress(): Promise<string>;
-            allBalances(): Promise<any>;
-            executeTx(messages: any): Promise<any>;
-        }>>;
-        query(messages: any): Promise<any>;
+    makeLocalChain: (initialPowers?: Partial<LocalChainPowers> | undefined) => import("@endo/exo/src/exo-makers.js").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.
+             */
+            createAccount(): Promise<import("@endo/exo/src/exo-makers.js").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<Amount<AssetKind>>;
+                executeTx(messages: any): Promise<any>;
+            }>>;
+            /**
+             * 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 {Proto3Jsonable} request
+             * @returns {Promise<Proto3Jsonable>}
+             */
+            query(request: Proto3Jsonable): Promise<Proto3Jsonable>;
+            /**
+             * 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 {Proto3Jsonable[]} requests
+             * @returns {Promise<{ error?: string; reply: Proto3Jsonable }[]>}
+             */
+            queryMany(requests: Proto3Jsonable[]): Promise<{
+                error?: string;
+                reply: Proto3Jsonable;
+            }[]>;
+        };
     }>;
 };
+export type Proto3Jsonable = {
+    [x: string]: unknown;
+    '@type': string;
+};
+export type LocalChainPowers = {
+    system: import('./types.js').ScopedBridgeManager;
+    bankManager: import('./vat-bank.js').BankManager;
+};
+export type PowerStore = MapStore<keyof LocalChainPowers, LocalChainPowers[keyof LocalChainPowers]>;
 export type LocalChainTools = ReturnType<typeof prepareLocalChainTools>;
-export type LocalChain = ReturnType<LocalChainTools['makeLocalChain']>;
+export type LocalChainKit = ReturnType<LocalChainTools['makeLocalChain']>;
+export type LocalChain = LocalChainKit['public'];
 //# sourceMappingURL=localchain.d.ts.map

package/src/localchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAKA;;;;GAMG;AA+CH;;;GAGG;AAmCI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;;;;;;;EAM3C;8BAGa,WAAW,6BAA6B,CAAC;yBACzC,WAAW,eAAe,CAAC,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAoCA;;;;GAMG;AAkDH;;;;GAIG;AAEH;;GAEG;AAiGI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;YAzEpC;;;;eAIG;;;;YAgBH;;;;;eAKG;;;gBAzFL;;;;;;mBAMG;iCADQ,OAAO;;;YA6FhB;;;;;;;eAOG;2BAFQ,cAAc,GACZ,QAAQ,cAAc,CAAC;YAapC;;;;;;;eAOG;gCAFQ,cAAc,EAAE,GACd,QAAQ;gBAAE,KAAK,CAAC,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,cAAc,CAAA;aAAE,EAAE,CAAC;;;EAoBxE;;;aAjMa,MAAM;;+BAMP;IACZ,MAAU,EAAE,OAAO,YAAY,EAAE,mBAAmB,CAAC;IACrD,WAAe,EAAE,OAAO,eAAe,EAAE,WAAW,CAAC;CAClD;yBAES,SACZ,MAAU,gBAAgB,EAC1B,gBAAoB,CAAC,MAAM,gBAAgB,CAAC,CACzC;8BAsLU,WAAW,6BAA6B,CAAC;4BACzC,WAAW,eAAe,CAAC,gBAAgB,CAAC,CAAC;yBAC7C,aAAa,CAAC,QAAQ,CAAC"}

package/src/localchain.js

@@ -1,14 +1,45 @@
+// @ts-check
 import { E } from '@endo/far';
 import { M } from '@endo/patterns';
+import { AmountShape } from '@agoric/ertp';
 
-const { Fail } = assert;
+const { Fail, bare } = assert;
+
+/**
+ * @typedef {{
+ *   '@type': string;
+ *   [x: string]: unknown;
+ * }} Proto3Jsonable
+ */
+
+/**
+ * @typedef {{
+ *   system: import('./types.js').ScopedBridgeManager;
+ *   bankManager: import('./vat-bank.js').BankManager;
+ * }} LocalChainPowers
+ *
+ * @typedef {MapStore<
+ *   keyof LocalChainPowers,
+ *   LocalChainPowers[keyof LocalChainPowers]
+ * >} PowerStore
+ */
+
+/**
+ * @template {keyof LocalChainPowers} K
+ * @param {PowerStore} powers
+ * @param {K} name
+ */
+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()),
+  deposit: M.callWhen(M.remotable('Payment'))
+    .optional(M.pattern())
+    .returns(AmountShape),
   executeTx: M.callWhen(M.arrayOf(M.record())).returns(M.arrayOf(M.record())),
-  // An example of a high-level query.  TODO: Move this functionality to a higher
-  // layer that implements the Orchestration API.
-  allBalances: M.callWhen().returns(M.record()),
 });
 
 /** @param {import('@agoric/base-zone').Zone} zone */
@@ -17,32 +48,34 @@ const prepareLocalChainAccount = zone =>
     'LocalChainAccount',
     LocalChainAccountI,
     /**
-     * @param {import('./types.js').ScopedBridgeManager} system
      * @param {string} address
-     * @param {{ query: (messages: any[]) => Promise<any> }} chain
+     * @param {PowerStore} powers
      */
-    (system, address, chain) => ({ system, address, chain }),
+    (address, powers) => ({ address, powers }),
     {
       // Information that the account creator needs.
       async getAddress() {
         return this.state.address;
       },
-      async allBalances() {
-        // We make a balance request, scoped to our own address.
-        const { address, chain } = this.state;
-        const res = await chain.query([
-          {
-            '@type': '/cosmos.bank.v1beta1.QueryAllBalancesRequest',
-            address,
-          },
-        ]);
-        if (res[0].error) {
-          throw Fail`query failed: ${res[0].error}`;
-        }
-        return res[0].reply;
+      /**
+       * 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
+       */
+      async deposit(payment) {
+        const { address, powers } = this.state;
+
+        const bankManager = getPower(powers, 'bankManager');
+
+        const allegedBrand = await E(payment).getAllegedBrand();
+        const bankAcct = E(bankManager).getBankForAddress(address);
+        const allegedPurse = E(bankAcct).getPurse(allegedBrand);
+        return E(allegedPurse).deposit(payment);
       },
       async executeTx(messages) {
-        const { system, address } = this.state;
+        const { address, powers } = this.state;
         const obj = {
           type: 'VLOCALCHAIN_EXECUTE_TX',
           // This address is the only one that `VLOCALCHAIN_EXECUTE_TX` will
@@ -51,6 +84,7 @@ const prepareLocalChainAccount = zone =>
           address,
           messages,
         };
+        const system = getPower(powers, 'system');
         return E(system).toBridge(obj);
       },
     },
@@ -58,7 +92,12 @@ const prepareLocalChainAccount = zone =>
 
 export const LocalChainI = M.interface('LocalChain', {
   createAccount: M.callWhen().returns(M.remotable('LocalChainAccount')),
-  query: M.callWhen(M.arrayOf(M.record())).returns(M.arrayOf(M.record())),
+  query: M.callWhen(M.record()).returns(M.record()),
+  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(),
 });
 
 /**
@@ -66,29 +105,91 @@ export const LocalChainI = M.interface('LocalChain', {
  * @param {ReturnType<typeof prepareLocalChainAccount>} createAccount
  */
 const prepareLocalChain = (zone, createAccount) =>
-  zone.exoClass(
+  zone.exoClassKit(
     'LocalChain',
-    LocalChainI,
-    /** @param {import('./types.js').ScopedBridgeManager} system */
-    system => ({ system }),
+    { 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 };
+    },
     {
-      async createAccount() {
-        const { system } = this.state;
-        // 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.
-        const address = await E(system).toBridge({
-          type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
-        });
-        return createAccount(system, address, this.self);
+      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);
+          }
+        },
       },
-      async query(messages) {
-        const { system } = this.state;
-        return E(system).toBridge({
-          type: 'VLOCALCHAIN_QUERY',
-          messages,
-        });
+      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 createAccount() {
+          const { powers } = this.state;
+          const system = getPower(powers, 'system');
+          const address = await E(system).toBridge({
+            type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
+          });
+          return createAccount(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 {Proto3Jsonable} request
+         * @returns {Promise<Proto3Jsonable>}
+         */
+        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 {Proto3Jsonable[]} requests
+         * @returns {Promise<{ error?: string; reply: Proto3Jsonable }[]>}
+         */
+        async queryMany(requests) {
+          const { powers } = this.state;
+          const system = getPower(powers, 'system');
+          return E(system).toBridge({
+            type: 'VLOCALCHAIN_QUERY_MANY',
+            messages: requests,
+          });
+        },
       },
     },
   );
@@ -103,4 +204,5 @@ export const prepareLocalChainTools = zone => {
 harden(prepareLocalChainTools);
 
 /** @typedef {ReturnType<typeof prepareLocalChainTools>} LocalChainTools */
-/** @typedef {ReturnType<LocalChainTools['makeLocalChain']>} LocalChain */
+/** @typedef {ReturnType<LocalChainTools['makeLocalChain']>} LocalChainKit */
+/** @typedef {LocalChainKit['public']} LocalChain */

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

@@ -1,4 +1,4 @@
-export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, }, produce: { localchainVat, localchain, localchainBridgeManager }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
+export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, bankManager, }, produce: { localchainVat, localchain, localchainAdmin: localchainAdminP, localchainBridgeManager, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
     vatAdminSvc: import("@agoric/swingset-vat").VatAdminSvc;
 }, {}, {
     loadVat: VatLoader<unknown>;
@@ -400,9 +400,11 @@ export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager:
         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>;
     };
@@ -425,11 +427,14 @@ export function getManifestForLocalChain(_powers: any, { localchainRef }: {
                 loadCriticalVat: boolean;
                 bridgeManager: string;
                 localchainBridgeManager: string;
+                bankManager: string;
+                transferMiddleware: string;
                 client?: undefined;
                 localchain?: undefined;
             };
             produce: {
                 localchain: string;
+                localchainAdmin: string;
                 localchainVat: string;
                 localchainBridgeManager: string;
             };
@@ -440,6 +445,8 @@ export function getManifestForLocalChain(_powers: any, { localchainRef }: {
                 loadCriticalVat?: undefined;
                 bridgeManager?: undefined;
                 localchainBridgeManager?: undefined;
+                bankManager?: undefined;
+                transferMiddleware?: undefined;
             };
             produce?: undefined;
         };

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

@@ -1 +1 @@
-{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AAwBO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAjBiB,UAAU,GAAG,CAAC;uBAChB,OAAO,UAAU,EAAE,aAAa;iCACtB,OAAO,UAAU,EAAE,mBAAmB;;aAExD;QACb,UAAgB,EAAE,SAAS,GAAG,CAAC,CAAC;QAChC,aAAmB,EAAE,SAAS,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,SAAS,GAAG,CAAC,CAAC;KACxC;;;uBAGsB,YAAY;;kBAqDvC;AAUM,2EAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBL;6BA7FW;IACZ,UAAc,EAAE,KAAK,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}
+{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AA0BO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAnBiB,UAAU,GAAG,CAAC;uBAChB,OAAO,UAAU,EAAE,aAAa;iCACtB,OAAO,UAAU,EAAE,mBAAmB;qBAClD,QAAQ,OAAO,gBAAgB,EAAE,WAAW,CAAC;;aAEnD;QACb,UAAgB,EAAE,SAAS,GAAG,CAAC,CAAC;QAChC,eAAqB,EAAE,SAAS,GAAG,CAAC,CAAC;QACrC,aAAmB,EAAE,SAAS,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,SAAS,GAAG,CAAC,CAAC;KACxC;;;uBAGsB,YAAY;;kBAoFvC;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,KAAK,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}

package/src/proposals/localchain-proposal.js

@@ -8,9 +8,11 @@ import { BridgeId as BRIDGE_ID } from '@agoric/internal';
  *     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>;
  *   };
@@ -28,8 +30,14 @@ export const setupLocalChainVat = async (
       loadCriticalVat,
       bridgeManager: bridgeManagerP,
       localchainBridgeManager: localchainBridgeManagerP,
+      bankManager,
+    },
+    produce: {
+      localchainVat,
+      localchain,
+      localchainAdmin: localchainAdminP,
+      localchainBridgeManager,
     },
-    produce: { localchainVat, localchain, localchainBridgeManager },
   },
   options,
 ) => {
@@ -66,9 +74,34 @@ export const setupLocalChainVat = async (
     );
   }
 
-  const newLocalChain = await E(vats.localchain).makeLocalChain(scopedManager);
+  const { admin: localChainAdmin, public: newLocalChain } = await E(
+    vats.localchain,
+  ).makeLocalChain({
+    system: scopedManager,
+  });
+
   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),
+        ),
+    ),
+  );
 };
 
 /**
@@ -93,9 +126,12 @@ export const getManifestForLocalChain = (_powers, { localchainRef }) => ({
         loadCriticalVat: true,
         bridgeManager: 'bridge',
         localchainBridgeManager: 'localchain',
+        bankManager: 'bank',
+        transferMiddleware: 'transfer',
       },
       produce: {
         localchain: 'localchain',
+        localchainAdmin: 'localchain',
         localchainVat: 'localchain',
         localchainBridgeManager: 'localchain',
       },

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

@@ -1 +1 @@
-{"version":3,"file":"localchain-test.d.ts","sourceRoot":"","sources":["localchain-test.js"],"names":[],"mappings":"AAYO,0EARI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH;IAE2C,OAAO,EAA3C;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE;kBAwDpC;AAEM;;;;;;;;;;;;;;EAYL"}
+{"version":3,"file":"localchain-test.d.ts","sourceRoot":"","sources":["localchain-test.js"],"names":[],"mappings":"AAYO,0EARI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH;IAE2C,OAAO,EAA3C;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE;kBA2DpC;AAEM;;;;;;;;;;;;;;EAYL"}

package/src/proposals/localchain-test.js

@@ -31,7 +31,10 @@ export const testLocalChain = async (
     console.info('created account', lca);
     const address = await E(lca).getAddress();
     console.info('address', address);
-    const balances = await E(lca).allBalances();
+    const balances = await E(localchain).query({
+      '@type': '/cosmos.bank.v1beta1.QueryAllBalancesRequest',
+      address,
+    });
     console.info('balances', balances);
     await E(lca)
       .executeTx([
@@ -53,7 +56,7 @@ export const testLocalChain = async (
         },
       );
 
-    const emptyQuery = await E(localchain).query([]);
+    const emptyQuery = await E(localchain).queryMany([]);
     console.info('emptyQuery', emptyQuery);
 
     result = { success: true };

package/src/vat-bank.d.ts

@@ -172,5 +172,464 @@ export type Bank = {
      */
     getPurse: (brand: Brand) => Promise<VirtualPurse>;
 };
+export type BankManager = ReturnType<ReturnType<typeof prepareBankManager>>;
 import { prepareVirtualPurse } from './virtual-purse.js';
+/**
+ * @param {import('@agoric/zone').Zone} zone
+ * @param {object} makers
+ * @param {ReturnType<prepareAssetSubscription>} makers.provideAssetSubscription
+ * @param {ReturnType<prepareBank>} makers.makeBank
+ * @param {ReturnType<prepareDurablePublishKit>} makers.makePublishKit
+ * @param {ReturnType<prepareRewardPurseController>} makers.makeRewardPurseController
+ * @param {ReturnType<prepareVirtualPurse>} makers.makeVirtualPurse
+ */
+declare function prepareBankManager(zone: import('@agoric/zone').Zone, { provideAssetSubscription, makeBank, makePublishKit, makeRewardPurseController, makeVirtualPurse, }: {
+    provideAssetSubscription: ReturnType<(zone: import('@agoric/zone').Zone) => (brandToAssetDescriptor?: any, assetSubscriber?: any) => import("@endo/exo/src/exo-makers.js").Guarded<{
+        subscribeAfter(publishCount?: bigint): any;
+        [Symbol.asyncIterator](): ForkableAsyncIterableIterator<any, any, undefined>;
+    }>>;
+    makeBank: ReturnType<(zone: import('@agoric/zone').Zone, { provideAssetSubscription, makePublishKit, makeVirtualPurse }: {
+        provideAssetSubscription: ReturnType<(zone: import('@agoric/zone').Zone) => (brandToAssetDescriptor?: any, assetSubscriber?: any) => import("@endo/exo/src/exo-makers.js").Guarded<{
+            subscribeAfter(publishCount?: bigint): any;
+            [Symbol.asyncIterator](): ForkableAsyncIterableIterator<any, any, undefined>;
+        }>>;
+        makePublishKit: ReturnType<(baggage: MapStore<string, any>, kindName: string) => (options?: {
+            valueDurability?: "mandatory" | undefined;
+        } | undefined) => import("@endo/exo/src/exo-makers.js").GuardedKit<{
+            publisher: {
+                publish(value: any): void;
+                finish(finalValue: any): void;
+                fail(reason: any): void;
+            };
+            subscriber: {
+                subscribeAfter(publishCount?: bigint): Promise<any>;
+                getUpdateSince(updateCount: any): any;
+            };
+        }>>;
+        makeVirtualPurse: ReturnType<(zone: import("@agoric/zone").Zone) => (vpc: ERef<import("./virtual-purse.js").VirtualPurseController>, { escrowPurse: defaultEscrowPurse, ...issuerKit }: {
+            issuer: ERef<Issuer<AssetKind>>;
+            brand: Brand<AssetKind>;
+            mint?: ERef<Mint<AssetKind>> | undefined;
+            escrowPurse?: ERef<Purse<AssetKind>> | undefined;
+        }) => Promise<{
+            /**
+             * Get the alleged Brand for this
+             * Purse
+             */
+            getAllegedBrand: () => import("@endo/eventual-send").ERef<{
+                /**
+                 *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
+                 */
+                isMyIssuer: (allegedIssuer: ERef<Issuer<AssetKind>>) => import("@endo/eventual-send").ERef<boolean>;
+                getAllegedName: () => import("@endo/eventual-send").ERef<string>;
+                /**
+                 * Give information to UI on how
+                 * to display the amount.
+                 */
+                getDisplayInfo: () => import("@endo/eventual-send").ERef<DisplayInfo<AssetKind>>;
+                getAmountShape: () => any;
+            }>;
+            /**
+             * Get the amount contained in this
+             * purse.
+             */
+            getCurrentAmount: () => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+            /**
+             * Get a lossy
+             * notifier for changes to this purse's balance.
+             */
+            getCurrentAmountNotifier: () => import("@endo/eventual-send").ERef<{
+                /**
+                 * Returns a promise for an update record as of an update count.
+                 * If the `updateCount` argument is omitted or differs from the current update count,
+                 * the promise promptly resolves to the current record.
+                 * Otherwise, after the next state change, the promise resolves to the resulting record.
+                 * This is an attenuated form of `subscribeAfter` whose return value stands alone and
+                 * does not allow consumers to pin a chain of historical PublicationRecords.
+                 * Used to make lossy ("latest") iterators.
+                 * NOTE: Use of `number` as an `updateCount` is deprecated.
+                 */
+                getUpdateSince: (updateCount?: number | bigint | undefined) => import("@endo/eventual-send").ERef<UpdateRecord<Amount<AssetKind>>>;
+            }>;
+            /**
+             * Deposit all the contents of payment into
+             * this purse, 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.
+             */
+            deposit: (args_0: Payment<AssetKind>, args_1?: any) => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+            /**
+             * Return an object whose
+             * `receive` method deposits to the current Purse.
+             */
+            getDepositFacet: () => import("@endo/eventual-send").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: Payment<AssetKind>, args_1?: any) => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+            }>;
+            /**
+             * Withdraw amount from
+             * this purse into a new Payment.
+             */
+            withdraw: (amount: Amount<AssetKind>) => import("@endo/eventual-send").ERef<{
+                /**
+                 * Get the allegedBrand, indicating
+                 * the type of digital asset this payment purports to be, and which issuer to
+                 * use. Because payments are not trusted, any method calls on payments should
+                 * be treated with suspicion and verified elsewhere.
+                 */
+                getAllegedBrand: () => import("@endo/eventual-send").ERef<{
+                    /**
+                     *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
+                     */
+                    isMyIssuer: (allegedIssuer: ERef<Issuer<AssetKind>>) => import("@endo/eventual-send").ERef<boolean>;
+                    getAllegedName: () => import("@endo/eventual-send").ERef<string>;
+                    /**
+                     * Give information to UI on how
+                     * to display the amount.
+                     */
+                    getDisplayInfo: () => import("@endo/eventual-send").ERef<DisplayInfo<AssetKind>>;
+                    getAmountShape: () => any;
+                }>;
+            }>;
+            /**
+             * The set of payments
+             * withdrawn from this purse that are still live. These are the payments that
+             * can still be recovered in emergencies by, for example, depositing into this
+             * purse. Such a deposit action is like canceling an outstanding check because
+             * you're tired of waiting for it. Once your cancellation is acknowledged, you
+             * can spend the assets at stake on other things. Afterwards, if the recipient
+             * of the original check finally gets around to depositing it, their deposit
+             * fails.
+             *
+             * Returns an empty set if this issuer does not support recovery sets.
+             */
+            getRecoverySet: () => import("@endo/eventual-send").ERef<CopySet<Payment<AssetKind>>>;
+            /**
+             * For use in emergencies, such as coming
+             * back from a traumatic crash and upgrade. This deposits all the payments in
+             * this purse's recovery set into the purse itself, returning the total amount
+             * of assets recovered.
+             *
+             * Returns an empty amount if this issuer does not support recovery sets.
+             */
+            recoverAll: () => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+        }>>;
+    }) => (args_0: {
+        address: string;
+        assetSubscriber: EachTopic<AssetDescriptor>;
+        brandToAssetDescriptor: MapStore<Brand, AssetDescriptor>;
+        bankChannel?: BridgeChannel | undefined;
+        brandToAssetRecord: MapStore<Brand, AssetRecord>;
+        brandToVPurse: MapStore<Brand, VirtualPurse>;
+        denomToAddressUpdater: MapStore<string, MapStore<string, BalanceUpdater>>;
+    }) => import("@endo/exo/src/exo-makers.js").Guarded<{
+        getAssetSubscription(): import("@endo/exo/src/exo-makers.js").Guarded<{
+            subscribeAfter(publishCount?: bigint): any;
+            [Symbol.asyncIterator](): ForkableAsyncIterableIterator<any, any, undefined>;
+        }>;
+        /** @param {Brand} brand */
+        getPurse(brand: Brand): Promise<{
+            /**
+             * Get the alleged Brand for this
+             * Purse
+             */
+            getAllegedBrand: () => import("@endo/eventual-send").ERef<{
+                /**
+                 *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
+                 */
+                isMyIssuer: (allegedIssuer: ERef<Issuer<AssetKind>>) => import("@endo/eventual-send").ERef<boolean>;
+                getAllegedName: () => import("@endo/eventual-send").ERef<string>;
+                /**
+                 * Give information to UI on how
+                 * to display the amount.
+                 */
+                getDisplayInfo: () => import("@endo/eventual-send").ERef<DisplayInfo<AssetKind>>;
+                getAmountShape: () => any;
+            }>;
+            /**
+             * Get the amount contained in this
+             * purse.
+             */
+            getCurrentAmount: () => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+            /**
+             * Get a lossy
+             * notifier for changes to this purse's balance.
+             */
+            getCurrentAmountNotifier: () => import("@endo/eventual-send").ERef<{
+                /**
+                 * Returns a promise for an update record as of an update count.
+                 * If the `updateCount` argument is omitted or differs from the current update count,
+                 * the promise promptly resolves to the current record.
+                 * Otherwise, after the next state change, the promise resolves to the resulting record.
+                 * This is an attenuated form of `subscribeAfter` whose return value stands alone and
+                 * does not allow consumers to pin a chain of historical PublicationRecords.
+                 * Used to make lossy ("latest") iterators.
+                 * NOTE: Use of `number` as an `updateCount` is deprecated.
+                 */
+                getUpdateSince: (updateCount?: number | bigint | undefined) => import("@endo/eventual-send").ERef<UpdateRecord<Amount<AssetKind>>>;
+            }>;
+            /**
+             * Deposit all the contents of payment into
+             * this purse, 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.
+             */
+            deposit: (args_0: Payment<AssetKind>, args_1?: any) => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+            /**
+             * Return an object whose
+             * `receive` method deposits to the current Purse.
+             */
+            getDepositFacet: () => import("@endo/eventual-send").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: Payment<AssetKind>, args_1?: any) => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+            }>;
+            /**
+             * Withdraw amount from
+             * this purse into a new Payment.
+             */
+            withdraw: (amount: Amount<AssetKind>) => import("@endo/eventual-send").ERef<{
+                /**
+                 * Get the allegedBrand, indicating
+                 * the type of digital asset this payment purports to be, and which issuer to
+                 * use. Because payments are not trusted, any method calls on payments should
+                 * be treated with suspicion and verified elsewhere.
+                 */
+                getAllegedBrand: () => import("@endo/eventual-send").ERef<{
+                    /**
+                     *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
+                     */
+                    isMyIssuer: (allegedIssuer: ERef<Issuer<AssetKind>>) => import("@endo/eventual-send").ERef<boolean>;
+                    getAllegedName: () => import("@endo/eventual-send").ERef<string>;
+                    /**
+                     * Give information to UI on how
+                     * to display the amount.
+                     */
+                    getDisplayInfo: () => import("@endo/eventual-send").ERef<DisplayInfo<AssetKind>>;
+                    getAmountShape: () => any;
+                }>;
+            }>;
+            /**
+             * The set of payments
+             * withdrawn from this purse that are still live. These are the payments that
+             * can still be recovered in emergencies by, for example, depositing into this
+             * purse. Such a deposit action is like canceling an outstanding check because
+             * you're tired of waiting for it. Once your cancellation is acknowledged, you
+             * can spend the assets at stake on other things. Afterwards, if the recipient
+             * of the original check finally gets around to depositing it, their deposit
+             * fails.
+             *
+             * Returns an empty set if this issuer does not support recovery sets.
+             */
+            getRecoverySet: () => import("@endo/eventual-send").ERef<CopySet<Payment<AssetKind>>>;
+            /**
+             * For use in emergencies, such as coming
+             * back from a traumatic crash and upgrade. This deposits all the payments in
+             * this purse's recovery set into the purse itself, returning the total amount
+             * of assets recovered.
+             *
+             * Returns an empty amount if this issuer does not support recovery sets.
+             */
+            recoverAll: () => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+        }>;
+    }>>;
+    makePublishKit: ReturnType<(baggage: MapStore<string, any>, kindName: string) => (options?: {
+        valueDurability?: "mandatory" | undefined;
+    } | undefined) => import("@endo/exo/src/exo-makers.js").GuardedKit<{
+        publisher: {
+            publish(value: any): void;
+            finish(finalValue: any): void;
+            fail(reason: any): void;
+        };
+        subscriber: {
+            subscribeAfter(publishCount?: bigint): Promise<any>;
+            getUpdateSince(updateCount: any): any;
+        };
+    }>>;
+    makeRewardPurseController: ReturnType<(zone: import('@agoric/zone').Zone) => (bankChannel: BridgeChannel, denom: string, brand: Brand<AssetKind>) => import("@endo/exo/src/exo-makers.js").Guarded<{
+        getBalances(b: any): Notifier<any>;
+        pullAmount(_amount: any): Promise<never>;
+        pushAmount(amount: any): Promise<void>;
+    }>>;
+    makeVirtualPurse: ReturnType<(zone: import("@agoric/zone").Zone) => (vpc: ERef<import("./virtual-purse.js").VirtualPurseController>, { escrowPurse: defaultEscrowPurse, ...issuerKit }: {
+        issuer: ERef<Issuer<AssetKind>>;
+        brand: Brand<AssetKind>;
+        mint?: ERef<Mint<AssetKind>> | undefined;
+        escrowPurse?: ERef<Purse<AssetKind>> | undefined;
+    }) => Promise<{
+        /**
+         * Get the alleged Brand for this
+         * Purse
+         */
+        getAllegedBrand: () => import("@endo/eventual-send").ERef<{
+            /**
+             *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
+             */
+            isMyIssuer: (allegedIssuer: ERef<Issuer<AssetKind>>) => import("@endo/eventual-send").ERef<boolean>;
+            getAllegedName: () => import("@endo/eventual-send").ERef<string>;
+            /**
+             * Give information to UI on how
+             * to display the amount.
+             */
+            getDisplayInfo: () => import("@endo/eventual-send").ERef<DisplayInfo<AssetKind>>;
+            getAmountShape: () => any;
+        }>;
+        /**
+         * Get the amount contained in this
+         * purse.
+         */
+        getCurrentAmount: () => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+        /**
+         * Get a lossy
+         * notifier for changes to this purse's balance.
+         */
+        getCurrentAmountNotifier: () => import("@endo/eventual-send").ERef<{
+            /**
+             * Returns a promise for an update record as of an update count.
+             * If the `updateCount` argument is omitted or differs from the current update count,
+             * the promise promptly resolves to the current record.
+             * Otherwise, after the next state change, the promise resolves to the resulting record.
+             * This is an attenuated form of `subscribeAfter` whose return value stands alone and
+             * does not allow consumers to pin a chain of historical PublicationRecords.
+             * Used to make lossy ("latest") iterators.
+             * NOTE: Use of `number` as an `updateCount` is deprecated.
+             */
+            getUpdateSince: (updateCount?: number | bigint | undefined) => import("@endo/eventual-send").ERef<UpdateRecord<Amount<AssetKind>>>;
+        }>;
+        /**
+         * Deposit all the contents of payment into
+         * this purse, 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.
+         */
+        deposit: (args_0: Payment<AssetKind>, args_1?: any) => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+        /**
+         * Return an object whose
+         * `receive` method deposits to the current Purse.
+         */
+        getDepositFacet: () => import("@endo/eventual-send").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: Payment<AssetKind>, args_1?: any) => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+        }>;
+        /**
+         * Withdraw amount from
+         * this purse into a new Payment.
+         */
+        withdraw: (amount: Amount<AssetKind>) => import("@endo/eventual-send").ERef<{
+            /**
+             * Get the allegedBrand, indicating
+             * the type of digital asset this payment purports to be, and which issuer to
+             * use. Because payments are not trusted, any method calls on payments should
+             * be treated with suspicion and verified elsewhere.
+             */
+            getAllegedBrand: () => import("@endo/eventual-send").ERef<{
+                /**
+                 *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
+                 */
+                isMyIssuer: (allegedIssuer: ERef<Issuer<AssetKind>>) => import("@endo/eventual-send").ERef<boolean>;
+                getAllegedName: () => import("@endo/eventual-send").ERef<string>;
+                /**
+                 * Give information to UI on how
+                 * to display the amount.
+                 */
+                getDisplayInfo: () => import("@endo/eventual-send").ERef<DisplayInfo<AssetKind>>;
+                getAmountShape: () => any;
+            }>;
+        }>;
+        /**
+         * The set of payments
+         * withdrawn from this purse that are still live. These are the payments that
+         * can still be recovered in emergencies by, for example, depositing into this
+         * purse. Such a deposit action is like canceling an outstanding check because
+         * you're tired of waiting for it. Once your cancellation is acknowledged, you
+         * can spend the assets at stake on other things. Afterwards, if the recipient
+         * of the original check finally gets around to depositing it, their deposit
+         * fails.
+         *
+         * Returns an empty set if this issuer does not support recovery sets.
+         */
+        getRecoverySet: () => import("@endo/eventual-send").ERef<CopySet<Payment<AssetKind>>>;
+        /**
+         * For use in emergencies, such as coming
+         * back from a traumatic crash and upgrade. This deposits all the payments in
+         * this purse's recovery set into the purse itself, returning the total amount
+         * of assets recovered.
+         *
+         * Returns an empty amount if this issuer does not support recovery sets.
+         */
+        recoverAll: () => import("@endo/eventual-send").ERef<Amount<AssetKind>>;
+    }>>;
+}): (args_0: {
+    bankChannel?: BridgeChannel | undefined;
+    denomToAddressUpdater: MapStore<string, MapStore<string, BalanceUpdater>>;
+    nameAdmin?: Pick<import("./types.js").NameAdmin, "update"> | undefined;
+}) => import("@endo/exo/src/exo-makers.js").Guarded<{
+    /**
+     * Returns assets as they are added to the bank.
+     *
+     * @returns {IterableEachTopic<AssetDescriptor>}
+     */
+    getAssetSubscription(): IterableEachTopic<AssetDescriptor>;
+    /**
+     * @param {string} denom
+     * @param {AssetIssuerKit} feeKit
+     * @returns {ERef<import('@endo/far').EOnly<DepositFacet>>}
+     */
+    getRewardDistributorDepositFacet(denom: string, feeKit: AssetIssuerKit): ERef<import('@endo/far').EOnly<DepositFacet>>;
+    /**
+     * Get the address of named module account.
+     *
+     * @param {string} moduleName
+     * @returns {Promise<string | null>} address of named module account, or
+     *   null if unimplemented (no bankChannel)
+     */
+    getModuleAccountAddress(moduleName: string): Promise<string | null>;
+    /**
+     * Add an asset to the bank, and publish it to the subscriptions. If
+     * nameAdmin is defined, update with denom to AssetInfo entry.
+     *
+     * Note that AssetInfo has the settled identity of the issuer, not just a
+     * promise for it.
+     *
+     * @param {string} denom lower-level denomination string
+     * @param {string} issuerName
+     * @param {string} proposedName
+     * @param {AssetIssuerKit & { payment?: ERef<Payment> }} kit ERTP issuer
+     *   kit (mint, brand, issuer)
+     */
+    addAsset(denom: string, issuerName: string, proposedName: string, kit: AssetIssuerKit<AssetKind> & {
+        payment?: ERef<Payment<AssetKind>> | undefined;
+    }): Promise<void>;
+    /**
+     * Create a new personal bank interface for a given address.
+     *
+     * @param {string} address lower-level bank account address
+     * @returns {Promise<Bank>}
+     */
+    getBankForAddress(address: string): Promise<Bank>;
+}>;
+export {};
 //# sourceMappingURL=vat-bank.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vat-bank.d.ts","sourceRoot":"","sources":["vat-bank.js"],"names":[],"mappings":"AAy0BA;IASI;;;;;;OAMG;yCALQ,KAAK,OAAO,YAAY,EAAE,mBAAmB,GAAG,SAAS,CAAC;gBAG3C,OAAO,YAAY,EAAE,SAAS,CAAC,QAAQ,CAAC;;QAhPhE;;;;WAIG;gCADU,kBAAkB,eAAe,CAAC;QAS/C;;;;WAIG;gDAHQ,MAAM,UACN,cAAc,GACZ,KAAK,OAAO,WAAW,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;QAkB1D;;;;;;WAMG;4CAHQ,MAAM,GACJ,QAAQ,MAAM,GAAG,IAAI,CAAC;QAenC;;;;;;;;;;;;WAYG;wBALQ,MAAM,cACN,MAAM,gBACN,MAAM;;;QA4EjB;;;;;WAKG;mCAFQ,MAAM,GACJ,QAAQ,IAAI,CAAC;;;IA+F5B;;;;;;OAMG;yCALQ,KAAK,OAAO,YAAY,EAAE,mBAAmB,GAAG,SAAS,CAAC;gBAG3C,OAAO,YAAY,EAAE,SAAS,CAAC,QAAQ,CAAC;;QAhPhE;;;;WAIG;gCADU,kBAAkB,eAAe,CAAC;QAS/C;;;;WAIG;gDAHQ,MAAM,UACN,cAAc,GACZ,KAAK,OAAO,WAAW,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;QAkB1D;;;;;;WAMG;4CAHQ,MAAM,GACJ,QAAQ,MAAM,GAAG,IAAI,CAAC;QAenC;;;;;;;;;;;;WAYG;wBALQ,MAAM,cACN,MAAM,gBACN,MAAM;;;QA4EjB;;;;;WAKG;mCAFQ,MAAM,GACJ,QAAQ,IAAI,CAAC;;GA6I/B;AAnhBD,2FAA2F;AAE3F;;;;;;;GAOG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AAEH;;;GAGG;qCAvWU,OAAO,oBAAoB,EAAE,sBAAsB;2BAEnD,QAAQ,WAAW,WAAW,0BAA0B,CAAC,CAAC,CAAC;;oBAKlD,MAAM,UAAU,MAAM,KAAK,IAAI;;4BAQxC,KACZ,OAAW,YAAY,EAAE,mBAAmB,EAC5C,YAAgB,GAAG,UAAU,CAC1B;;;YA2SU,KAAK,OAAO,CAAC,CAAC,CAAC;WACf,MAAM,CAAC,CAAC;;0BAYR,cAAc,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,KAAK,KAAK,CAAC,CAAA;CAAE;;WAI7D,KAAK;YACL,KAAK,MAAM,CAAC;gBACZ,MAAM;WACN,MAAM;kBACN,MAAM;;wBAIP,eAAe,GAAG;IAC9B,MAAU,EAAE,OAAO,KAAK,CAAC,CAAC;IAC1B,WAAe,EAAE,WAAW,CAAC;CAC1B;;;;;0BAKU,MAAM,kBAAkB,eAAe,CAAC;;;;;sBAEhC,KAAK,KAAK,QAAQ,YAAY,CAAC;;oCAhX9C,oBAAoB"}
+{"version":3,"file":"vat-bank.d.ts","sourceRoot":"","sources":["vat-bank.js"],"names":[],"mappings":"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"}

package/src/vat-bank.js

@@ -787,6 +787,7 @@ const prepareBankManager = (
   );
   return makeBankManager;
 };
+/** @typedef {ReturnType<ReturnType<typeof prepareBankManager>>} BankManager */
 
 /** @param {MapStore<string, any>} baggage */
 const prepareFromBaggage = baggage => {

package/src/vat-localchain.d.ts

@@ -3,30 +3,48 @@ 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 {import('./types').ScopedBridgeManager} system
+     * @param {Partial<import('./localchain.js').LocalChainPowers>} [initialPowers]
      */
-    makeLocalChain(system: import('./types').ScopedBridgeManager): import("@endo/exo/src/exo-makers.js").Guarded<{
-        createAccount(): Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
-            getAddress(): Promise<string>;
-            allBalances(): Promise<any>;
-            executeTx(messages: any): Promise<any>;
-        }>>;
-        query(messages: any): Promise<any>;
+    makeLocalChain(initialPowers?: Partial<import("./localchain.js").LocalChainPowers> | undefined): import("@endo/exo/src/exo-makers.js").GuardedKit<{
+        admin: {
+            setPower<K extends keyof import("./localchain.js").LocalChainPowers>(name: K, power?: import("./localchain.js").LocalChainPowers[K] | undefined): void;
+        };
+        public: {
+            createAccount(): Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
+                getAddress(): Promise<string>;
+                deposit(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
+                executeTx(messages: any): Promise<any>;
+            }>>;
+            query(request: import("./localchain.js").Proto3Jsonable): Promise<import("./localchain.js").Proto3Jsonable>;
+            queryMany(requests: import("./localchain.js").Proto3Jsonable[]): Promise<{
+                error?: string | undefined;
+                reply: import("./localchain.js").Proto3Jsonable;
+            }[]>;
+        };
     }>;
 } & 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 {import('./types').ScopedBridgeManager} system
+     * @param {Partial<import('./localchain.js').LocalChainPowers>} [initialPowers]
      */
-    makeLocalChain(system: import('./types').ScopedBridgeManager): import("@endo/exo/src/exo-makers.js").Guarded<{
-        createAccount(): Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
-            getAddress(): Promise<string>;
-            allBalances(): Promise<any>;
-            executeTx(messages: any): Promise<any>;
-        }>>;
-        query(messages: any): Promise<any>;
+    makeLocalChain(initialPowers?: Partial<import("./localchain.js").LocalChainPowers> | undefined): import("@endo/exo/src/exo-makers.js").GuardedKit<{
+        admin: {
+            setPower<K extends keyof import("./localchain.js").LocalChainPowers>(name: K, power?: import("./localchain.js").LocalChainPowers[K] | undefined): void;
+        };
+        public: {
+            createAccount(): Promise<import("@endo/exo/src/exo-makers.js").Guarded<{
+                getAddress(): Promise<string>;
+                deposit(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
+                executeTx(messages: any): Promise<any>;
+            }>>;
+            query(request: import("./localchain.js").Proto3Jsonable): Promise<import("./localchain.js").Proto3Jsonable>;
+            queryMany(requests: import("./localchain.js").Proto3Jsonable[]): Promise<{
+                error?: string | undefined;
+                reply: import("./localchain.js").Proto3Jsonable;
+            }[]>;
+        };
     }>;
 }>;
 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;2BADQ,OAAO,SAAS,EAAE,mBAAmB;;;;;;;;;IAJhD;;;;;OAKG;2BADQ,OAAO,SAAS,EAAE,mBAAmB;;;;;;;;GAMnD;4BAEa,WAAW,sBAAsB,CAAC"}
+{"version":3,"file":"vat-localchain.d.ts","sourceRoot":"","sources":["vat-localchain.js"],"names":[],"mappings":"AAMO;IAKH;;;;;OAKG;;;;;;;;;;;;;;;;;;;IALH;;;;;OAKG;;;;;;;;;;;;;;;;;;GAKN;4BAEa,WAAW,sBAAsB,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 {import('./types').ScopedBridgeManager} system
+     * @param {Partial<import('./localchain.js').LocalChainPowers>} [initialPowers]
      */
-    makeLocalChain(system) {
-      return makeLocalChain(system);
+    makeLocalChain(initialPowers = {}) {
+      return makeLocalChain(initialPowers);
     },
   });
 };