@agoric/vats 0.15.2-dev-249a5d4.0 → 0.15.2-dev-5856dc0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vats",
-  "version": "0.15.2-dev-249a5d4.0+249a5d4",
+  "version": "0.15.2-dev-5856dc0.0+5856dc0",
   "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-249a5d4.0+249a5d4",
-    "@agoric/cosmic-proto": "0.4.1-dev-249a5d4.0+249a5d4",
-    "@agoric/ertp": "0.16.3-dev-249a5d4.0+249a5d4",
-    "@agoric/governance": "0.10.4-dev-249a5d4.0+249a5d4",
-    "@agoric/internal": "0.3.3-dev-249a5d4.0+249a5d4",
-    "@agoric/network": "0.1.1-dev-249a5d4.0+249a5d4",
-    "@agoric/notifier": "0.6.3-dev-249a5d4.0+249a5d4",
-    "@agoric/store": "0.9.3-dev-249a5d4.0+249a5d4",
-    "@agoric/swingset-vat": "0.32.3-dev-249a5d4.0+249a5d4",
-    "@agoric/time": "0.3.3-dev-249a5d4.0+249a5d4",
-    "@agoric/vat-data": "0.5.3-dev-249a5d4.0+249a5d4",
-    "@agoric/vow": "0.1.1-dev-249a5d4.0+249a5d4",
-    "@agoric/zoe": "0.26.3-dev-249a5d4.0+249a5d4",
-    "@agoric/zone": "0.2.3-dev-249a5d4.0+249a5d4",
+    "@agoric/assert": "0.6.1-dev-5856dc0.0+5856dc0",
+    "@agoric/cosmic-proto": "0.4.1-dev-5856dc0.0+5856dc0",
+    "@agoric/ertp": "0.16.3-dev-5856dc0.0+5856dc0",
+    "@agoric/governance": "0.10.4-dev-5856dc0.0+5856dc0",
+    "@agoric/internal": "0.3.3-dev-5856dc0.0+5856dc0",
+    "@agoric/network": "0.1.1-dev-5856dc0.0+5856dc0",
+    "@agoric/notifier": "0.6.3-dev-5856dc0.0+5856dc0",
+    "@agoric/store": "0.9.3-dev-5856dc0.0+5856dc0",
+    "@agoric/swingset-vat": "0.32.3-dev-5856dc0.0+5856dc0",
+    "@agoric/time": "0.3.3-dev-5856dc0.0+5856dc0",
+    "@agoric/vat-data": "0.5.3-dev-5856dc0.0+5856dc0",
+    "@agoric/vow": "0.1.1-dev-5856dc0.0+5856dc0",
+    "@agoric/zoe": "0.26.3-dev-5856dc0.0+5856dc0",
+    "@agoric/zone": "0.2.3-dev-5856dc0.0+5856dc0",
     "@endo/far": "^1.1.2",
     "@endo/import-bundle": "^1.1.2",
     "@endo/marshal": "^1.5.0",
@@ -46,7 +46,7 @@
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-249a5d4.0+249a5d4",
+    "@agoric/swingset-liveslots": "0.10.3-dev-5856dc0.0+5856dc0",
     "@endo/bundle-source": "^3.2.3",
     "@endo/init": "^1.1.2",
     "ava": "^5.3.0",
@@ -78,5 +78,5 @@
   "typeCoverage": {
     "atLeast": 91.21
   },
-  "gitHead": "249a5d429ebf18be65e8e04ada7acda06e7be02d"
+  "gitHead": "5856dc0a002031bdcc1d22a68a6fcf6fa9be38e0"
 }

package/src/ibc.d.ts

@@ -1,6 +1,6 @@
 export function prepareIBCConnectionHandler(zone: Zone): any;
 export function prepareIBCProtocol(zone: Zone, powers: {
-    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
     watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
     makeVowKit: <T_2>() => VowKit<T_2>;
     allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;

package/src/ibc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AAmDO,yDAFM,GAAG,CAmHf;AAMM;uFAvJJ,CAAC;;;oBASO,SAAS;;cAqJJ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;;;;EAunB7D;AAIM;IAOD;;;OAGG;qBAFQ,MAAM,OACN,GAAG;GAYnB;;;;;;;gBAxxBgB,UAAU;kBACR;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;;0BAbf,mBAAmB;4BAC0B,aAAa;qCAH+B,iBAAiB;mCACyE,YAAY;yCAAZ,YAAY;wCAZjL,iBAAiB;iCAcc,aAAa;oCAFyH,YAAY"}
+{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AAmDO,yDAFM,GAAG,CAmHf;AAMM;wFAvJF,CAAC;;;oBASK,SAAS;;cAqJJ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;;;;EAunB7D;AAIM;IAOD;;;OAGG;qBAFQ,MAAM,OACN,GAAG;GAYnB;;;;;;;gBAxxBgB,UAAU;kBACR;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;;0BAbf,mBAAmB;4BAC0B,aAAa;qCAH+B,iBAAiB;mCACyE,YAAY;yCAAZ,YAAY;wCAZjL,iBAAiB;iCAcc,aAAa;oCAFyH,YAAY"}

package/src/localchain.d.ts

@@ -1,8 +1,23 @@
 /**
  * @import {TypedJson, ResponseTo, JsonSafe} from '@agoric/cosmic-proto';
+ * @import {PromiseVow, VowTools} from '@agoric/vow';
+ * @import {TargetApp, TargetRegistration} from './bridge-target.js';
  * @import {BankManager, Bank} from './vat-bank.js';
  * @import {ScopedBridgeManager} from './types.js';
  */
+/**
+ * @template {unknown[]} T
+ * @typedef {Promise<T>} PromiseVowOfTupleMappedToGenerics Temporary hack
+ *
+ *   UNTIL(microsoft/TypeScript#57122): This type should be replaced with just
+ *   PromiseVow<T>, but TypeScript doesn't understand that the result of a
+ *   mapping a tuple type using generics is iterable:
+ *
+ *   'JsonSafe<MsgTransferResponse & { '@type':
+ *   "/ibc.applications.transfer.v1.MsgTransferResponse"; }>[] |
+ *   Vow<JsonSafe<MsgTransferResponse & { ...; }>[]>' must have a
+ *   '[Symbol.iterator]()' method that returns an iterator.
+ */
 /**
  * @typedef {{
  *   system: ScopedBridgeManager<'vlocalchain'>;
@@ -25,88 +40,197 @@ export const LocalChainAccountI: import("@endo/patterns").InterfaceGuard<{
     executeTx: import("@endo/patterns").MethodGuard;
     monitorTransfers: import("@endo/patterns").MethodGuard;
 }>;
+export function prepareLocalChainAccountKit(zone: import("@agoric/base-zone").Zone, { watch }: {
+    when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
+    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+}): (address: string, powers: AccountPowers) => import("@endo/exo").GuardedKit<{
+    depositPaymentWatcher: {
+        /**
+         * @param {Brand<'nat'>} brand
+         * @param {{
+         *   payment: Payment<'nat'>;
+         *   optAmountShape: Amount<'nat'>;
+         * }} ctx
+         */
+        onFulfilled(brand: Brand<"nat">, { payment, optAmountShape }: {
+            payment: Payment<"nat">;
+            optAmountShape: Amount<"nat">;
+        }): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
+    };
+    account: {
+        getAddress(): string;
+        /**
+         * @param {Brand<'nat'>} brand
+         * @returns {PromiseVow<Amount<'nat'>>}
+         */
+        getBalance(brand: Brand<"nat">): PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+        /**
+         * 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<'nat'>} payment
+         * @param {Pattern} [optAmountShape] throws if the Amount of the Payment
+         *   does not match the provided Pattern
+         * @returns {PromiseVow<Amount<'nat'>>}
+         */
+        deposit(payment: Payment<"nat">, optAmountShape?: Pattern): PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+        /**
+         * Withdraw a payment from the account's bank purse of the amount's
+         * brand.
+         *
+         * @param {Amount<'nat'>} amount
+         * @returns {PromiseVow<Payment<'nat'>>} payment
+         */
+        withdraw(amount: Amount<"nat">): PromiseVow<globalThis.Payment<"nat">>;
+        /**
+         * Execute a batch of messages in order as a single atomic transaction
+         * and return the responses. If any of the messages fails, the entire
+         * batch will be rolled back. 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 {PromiseVowOfTupleMappedToGenerics<{
+         *   [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>;
+         * }>}
+         */
+        executeTx<MT extends {
+            '@type': string;
+        }[]>(messages: MT): PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>; }>;
+        /**
+         * @param {TargetApp} tap
+         * @returns {PromiseVow<TargetRegistration>}
+         */
+        monitorTransfers(tap: TargetApp): PromiseVow<TargetRegistration>;
+    };
+}>;
 /**
  * @typedef {Awaited<
- *   ReturnType<Awaited<ReturnType<typeof prepareLocalChainAccount>>>
- * >} LocalChainAccount
+ *   ReturnType<ReturnType<typeof prepareLocalChainAccountKit>>
+ * >} LocalChainAccountKit
  */
+/** @typedef {LocalChainAccountKit['account']} LocalChainAccount */
 export const LocalChainI: import("@endo/patterns").InterfaceGuard<{
     makeAccount: import("@endo/patterns").MethodGuard;
     query: import("@endo/patterns").MethodGuard;
     queryMany: import("@endo/patterns").MethodGuard;
 }>;
-export function prepareLocalChainTools(zone: import("@agoric/base-zone").Zone): {
+export function prepareLocalChainTools(zone: import("@agoric/base-zone").Zone, vowTools: {
+    when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
+    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+}): {
     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
+         * 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.
+         *
+         * @returns {PromiseVow<LocalChainAccount>}
          */
-        makeAccount(): Promise<import("@endo/exo").Guarded<{
+        makeAccount(): PromiseVow<import("@endo/exo").Guarded<{
             getAddress(): string;
-            /** @param {Brand<'nat'>} brand */
-            getBalance(brand: Brand<"nat">): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
+            /**
+             * @param {Brand<'nat'>} brand
+             * @returns {PromiseVow<Amount<'nat'>>}
+             */
+            getBalance(brand: Brand<"nat">): PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
             /**
              * 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.
+             * 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<'nat'>} payment
              * @param {Pattern} [optAmountShape] throws if the Amount of the Payment
              *   does not match the provided Pattern
-             * @returns {Promise<Amount>}
+             * @returns {PromiseVow<Amount<'nat'>>}
              */
-            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<Amount>;
+            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
             /**
-             * Withdraw a payment from the account's bank purse of the amount's brand.
+             * Withdraw a payment from the account's bank purse of the amount's
+             * brand.
              *
              * @param {Amount<'nat'>} amount
-             * @returns {Promise<Payment<'nat'>>} payment
+             * @returns {PromiseVow<Payment<'nat'>>} payment
              */
-            withdraw(amount: Amount<"nat">): Promise<Payment<"nat">>;
+            withdraw(amount: Amount<"nat">): PromiseVow<globalThis.Payment<"nat">>;
             /**
-             * Execute a batch of transactions and return the responses. Use
-             * `typedJson()` on the arguments to get typed return values.
+             * Execute a batch of messages in order as a single atomic transaction
+             * and return the responses. If any of the messages fails, the entire
+             * batch will be rolled back. 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]: JsonSafe<ResponseTo<MT[K]>> }>}
+             * @returns {PromiseVowOfTupleMappedToGenerics<{
+             *   [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>;
+             * }>}
              */
             executeTx<MT extends {
                 '@type': string;
-            }[]>(messages: MT): Promise<{ [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>; }>;
-            monitorTransfers(tap: any): Promise<any>;
+            }[]>(messages: MT): PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>; }>;
+            /**
+             * @param {TargetApp} tap
+             * @returns {PromiseVow<TargetRegistration>}
+             */
+            monitorTransfers(tap: TargetApp): PromiseVow<TargetRegistration>;
         }>>;
         /**
          * 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>}
+         * @template {TypedJson} [T=TypedJson]
+         * @param {T} request
+         * @returns {PromiseVow<JsonSafe<ResponseTo<T>>>}
          */
-        query(request: import("@agoric/cosmic-proto").TypedJson): Promise<import("@agoric/cosmic-proto").TypedJson>;
+        query<T extends {
+            '@type': string;
+        } = {
+            '@type': string;
+        }>(request: T): PromiseVow<JsonSafe<ResponseTo<T>>>;
         /**
          * 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<
-         *   {
+         * @template {import('@agoric/cosmic-proto').TypedJson[]} RT
+         * @param {RT} requests
+         * @returns {PromiseVowOfTupleMappedToGenerics<{
+         *   [K in keyof RT]: JsonSafe<{
          *     error?: string;
-         *     reply: import('@agoric/cosmic-proto').TypedJson;
-         *   }[]
-         * >}
+         *     reply: ResponseTo<RT[K]>;
+         *   }>;
+         * }>}
          */
-        queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
+        queryMany<RT extends {
+            '@type': string;
+        }[]>(requests: RT): PromiseVowOfTupleMappedToGenerics<{ [K_1 in keyof RT]: JsonSafe<{
             error?: string;
-            reply: import("@agoric/cosmic-proto").TypedJson;
-        }[]>;
+            reply: ResponseTo<RT[K_1]>;
+        }>; }>;
     }>;
 };
+/**
+ * Temporary hack
+ *
+ *   UNTIL(microsoft/TypeScript#57122): This type should be replaced with just
+ *   PromiseVow<T>, but TypeScript doesn't understand that the result of a
+ *   mapping a tuple type using generics is iterable:
+ *
+ *   'JsonSafe<MsgTransferResponse & { '@type':
+ *   "/ibc.applications.transfer.v1.MsgTransferResponse"; }>[] |
+ *   Vow<JsonSafe<MsgTransferResponse & { ...; }>[]>' must have a
+ *   '[Symbol.iterator]()' method that returns an iterator.
+ */
+export type PromiseVowOfTupleMappedToGenerics<T extends unknown[]> = Promise<T>;
 export type AccountPowers = {
     system: ScopedBridgeManager<"vlocalchain">;
     bank: Bank;
@@ -135,49 +259,15 @@ export type LocalChainPowers = {
     }>;
     transfer: import("./transfer.js").TransferMiddleware;
 };
-export type LocalChainAccount = Awaited<ReturnType<Awaited<ReturnType<typeof prepareLocalChainAccount>>>>;
+export type LocalChainAccountKit = Awaited<ReturnType<ReturnType<typeof prepareLocalChainAccountKit>>>;
+export type LocalChainAccount = LocalChainAccountKit["account"];
 export type LocalChainTools = ReturnType<typeof prepareLocalChainTools>;
 export type LocalChain = ReturnType<LocalChainTools["makeLocalChain"]>;
+import type { PromiseVow } from '@agoric/vow';
 import type { ResponseTo } from '@agoric/cosmic-proto';
 import type { JsonSafe } from '@agoric/cosmic-proto';
+import type { TargetApp } from './bridge-target.js';
+import type { TargetRegistration } from './bridge-target.js';
 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: AccountPowers) => import("@endo/exo").Guarded<{
-    getAddress(): string;
-    /** @param {Brand<'nat'>} brand */
-    getBalance(brand: Brand<"nat">): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
-    /**
-     * 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<'nat'>} payment
-     * @param {Pattern} [optAmountShape] throws if the Amount of the Payment
-     *   does not match the provided Pattern
-     * @returns {Promise<Amount>}
-     */
-    deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<Amount>;
-    /**
-     * Withdraw a payment from the account's bank purse of the amount's brand.
-     *
-     * @param {Amount<'nat'>} amount
-     * @returns {Promise<Payment<'nat'>>} payment
-     */
-    withdraw(amount: Amount<"nat">): Promise<Payment<"nat">>;
-    /**
-     * 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]: JsonSafe<ResponseTo<MT[K]>> }>}
-     */
-    executeTx<MT extends {
-        '@type': string;
-    }[]>(messages: MT): Promise<{ [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>; }>;
-    monitorTransfers(tap: any): Promise<any>;
-}>;
-export {};
 //# 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":"AAOA;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;;;;;;GASG;AAgFH;;;;GAIG;AAEH;;;;GAIG;AAwEI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;QAxDtC;;;;;WAKG;;;YA7FH,kCAAkC;8BAAtB,KAAK,CAAC,KAAK,CAAC;YAMxB;;;;;;;;;eASG;6BAJQ,OAAO,CAAC,KAAK,CAAC,mBACd,OAAO,GAEL,OAAO,CAAC,MAAM,CAAC;YAS5B;;;;;eAKG;6BAFQ,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAOpC;;;;;;;;eAQG;sBADyD,EAAE;;2BAAF,EAAE,AADjD;;;QA8Db;;;;;;;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;;;;cA5Lc,OAAO,eAAe,EAAE,kBAAkB;;;;;;gEAiM++X,cAAc;;;;;;;;;;;;+EAAiiD,cAAc,GAAE;YAAE,OAAQ,CAAC,EAAC,KAAM,QAAQ,KAAK,CAAC,CAAC,CAAA;SAAE;;;cAzL3nb,OAAO,eAAe,EAAE,kBAAkB;;gCA8F5C,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;gCAzMT,sBAAsB;8BAAtB,sBAAsB;yCAElC,YAAY;0BADd,eAAe;AA+BnD,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC,kCAAkC;sBAAtB,KAAK,CAAC,KAAK,CAAC;IAMxB;;;;;;;;;OASG;qBAJQ,OAAO,CAAC,KAAK,CAAC,mBACd,OAAO,GAEL,OAAO,CAAC,MAAM,CAAC;IAS5B;;;;;OAKG;qBAFQ,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAOpC;;;;;;;;OAQG;cADyD,EAAE;;mBAAF,EAAE,AADjD;;GAsBhB"}
+{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAWG;AAMI,kDAHI,OAAO,mBAAmB,EAAE,IAAI;wFAhDf,CAAC;;;oBAYH,SAAS;;;QAgE3B;;;;;;WAMG;2BALQ,KAAK,CAAC,KAAK,CAAC,+BACZ;YACV,OAAW,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;YAC5B,cAAkB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;SAC/B;;;;QAYJ;;;WAGG;0BAFQ,KAAK,CAAC,KAAK,CAAC;QAQvB;;;;;;;;;WASG;yBAJQ,OAAO,CAAC,KAAK,CAAC,mBACd,OAAO;QAclB;;;;;;WAMG;yBAFQ,MAAM,CAAC,KAAK,CAAC;QAQxB;;;;;;;;;;;;WAYG;kBAFuC,EAAE;;uBAAF,EAAE,AAF/B;QAmBb;;;WAGG;;;GAOR;AAEH;;;;GAIG;AAEH,mEAAmE;AAEnE;;;;GAIG;AAiHI,6CAHI,OAAO,mBAAmB,EAAE,IAAI;;;;;;6BAP9B,gBAAgB;QA9ErB;;;;;;;WAOG;;;YA5HH;;;eAGG;8BAFQ,KAAK,CAAC,KAAK,CAAC;YAQvB;;;;;;;;;eASG;6BAJQ,OAAO,CAAC,KAAK,CAAC,mBACd,OAAO;YAclB;;;;;;eAMG;6BAFQ,MAAM,CAAC,KAAK,CAAC;YAQxB;;;;;;;;;;;;eAYG;sBAFuC,EAAE;;2BAAF,EAAE,AAF/B;YAmBb;;;eAGG;;;QA8DH;;;;;;;;WAQG;cADyC,CAAC;;;;oBAAD,CAAC,AADjC;QAUZ;;;;;;;;;;;;;WAaG;kBAHsB,EAAE;;uBAAF,EAAE,AAJd,wCAIe,GAAC;oBADd,MAAM;;;;EAoD5B;;;;;;;;;;;;;8CAzSoB,CAAC,sBAAT,OAAO,CAAC,CAAC,CAAC;;;;cAgBR,OAAO,eAAe,EAAE,kBAAkB;;;;;;gEA8RgrR,cAAc;;;;;;;;;;;;+EAAiiD,cAAc,GAAE;YAAE,OAAQ,CAAC,EAAC,KAAM,QAAQ,KAAK,CAAC,CAAC,CAAA;SAAE;;;cAtR5zU,OAAO,eAAe,EAAE,kBAAkB;;mCAgJ5C,OAAO,CACnB,UAAc,CAAC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC,CAC3D;gCAGU,oBAAoB,CAAC,SAAS,CAAC;8BA+H/B,UAAU,CAAC,OAAO,sBAAsB,CAAC;yBACzC,UAAU,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;gCArTpB,aAAa;gCADF,sBAAsB;8BAAtB,sBAAsB;+BAExB,oBAAoB;wCAApB,oBAAoB;yCAE9B,YAAY;0BADd,eAAe"}

package/src/localchain.js

@@ -2,15 +2,32 @@
 import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 import { AmountShape, BrandShape, PaymentShape } from '@agoric/ertp';
+import { Shape as NetworkShape } from '@agoric/network';
 
 const { Fail } = assert;
 
 /**
  * @import {TypedJson, ResponseTo, JsonSafe} from '@agoric/cosmic-proto';
+ * @import {PromiseVow, VowTools} from '@agoric/vow';
+ * @import {TargetApp, TargetRegistration} from './bridge-target.js';
  * @import {BankManager, Bank} from './vat-bank.js';
  * @import {ScopedBridgeManager} from './types.js';
  */
 
+/**
+ * @template {unknown[]} T
+ * @typedef {Promise<T>} PromiseVowOfTupleMappedToGenerics Temporary hack
+ *
+ *   UNTIL(microsoft/TypeScript#57122): This type should be replaced with just
+ *   PromiseVow<T>, but TypeScript doesn't understand that the result of a
+ *   mapping a tuple type using generics is iterable:
+ *
+ *   'JsonSafe<MsgTransferResponse & { '@type':
+ *   "/ibc.applications.transfer.v1.MsgTransferResponse"; }>[] |
+ *   Vow<JsonSafe<MsgTransferResponse & { ...; }>[]>' must have a
+ *   '[Symbol.iterator]()' method that returns an iterator.
+ */
+
 /**
  * @typedef {{
  *   system: ScopedBridgeManager<'vlocalchain'>;
@@ -30,7 +47,9 @@ const { Fail } = assert;
 export const LocalChainAccountI = M.interface('LocalChainAccount', {
   getAddress: M.callWhen().returns(M.string()),
   getBalance: M.callWhen(BrandShape).returns(AmountShape),
-  deposit: M.callWhen(PaymentShape).optional(M.pattern()).returns(AmountShape),
+  deposit: M.callWhen(PaymentShape)
+    .optional(M.pattern())
+    .returns(NetworkShape.Vow$(AmountShape)),
   withdraw: M.callWhen(AmountShape).returns(PaymentShape),
   executeTx: M.callWhen(M.arrayOf(M.record())).returns(M.arrayOf(M.record())),
   monitorTransfers: M.callWhen(M.remotable('TransferTap')).returns(
@@ -38,90 +57,140 @@ export const LocalChainAccountI = M.interface('LocalChainAccount', {
   ),
 });
 
-/** @param {import('@agoric/base-zone').Zone} zone */
-const prepareLocalChainAccount = zone =>
-  zone.exoClass(
-    'LocalChainAccount',
-    LocalChainAccountI,
+/**
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {VowTools} vowTools
+ */
+export const prepareLocalChainAccountKit = (zone, { watch }) =>
+  zone.exoClassKit(
+    'LocalChainAccountKit',
+    {
+      account: LocalChainAccountI,
+      depositPaymentWatcher: M.interface('DepositPaymentWatcher', {
+        onFulfilled: M.call(BrandShape)
+          .optional({
+            payment: PaymentShape,
+            optAmountShape: M.or(M.undefined(), AmountShape),
+          })
+          .returns(M.promise()),
+      }),
+    },
     /**
      * @param {string} address
      * @param {AccountPowers} powers
      */
-    (address, powers) => ({ address, ...powers, reserved: undefined }),
+    (address, powers) => ({
+      address,
+      ...powers,
+      reserved: undefined,
+    }),
     {
-      // Information that the account creator needs.
-      getAddress() {
-        return this.state.address;
-      },
-      /** @param {Brand<'nat'>} brand */
-      async getBalance(brand) {
-        const { bank } = this.state;
-        const purse = E(bank).getPurse(brand);
-        return E(purse).getCurrentAmount();
-      },
-      /**
-       * 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<'nat'>} payment
-       * @param {Pattern} [optAmountShape] throws if the Amount of the Payment
-       *   does not match the provided Pattern
-       * @returns {Promise<Amount>}
-       */
-      async deposit(payment, optAmountShape) {
-        const { bank } = this.state;
-
-        const allegedBrand = await E(payment).getAllegedBrand();
-        const purse = E(bank).getPurse(allegedBrand);
-        return E(purse).deposit(payment, optAmountShape);
-      },
-      /**
-       * Withdraw a payment from the account's bank purse of the amount's brand.
-       *
-       * @param {Amount<'nat'>} amount
-       * @returns {Promise<Payment<'nat'>>} payment
-       */
-      async withdraw(amount) {
-        const { bank } = this.state;
-        const purse = E(bank).getPurse(amount.brand);
-        return E(purse).withdraw(amount);
-      },
-      /**
-       * 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]: JsonSafe<ResponseTo<MT[K]>> }>}
-       */
-      async executeTx(messages) {
-        const { address, system } = this.state;
-        messages.length > 0 || Fail`need at least one message to execute`;
-
-        const obj = {
-          type: 'VLOCALCHAIN_EXECUTE_TX',
-          // This address is the only one that `VLOCALCHAIN_EXECUTE_TX` will
-          // accept as a signer for the transaction.  If the messages have other
-          // addresses in signer positions, the transaction will be aborted.
-          address,
-          messages,
-        };
-        return E(system).toBridge(obj);
+      depositPaymentWatcher: {
+        /**
+         * @param {Brand<'nat'>} brand
+         * @param {{
+         *   payment: Payment<'nat'>;
+         *   optAmountShape: Amount<'nat'>;
+         * }} ctx
+         */
+        onFulfilled(brand, { payment, optAmountShape }) {
+          const purse = E(this.state.bank).getPurse(brand);
+          return E(purse).deposit(payment, optAmountShape);
+        },
       },
-      async monitorTransfers(tap) {
-        const { address, transfer } = this.state;
-        return E(transfer).registerTap(address, tap);
+      account: {
+        // Information that the account creator needs.
+        getAddress() {
+          return this.state.address;
+        },
+        /**
+         * @param {Brand<'nat'>} brand
+         * @returns {PromiseVow<Amount<'nat'>>}
+         */
+        async getBalance(brand) {
+          const { bank } = this.state;
+          const purse = E(bank).getPurse(brand);
+          return E(purse).getCurrentAmount();
+        },
+        /**
+         * 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<'nat'>} payment
+         * @param {Pattern} [optAmountShape] throws if the Amount of the Payment
+         *   does not match the provided Pattern
+         * @returns {PromiseVow<Amount<'nat'>>}
+         */
+        async deposit(payment, optAmountShape) {
+          return watch(
+            E(payment).getAllegedBrand(),
+            this.facets.depositPaymentWatcher,
+            {
+              payment,
+              optAmountShape,
+            },
+          );
+        },
+        /**
+         * Withdraw a payment from the account's bank purse of the amount's
+         * brand.
+         *
+         * @param {Amount<'nat'>} amount
+         * @returns {PromiseVow<Payment<'nat'>>} payment
+         */
+        async withdraw(amount) {
+          const { bank } = this.state;
+          const purse = E(bank).getPurse(amount.brand);
+          return E(purse).withdraw(amount);
+        },
+        /**
+         * Execute a batch of messages in order as a single atomic transaction
+         * and return the responses. If any of the messages fails, the entire
+         * batch will be rolled back. 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 {PromiseVowOfTupleMappedToGenerics<{
+         *   [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>;
+         * }>}
+         */
+        async executeTx(messages) {
+          const { address, system } = this.state;
+          messages.length > 0 || Fail`need at least one message to execute`;
+
+          const obj = {
+            type: 'VLOCALCHAIN_EXECUTE_TX',
+            // This address is the only one that `VLOCALCHAIN_EXECUTE_TX` will
+            // accept as a signer for the transaction.  If the messages have other
+            // addresses in signer positions, the transaction will be aborted.
+            address,
+            messages,
+          };
+          return E(system).toBridge(obj);
+        },
+        /**
+         * @param {TargetApp} tap
+         * @returns {PromiseVow<TargetRegistration>}
+         */
+        async monitorTransfers(tap) {
+          const { address, transfer } = this.state;
+          return E(transfer).registerTap(address, tap);
+        },
       },
     },
   );
+
 /**
  * @typedef {Awaited<
- *   ReturnType<Awaited<ReturnType<typeof prepareLocalChainAccount>>>
- * >} LocalChainAccount
+ *   ReturnType<ReturnType<typeof prepareLocalChainAccountKit>>
+ * >} LocalChainAccountKit
  */
 
+/** @typedef {LocalChainAccountKit['account']} LocalChainAccount */
+
 export const LocalChainI = M.interface('LocalChain', {
   makeAccount: M.callWhen().returns(M.remotable('LocalChainAccount')),
   query: M.callWhen(M.record()).returns(M.record()),
@@ -130,77 +199,118 @@ export const LocalChainI = M.interface('LocalChain', {
 
 /**
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<typeof prepareLocalChainAccount>} makeAccount
+ * @param {ReturnType<typeof prepareLocalChainAccountKit>} makeAccountKit
+ * @param {VowTools} vowTools
  */
-const prepareLocalChain = (zone, makeAccount) =>
-  zone.exoClass(
-    'LocalChain',
-    LocalChainI,
+const prepareLocalChain = (zone, makeAccountKit, { watch }) => {
+  const makeLocalChainKit = zone.exoClassKit(
+    'LocalChainKit',
+    {
+      public: LocalChainI,
+      extractFirstQueryResultWatcher: M.interface(
+        'ExtractFirstQueryResultWatcher',
+        {
+          onFulfilled: M.call(M.arrayOf(M.record())).returns(M.record()),
+        },
+      ),
+    },
     /** @param {LocalChainPowers} powers */
     powers => {
       return { ...powers };
     },
     {
-      /**
-       * 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, transfer } = this.state;
-        const address = await E(system).toBridge({
-          type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
-        });
-        const bank = await E(bankManager).getBankForAddress(address);
-        return makeAccount(address, { system, bank, transfer });
-      },
-      /**
-       * 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;
+      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.
+         *
+         * @returns {PromiseVow<LocalChainAccount>}
+         */
+        async makeAccount() {
+          const { system, bankManager, transfer } = this.state;
+          const address = await E(system).toBridge({
+            type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
+          });
+          const bank = await E(bankManager).getBankForAddress(address);
+          return makeAccountKit(address, { system, bank, transfer }).account;
+        },
+        /**
+         * 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.
+         *
+         * @template {TypedJson} [T=TypedJson]
+         * @param {T} request
+         * @returns {PromiseVow<JsonSafe<ResponseTo<T>>>}
+         */
+        async query(request) {
+          const requests = harden([request]);
+          return watch(
+            E(this.facets.public).queryMany(requests),
+            this.facets.extractFirstQueryResultWatcher,
+          );
+        },
+        /**
+         * 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.
+         *
+         * @template {import('@agoric/cosmic-proto').TypedJson[]} RT
+         * @param {RT} requests
+         * @returns {PromiseVowOfTupleMappedToGenerics<{
+         *   [K in keyof RT]: JsonSafe<{
+         *     error?: string;
+         *     reply: ResponseTo<RT[K]>;
+         *   }>;
+         * }>}
+         */
+        async queryMany(requests) {
+          const { system } = this.state;
+          return E(system).toBridge({
+            type: 'VLOCALCHAIN_QUERY_MANY',
+            messages: requests,
+          });
+        },
       },
-      /**
-       * 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,
-        });
+      extractFirstQueryResultWatcher: {
+        /**
+         * Extract the first result from the array of results or throw an error
+         * if that result failed.
+         *
+         * @param {JsonSafe<{
+         *   error?: string;
+         *   reply: TypedJson<any>;
+         * }>[]} results
+         */
+        onFulfilled(results) {
+          results.length === 1 ||
+            Fail`expected exactly one result; got ${results}`;
+          const { error, reply } = results[0];
+          if (error) {
+            throw Fail`query failed: ${error}`;
+          }
+          return reply;
+        },
       },
     },
   );
 
-/** @param {import('@agoric/base-zone').Zone} zone */
-export const prepareLocalChainTools = zone => {
-  const makeAccount = prepareLocalChainAccount(zone);
-  const makeLocalChain = prepareLocalChain(zone, makeAccount);
+  /**
+   * @param {LocalChainPowers} powers
+   */
+  const makeLocalChain = powers => makeLocalChainKit(powers).public;
+  return makeLocalChain;
+};
+
+/**
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {VowTools} vowTools
+ */
+export const prepareLocalChainTools = (zone, vowTools) => {
+  const makeAccountKit = prepareLocalChainAccountKit(zone, vowTools);
+  const makeLocalChain = prepareLocalChain(zone, makeAccountKit, vowTools);
 
   return harden({ makeLocalChain });
 };

package/src/proposals/localchain-test.js

@@ -1,5 +1,5 @@
 // @ts-check
-import { E } from '@endo/far';
+import { V as E } from '@agoric/vow/vat.js';
 import { typedJson } from '@agoric/cosmic-proto/vatsafe';
 
 /**

package/src/vat-localchain.d.ts

@@ -6,25 +6,27 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
      * @param {import('./localchain.js').LocalChainPowers} powers
      */
     makeLocalChain(powers: import("./localchain.js").LocalChainPowers): import("@endo/exo").Guarded<{
-        makeAccount(): Promise<import("@endo/exo").Guarded<{
+        makeAccount(): import("@agoric/vow").PromiseVow<import("@endo/exo").Guarded<{
             getAddress(): string;
-            getBalance(brand: Brand<"nat">): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
-            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<globalThis.Amount>;
-            withdraw(amount: Amount<"nat">): Promise<globalThis.Payment<"nat">>;
+            getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
             executeTx<MT extends {
                 '@type': string;
-            }[]>(messages: MT): Promise<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-            monitorTransfers(tap: any): Promise<any>;
+            }[]>(messages: MT): import("./localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
+            monitorTransfers(tap: import("./bridge-target.js").TargetApp): import("@agoric/vow").PromiseVow<import("./bridge-target.js").TargetRegistration>;
         }>>;
-        query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
+        query<T extends {
             '@type': string;
-        }>;
-        queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
+        } = {
+            '@type': string;
+        }>(request: T): import("@agoric/vow").PromiseVow<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<T>>>;
+        queryMany<RT extends {
+            '@type': string;
+        }[]>(requests: RT): import("./localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K_1 in keyof RT]: import("@agoric/cosmic-proto").JsonSafe<{
             error?: string | undefined;
-            reply: {
-                '@type': string;
-            };
-        }[]>;
+            reply: import("@agoric/cosmic-proto").ResponseTo<RT[K_1]>;
+        }>; }>;
     }>;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     /**
@@ -34,25 +36,27 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
      * @param {import('./localchain.js').LocalChainPowers} powers
      */
     makeLocalChain(powers: import("./localchain.js").LocalChainPowers): import("@endo/exo").Guarded<{
-        makeAccount(): Promise<import("@endo/exo").Guarded<{
+        makeAccount(): import("@agoric/vow").PromiseVow<import("@endo/exo").Guarded<{
             getAddress(): string;
-            getBalance(brand: Brand<"nat">): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
-            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<globalThis.Amount>;
-            withdraw(amount: Amount<"nat">): Promise<globalThis.Payment<"nat">>;
+            getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
             executeTx<MT extends {
                 '@type': string;
-            }[]>(messages: MT): Promise<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-            monitorTransfers(tap: any): Promise<any>;
+            }[]>(messages: MT): import("./localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
+            monitorTransfers(tap: import("./bridge-target.js").TargetApp): import("@agoric/vow").PromiseVow<import("./bridge-target.js").TargetRegistration>;
         }>>;
-        query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
+        query<T extends {
             '@type': string;
-        }>;
-        queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
+        } = {
+            '@type': string;
+        }>(request: T): import("@agoric/vow").PromiseVow<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<T>>>;
+        queryMany<RT extends {
+            '@type': string;
+        }[]>(requests: RT): import("./localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K_1 in keyof RT]: import("@agoric/cosmic-proto").JsonSafe<{
             error?: string | undefined;
-            reply: {
-                '@type': string;
-            };
-        }[]>;
+            reply: import("@agoric/cosmic-proto").ResponseTo<RT[K_1]>;
+        }>; }>;
     }>;
 }>;
 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,iBAAiB,EAAE,gBAAgB;;;8BASs1B,MAAM,KAAK,CAAC;6BAA8b,QAAQ,KAAK,CAAC,mBAA2B,OAAO;6BAAwhB,OAAO,KAAK,CAAC;;;2BAAgiB,EAAE;;;uBAAg0E,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;IAbvgL;;;;;OAKG;2BADQ,OAAO,iBAAiB,EAAE,gBAAgB;;;;;;;;;;;sDASsvJ,SAAS;;;2DAAwsB,SAAS;;;;;;;GAHxgL;4BAEa,UAAU,CAAC,OAAO,eAAe,CAAC"}
+{"version":3,"file":"vat-localchain.d.ts","sourceRoot":"","sources":["vat-localchain.js"],"names":[],"mappings":"AAOO;IASH;;;;;OAKG;2BADQ,OAAO,iBAAiB,EAAE,gBAAgB;;;8BAS4xE,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;;IAbrzP;;;;;OAKG;2BADQ,OAAO,iBAAiB,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;GAMxD;4BAEa,UAAU,CAAC,OAAO,eAAe,CAAC"}

package/src/vat-localchain.js

@@ -1,12 +1,17 @@
 // @ts-check
 import { Far } from '@endo/far';
 import { makeDurableZone } from '@agoric/zone/durable.js';
+import { prepareVowTools } from '@agoric/vow/vat.js';
 
 import { prepareLocalChainTools } from './localchain.js';
 
 export const buildRootObject = (_vatPowers, _args, baggage) => {
   const zone = makeDurableZone(baggage);
-  const { makeLocalChain } = prepareLocalChainTools(zone.subZone('localchain'));
+  const vowTools = prepareVowTools(zone.subZone('VowTools'));
+  const { makeLocalChain } = prepareLocalChainTools(
+    zone.subZone('localchain'),
+    vowTools,
+  );
 
   return Far('LocalChainVat', {
     /**

package/src/vat-network.d.ts

@@ -45,10 +45,10 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
     /** @param {Parameters<typeof protocol.unregisterProtocolHandler>} args */
     unregisterProtocolHandler: (prefix: string, protocolHandler: import("@agoric/internal").Remote<import("@agoric/network").ProtocolHandler>) => void;
     getPortAllocator(): import("@endo/exo").Guarded<{
-        allocateCustomIBCPort(specifiedName?: string): import("@agoric/vow").Vow<import("@agoric/network").Port>;
-        allocateICAControllerPort(): import("@agoric/vow").Vow<import("@agoric/network").Port>;
-        allocateICQControllerPort(): import("@agoric/vow").Vow<import("@agoric/network").Port>;
-        allocateCustomLocalPort(specifiedName?: string): import("@agoric/vow").Vow<import("@agoric/network").Port>;
+        allocateCustomIBCPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateICAControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateICQControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateCustomLocalPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
     }>;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     makeLoopbackProtocolHandler: (instancePrefix?: string | undefined) => import("@endo/exo").Guarded<{
@@ -110,10 +110,10 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
     /** @param {Parameters<typeof protocol.unregisterProtocolHandler>} args */
     unregisterProtocolHandler: (prefix: string, protocolHandler: import("@agoric/internal").Remote<import("@agoric/network").ProtocolHandler>) => void;
     getPortAllocator(): import("@endo/exo").Guarded<{
-        allocateCustomIBCPort(specifiedName?: string): import("@agoric/vow").Vow<import("@agoric/network").Port>;
-        allocateICAControllerPort(): import("@agoric/vow").Vow<import("@agoric/network").Port>;
-        allocateICQControllerPort(): import("@agoric/vow").Vow<import("@agoric/network").Port>;
-        allocateCustomLocalPort(specifiedName?: string): import("@agoric/vow").Vow<import("@agoric/network").Port>;
+        allocateCustomIBCPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateICAControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateICQControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateCustomLocalPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
     }>;
 }>;
 //# sourceMappingURL=vat-network.d.ts.map