@agoric/vats 0.16.0-upgrade-16-dev-0df76a7.0 → 0.16.0-upgrade-17-dev-a61cdab.0

package/src/vat-board.d.ts

@@ -23,8 +23,8 @@ export function buildRootObject(_vatPowers: unknown, _vatParameters: unknown, ba
             unserialize(data: any): any;
         }>;
     }>;
-    makePublishingRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>;
-    makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>;
+    makePublishingRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/internal").TypedPattern<T> | undefined) => RecorderKit<T>;
+    makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/internal").TypedPattern<T> | undefined) => RecorderKit<T>;
 } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     getBoard: () => import("@endo/exo").Guarded<{
         getId(value: import("@endo/marshal").RemotableObject): string;
@@ -45,7 +45,7 @@ export function buildRootObject(_vatPowers: unknown, _vatParameters: unknown, ba
             unserialize(data: any): any;
         }>;
     }>;
-    makePublishingRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>;
-    makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>;
+    makePublishingRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/internal").TypedPattern<T> | undefined) => RecorderKit<T>;
+    makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | Awaited<import("jessie.js").FarRef<StorageNode>>, valueShape?: import("@agoric/internal").TypedPattern<T> | undefined) => RecorderKit<T>;
 }>;
 //# sourceMappingURL=vat-board.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vat-board.d.ts","sourceRoot":"","sources":["vat-board.js"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,4CAJW,OAAO,kBACP,OAAO,WACP,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;6EA4B0lH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;GADjpH"}
+{"version":3,"file":"vat-board.d.ts","sourceRoot":"","sources":["vat-board.js"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,4CAJW,OAAO,kBACP,OAAO,WACP,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;6EA4BspH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;GAD7sH"}

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

@@ -1 +1 @@
-{"version":3,"file":"vat-bridge.d.ts","sourceRoot":"","sources":["vat-bridge.js"],"names":[],"mappings":"AAOA;yDAea,IAAI,CAAC,OAAO,YAAY,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC,YACzD,MAAM,YACN,MAAM;;;;oBA0BwwJ,CAAC;;;;oEAA5wB,YAAY;;yDA5B/gI,IAAI,CAAC,OAAO,YAAY,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC,YACzD,MAAM,YACN,MAAM;;;;oBA0BwwJ,CAAC;;;;;GAD3xJ"}
+{"version":3,"file":"vat-bridge.d.ts","sourceRoot":"","sources":["vat-bridge.js"],"names":[],"mappings":"AAOA;yDAea,IAAI,CAAC,OAAO,YAAY,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC,YACzD,MAAM,YACN,MAAM;;;;oBA0BqxJ,CAAC;;;;oEAAmH,YAAY;;yDA5B35J,IAAI,CAAC,OAAO,YAAY,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC,YACzD,MAAM,YACN,MAAM;;;;oBA0BqxJ,CAAC;;;;;GADxyJ"}

package/src/vat-bridge.js

@@ -1,4 +1,4 @@
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 import { Far } from '@endo/far';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 import * as cb from '@agoric/internal/src/callback.js';

package/src/vat-localchain.d.ts

@@ -10,9 +10,15 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
         query<T extends import("@agoric/cosmic-proto").TypedJson = {
             '@type': string;
         }>(request: T): import("@agoric/vow").PromiseVow<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<T>>>;
-        queryMany<RT extends import("@agoric/cosmic-proto").TypedJson[]>(requests: RT): PromiseVowOfTupleMappedToGenerics<{ [K in keyof RT]: import("@agoric/cosmic-proto").JsonSafe<{
+        queryMany(requests: {
+            '@type': string;
+        }[]): import("./localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof {
+            '@type': string;
+        }[]]: import("@agoric/cosmic-proto").JsonSafe<{
             error?: string;
-            reply: import("@agoric/cosmic-proto").ResponseTo<RT[K]>;
+            reply: import("@agoric/cosmic-proto").ResponseTo<{
+                '@type': string;
+            }[][K]>;
         }>; }>;
     }>;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
@@ -27,9 +33,15 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
         query<T extends import("@agoric/cosmic-proto").TypedJson = {
             '@type': string;
         }>(request: T): import("@agoric/vow").PromiseVow<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<T>>>;
-        queryMany<RT extends import("@agoric/cosmic-proto").TypedJson[]>(requests: RT): PromiseVowOfTupleMappedToGenerics<{ [K in keyof RT]: import("@agoric/cosmic-proto").JsonSafe<{
+        queryMany(requests: {
+            '@type': string;
+        }[]): import("./localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof {
+            '@type': string;
+        }[]]: import("@agoric/cosmic-proto").JsonSafe<{
             error?: string;
-            reply: import("@agoric/cosmic-proto").ResponseTo<RT[K]>;
+            reply: import("@agoric/cosmic-proto").ResponseTo<{
+                '@type': string;
+            }[][K]>;
         }>; }>;
     }>;
 }>;

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

@@ -1 +1 @@
-{"version":3,"file":"vat-localchain.d.ts","sourceRoot":"","sources":["vat-localchain.js"],"names":[],"mappings":"AAOO;IASH;;;;;OAKG;2BADQ,OAAO,iBAAiB,EAAE,gBAAgB;;;;;oCASuxP,sBAAsB;iBAAwK,CAAC;;;;;IAb3gQ;;;;;OAKG;2BADQ,OAAO,iBAAiB,EAAE,gBAAgB;;;;;;iBASq9P,CAAC;;;;GAH9gQ;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;;;;;;;;;;iBASuiB,CAAC;;;;;;;IAb7lB;;;;;OAKG;2BADQ,OAAO,iBAAiB,EAAE,gBAAgB;;;;;;;;;;iBASuiB,CAAC;;;;;;GAHhmB;4BAEa,UAAU,CAAC,OAAO,eAAe,CAAC"}

package/src/vat-network.d.ts

@@ -12,12 +12,12 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
     makeEchoConnectionKit: () => import("@endo/exo").GuardedKit<{
         handler: {
             onReceive(_connection: import("@agoric/network").Connection, bytes: import("@agoric/network").Bytes, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
-            onClose(_connection: import("@agoric/network").Connection, _reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
+            onClose(_connection: import("@agoric/network").Connection, reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
         };
         listener: {
             onAccept(_port: any, _localAddr: any, _remoteAddr: any, _listenHandler: any): Promise<import("@endo/exo").Guarded<{
                 onReceive(_connection: import("@agoric/network").Connection, bytes: import("@agoric/network").Bytes, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
-                onClose(_connection: import("@agoric/network").Connection, _reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
+                onClose(_connection: import("@agoric/network").Connection, reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
             }>>;
             onListen(port: any, _listenHandler: any): Promise<void>;
         };
@@ -46,12 +46,12 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
     makeEchoConnectionKit: () => import("@endo/exo").GuardedKit<{
         handler: {
             onReceive(_connection: import("@agoric/network").Connection, bytes: import("@agoric/network").Bytes, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
-            onClose(_connection: import("@agoric/network").Connection, _reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
+            onClose(_connection: import("@agoric/network").Connection, reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
         };
         listener: {
             onAccept(_port: any, _localAddr: any, _remoteAddr: any, _listenHandler: any): Promise<import("@endo/exo").Guarded<{
                 onReceive(_connection: import("@agoric/network").Connection, bytes: import("@agoric/network").Bytes, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
-                onClose(_connection: import("@agoric/network").Connection, _reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
+                onClose(_connection: import("@agoric/network").Connection, reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
             }>>;
             onListen(port: any, _listenHandler: any): Promise<void>;
         };

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

@@ -1 +1 @@
-{"version":3,"file":"vat-network.d.ts","sourceRoot":"","sources":["vat-network.js"],"names":[],"mappings":"AAWA;;;;;qIAqCs5nC,aAAa;;;oCAAmuE,kBAAa,+GAAsF,kBAAa;;;;;;;;;;;;;;;;IAXlvsC,wEAAwE;;IAGxE,0EAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAH1E,wEAAwE;;IAGxE,0EAA0E;;;;;;;;GAO7E"}
+{"version":3,"file":"vat-network.d.ts","sourceRoot":"","sources":["vat-network.js"],"names":[],"mappings":"AAYA;;;;;qIAsC2hnC,aAAa;;;;;;;;;;;;;;;;;;;IAXpinC,wEAAwE;;IAGxE,0EAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAH1E,wEAAwE;;IAGxE,0EAA0E;;;;;;;;GAO7E"}

package/src/vat-network.js

@@ -3,6 +3,7 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 import {
   prepareEchoConnectionKit,
   prepareLoopbackProtocolHandler,
+  prepareNetworkPowers,
   preparePortAllocator,
   prepareRouterProtocol,
 } from '@agoric/network';
@@ -11,7 +12,8 @@ import { Far } from '@endo/far';
 
 export function buildRootObject(_vatPowers, _args, baggage) {
   const zone = makeDurableZone(baggage);
-  const powers = prepareVowTools(zone.subZone('vow'));
+  const vowTools = prepareVowTools(zone.subZone('vow'));
+  const powers = prepareNetworkPowers(zone, vowTools);
 
   const makeRouterProtocol = prepareRouterProtocol(
     zone.subZone('network'),

package/src/vat-transfer.d.ts

@@ -28,7 +28,7 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
         };
         interceptorFactory: {
             wrapApp: (tap: globalThis.ERef<import("./bridge-target.js").TargetApp>, targetHost: globalThis.ERef<import("./bridge-target.js").TargetHost>, isActiveTap?: boolean | undefined) => import("@endo/exo").Guarded<{
-                receiveUpcall(obj: any): Promise<import("@agoric/vow").Vow<unknown> | undefined>;
+                receiveUpcall(obj: import("./types").VTransferIBCEvent): Promise<import("@agoric/vow").Vow<unknown> | undefined>;
             }>;
         };
         transferMiddleware: {
@@ -67,7 +67,7 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
         };
         interceptorFactory: {
             wrapApp: (tap: globalThis.ERef<import("./bridge-target.js").TargetApp>, targetHost: globalThis.ERef<import("./bridge-target.js").TargetHost>, isActiveTap?: boolean | undefined) => import("@endo/exo").Guarded<{
-                receiveUpcall(obj: any): Promise<import("@agoric/vow").Vow<unknown> | undefined>;
+                receiveUpcall(obj: import("./types").VTransferIBCEvent): Promise<import("@agoric/vow").Vow<unknown> | undefined>;
             }>;
         };
         transferMiddleware: {

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

@@ -1 +1 @@
-{"version":3,"file":"vat-transfer.d.ts","sourceRoot":"","sources":["vat-transfer.js"],"names":[],"mappings":"AASO;IAyBH;;;;;OAKG;2BAJqD,CAAC,SAA5C,OAAQ,kBAAkB,EAAE,aAAc,WAC5C,OAAO,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC;;;;;;;;;;;;;IAkBnD;;;OAGG;;;yCAMw8J,oBAAiB;;;;;;;;yDAAl6C,oBAAoB;+DAApB,oBAAoB;;;;;IA7B9kH;;;;;OAKG;2BAJqD,CAAC,SAA5C,OAAQ,kBAAkB,EAAE,aAAc,WAC5C,OAAO,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC;;;;;;;;;;;;;IAkBnD;;;OAGG;;;;;;;;;;;;;;;;GAGN;0BAEa,UAAU,CAAC,OAAO,eAAe,CAAC"}
+{"version":3,"file":"vat-transfer.d.ts","sourceRoot":"","sources":["vat-transfer.js"],"names":[],"mappings":"AASO;IAyBH;;;;;OAKG;2BAJqD,CAAC,SAA5C,OAAQ,kBAAkB,EAAE,aAAc,WAC5C,OAAO,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC;;;;;;;;;;;;;IAkBnD;;;OAGG;;;yCAM6iK,oBAAiB;;;;;;;;yDAAl6C,oBAAoB;+DAApB,oBAAoB;;;;;IA7BnrH;;;;;OAKG;2BAJqD,CAAC,SAA5C,OAAQ,kBAAkB,EAAE,aAAc,WAC5C,OAAO,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC;;;;;;;;;;;;;IAkBnD;;;OAGG;;;;;;;;;;;;;;;;GAGN;0BAEa,UAAU,CAAC,OAAO,eAAe,CAAC"}

package/src/vat-zoe.d.ts

@@ -1,14 +1,15 @@
 export function buildRootObject(vatPowers: any, _vatParams: any, zoeBaggage: any): {
     buildZoe: (adminVat: any, feeIssuerConfig: any, zcfBundleName: any) => Promise<{
-        zoeService: ZoeService;
+        zoeService: import("@endo/exo").Guarded<ZoeService>;
         feeMintAccess: FeeMintAccess;
     }>;
     getZoeConfigFacet: () => any;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     buildZoe: (adminVat: any, feeIssuerConfig: any, zcfBundleName: any) => Promise<{
-        zoeService: ZoeService;
+        zoeService: import("@endo/exo").Guarded<ZoeService>;
         feeMintAccess: FeeMintAccess;
     }>;
     getZoeConfigFacet: () => any;
 }>;
+export type ZoeVat = ReturnType<typeof buildRootObject>;
 //# sourceMappingURL=vat-zoe.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vat-zoe.d.ts","sourceRoot":"","sources":["vat-zoe.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAgDC"}
+{"version":3,"file":"vat-zoe.d.ts","sourceRoot":"","sources":["vat-zoe.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAgDC;qBAEa,UAAU,CAAC,OAAO,eAAe,CAAC"}

package/src/vat-zoe.js

@@ -52,3 +52,5 @@ export function buildRootObject(vatPowers, _vatParams, zoeBaggage) {
     getZoeConfigFacet: () => zoeConfigFacet,
   });
 }
+
+/** @typedef {ReturnType<typeof buildRootObject>} ZoeVat */

package/src/virtual-purse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"virtual-purse.d.ts","sourceRoot":"","sources":["virtual-purse.js"],"names":[],"mappings":"AAoBO,qDAHI,OAAO,gBACP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DjB;AAsMM,0CADK,OAAO,cAAc,EAAE,IAAI,SAK1B,IAAI,CAAC,sBAAsB,CAAC,qDAE5B;IACV,MAAU,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAChC,KAAS,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACxB,IAAQ,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7B,WAAe,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;CAClC,KAQS,OAAO,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CA0BnD;qBA9OY,CACZ,GAAO,EAAE,OAAO,CAAC,KAAK,CAAC,EACvB,cAAkB,CAAC,EAAE,OAAO,KACrB,OAAO,CAAC,MAAM,CAAC;qBAET,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;;;;;;;;;;;;gBAK/C,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;;;;;;;gBAIjC,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;;;;;iBAIjC,CAAC,KAAK,EAAE,KAAK,KAAK,WAAW,CAAC,MAAM,CAAC;;2BArB1B,WAAW"}
+{"version":3,"file":"virtual-purse.d.ts","sourceRoot":"","sources":["virtual-purse.js"],"names":[],"mappings":"AAmBO,qDAHI,OAAO,gBACP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DjB;AAwNM,0CADK,OAAO,cAAc,EAAE,IAAI,SAK1B,IAAI,CAAC,sBAAsB,CAAC,qDAE5B;IACV,MAAU,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAChC,KAAS,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IACxB,IAAQ,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7B,WAAe,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;CAClC,KAQS,OAAO,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CA0BnD;qBAhQY,CACZ,GAAO,EAAE,OAAO,CAAC,KAAK,CAAC,EACvB,cAAkB,CAAC,EAAE,OAAO,KACrB,OAAO,CAAC,MAAM,CAAC;qBAET,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;;;;;;;;;;;;gBAK/C,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;;;;;;;gBAIjC,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;;;;;iBAIjC,CAAC,KAAK,EAAE,KAAK,KAAK,WAAW,CAAC,MAAM,CAAC;;2BArB1B,WAAW"}

package/src/virtual-purse.js

@@ -1,18 +1,17 @@
-import { M } from '@agoric/store';
+import { Fail } from '@endo/errors';
 import { E } from '@endo/far';
 import { isPromise } from '@endo/promise-kit';
+import { getInterfaceGuardPayload, matches } from '@endo/patterns';
 
+import { M } from '@agoric/store';
 import {
+  AmountPatternShape,
   AmountShape,
   BrandShape,
   DepositFacetShape,
   NotifierShape,
   PaymentShape,
-} from '@agoric/ertp/src/typeGuards.js';
-
-import { getInterfaceGuardPayload } from '@endo/patterns';
-
-const { Fail } = assert;
+} from '@agoric/ertp';
 
 /**
  * @param {Pattern} [brandShape]
@@ -37,7 +36,7 @@ export const makeVirtualPurseKitIKit = (
     // to this raw method to validate that this remotable is actually
     // a live payment of the correct brand with sufficient funds.
     deposit: M.callWhen(PaymentShape)
-      .optional(M.pattern())
+      .optional(AmountPatternShape)
       .returns(amountShape),
     getDepositFacet: M.callWhen().returns(DepositFacetShape),
     withdraw: M.callWhen(amountShape).returns(PaymentShape),
@@ -50,7 +49,9 @@ export const makeVirtualPurseKitIKit = (
   });
 
   const RetainRedeemI = M.interface('RetainRedeem', {
-    retain: M.callWhen(PaymentShape).optional(amountShape).returns(amountShape),
+    retain: M.callWhen(PaymentShape)
+      .optional(AmountPatternShape)
+      .returns(amountShape),
     redeem: M.callWhen(amountShape).returns(PaymentShape),
   });
 
@@ -58,7 +59,7 @@ export const makeVirtualPurseKitIKit = (
     retain: getInterfaceGuardPayload(RetainRedeemI).methodGuards.retain,
     redeem: getInterfaceGuardPayload(RetainRedeemI).methodGuards.redeem,
     recoverableClaim: M.callWhen(M.await(PaymentShape))
-      .optional(amountShape)
+      .optional(AmountPatternShape)
       .returns(PaymentShape),
   });
 
@@ -104,6 +105,22 @@ export const makeVirtualPurseKitIKit = (
  *   current balance iterable for a given brand.
  */
 
+/**
+ * Until https://github.com/Agoric/agoric-sdk/issues/9407 is fixed, this
+ * function restricts the `optAmountShape`, if provided, to be a concrete
+ * `Amount` rather than a `Pattern` as it is supposed to be.
+ *
+ * TODO: Once https://github.com/Agoric/agoric-sdk/issues/9407 is fixed, remove
+ * this function and all calls to it.
+ *
+ * @param {Pattern} [optAmountShape]
+ */
+const legacyRestrictAmountShapeArg = optAmountShape => {
+  if (optAmountShape && !matches(optAmountShape, AmountShape)) {
+    throw Fail`optAmountShape if provided, must still be a concrete Amount due to https://github.com/Agoric/agoric-sdk/issues/9407`;
+  }
+};
+
 /** @param {import('@agoric/zone').Zone} zone */
 const prepareVirtualPurseKit = zone =>
   zone.exoClassKit(
@@ -141,6 +158,7 @@ const prepareVirtualPurseKit = zone =>
          * @returns {Promise<Payment<'nat'>>}
          */
         async recoverableClaim(payment, optAmountShape) {
+          legacyRestrictAmountShapeArg(optAmountShape);
           const {
             state: { recoveryPurse },
           } = this;
@@ -168,6 +186,7 @@ const prepareVirtualPurseKit = zone =>
       minter: {
         /** @type {Retain} */
         async retain(payment, optAmountShape) {
+          legacyRestrictAmountShapeArg(optAmountShape);
           !!this.state.mint || Fail`minter cannot retain without a mint.`;
           return E(this.state.issuer).burn(payment, optAmountShape);
         },

package/tools/bank-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bank-utils.d.ts","sourceRoot":"","sources":["bank-utils.js"],"names":[],"mappings":"AAYO,4CAFI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC,EAAE;sBA4B1C,MAAM,cACN,MAAM,gBACN,MAAM,OACN,OAAO,oBAAoB,EAAE,cAAc;;;EAqBvD;AAMM;cAFI,OAAO,kBAAkB,EAAE,QAAQ;;;;6FA0Bm9gB,WAAW,eAA6B,2BAA2B;;;mBAAo8C,CAAC;;;;0BAX5/jB,MAAM,CAAC,KAAK,CAAC,KACX,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;GASrC"}
+{"version":3,"file":"bank-utils.d.ts","sourceRoot":"","sources":["bank-utils.js"],"names":[],"mappings":"AAYO,4CAFI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC,EAAE;sBA4B1C,MAAM,cACN,MAAM,gBACN,MAAM,OACN,OAAO,oBAAoB,EAAE,cAAc;;;EAqBvD;AAMM;cAFI,OAAO,kBAAkB,EAAE,QAAQ;;;;6FA0Bg+gB,WAAW,eAA6B,2BAA2B;;;mBAAo8C,CAAC;;;;0BAXzgkB,MAAM,CAAC,KAAK,CAAC,KACX,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;GASrC"}

package/tools/boot-test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boot-test-utils.d.ts","sourceRoot":"","sources":["boot-test-utils.js"],"names":[],"mappings":";;;;;;;;;;;AAiCO,6BAAqB;AAE5B,qBAAqB;AACrB,yBADW,MAAM,CACgB;AAE1B;;;;;;;iBAGmB,GAAG;iBACH,GAAG;eAGL,GAAG;gBACF,GAAG;;;eAIJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BvB;AAEG;;;EAmEN;AAEM,iDAON;mDAnJkD,2BAA2B;4CAClC,oBAAoB;6CACnB,qBAAqB;2CACvB,mBAAmB;6CACjB,qBAAqB;+CACnB,uBAAuB;sDAChB,8BAA8B;oDAChC,4BAA4B;2CACrC,mBAAmB"}
+{"version":3,"file":"boot-test-utils.d.ts","sourceRoot":"","sources":["boot-test-utils.js"],"names":[],"mappings":";;;;;;;;;;;AAkCO,6BAAqB;AAE5B,qBAAqB;AACrB,yBADW,MAAM,CACgB;AAE1B;;;;;;;iBAGmB,GAAG;iBACH,GAAG;eAGL,GAAG;gBACF,GAAG;;;eAIJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BvB;AAEG;;;EAoEN;AAEM,iDAON;mDAlJkD,2BAA2B;4CAClC,oBAAoB;6CACnB,qBAAqB;2CACvB,mBAAmB;6CACjB,qBAAqB;+CACnB,uBAAuB;sDAChB,8BAA8B;oDAChC,4BAA4B;2CACrC,mBAAmB"}

package/tools/boot-test-utils.js

@@ -1,9 +1,12 @@
+import { Fail } from '@endo/errors';
+import { E } from '@endo/far';
+import { Far } from '@endo/marshal';
+
 import {
   makeFakeVatAdmin,
   zcfBundleCap,
 } from '@agoric/zoe/tools/fakeVatAdmin.js';
 import { buildZoeManualTimer } from '@agoric/zoe/tools/manualTimer.js';
-import { Far } from '@endo/marshal';
 import { makeScalarBigMapStore } from '@agoric/vat-data';
 import { bundles, devices } from '../test/devices.js';
 
@@ -17,8 +20,6 @@ import { buildRootObject as priceAuthorityRoot } from '../src/vat-priceAuthority
 import { buildRootObject as provisioningRoot } from '../src/vat-provisioning.js';
 import { buildRootObject as zoeRoot } from '../src/vat-zoe.js';
 
-const { Fail } = assert;
-
 export const vatRoots = {
   agoricNames: agoricNamesRoot,
   bank: bankRoot,
@@ -126,7 +127,8 @@ export const makePopulatedFakeVatAdmin = () => {
     const baggage = makeScalarBigMapStore('baggage');
     const adminNode =
       /** @type {import('@agoric/swingset-vat').VatAdminFacet} */ ({});
-    return { root: buildRoot({}, vatParameters, baggage), adminNode };
+    const rootP = buildRoot({}, vatParameters, baggage);
+    return E.when(rootP, root => harden({ root, adminNode }));
   };
   const createVatByName = async name => {
     return createVat(fakeNameToCap.get(name) || Fail`unknown vat ${name}`);

package/tools/fake-bridge.d.ts

@@ -5,6 +5,16 @@ export function makeFakeBankBridge(zone: import("@agoric/zone").Zone, opts?: {
 }): ScopedBridgeManager<"bank">;
 export function makeFakeIbcBridge(zone: import("@agoric/zone").Zone, onToBridge: (obj: any) => void): ScopedBridgeManager<"dibc">;
 export const LOCALCHAIN_DEFAULT_ADDRESS: "agoric1fakeLCAAddress";
+export namespace SIMULATED_ERRORS {
+    let TIMEOUT: bigint;
+    let BAD_REQUEST: bigint;
+}
+export function fakeLocalChainBridgeTxMsgHandler(message: object, sequence: number): unknown;
+export const LOCALCHAIN_QUERY_ALL_BALANCES_RESPONSE: {
+    value: bigint;
+    denom: string;
+}[];
+export function fakeLocalChainBridgeQueryHandler(message: object): unknown;
 export function makeFakeLocalchainBridge(zone: import("@agoric/zone").Zone, onToBridge?: ((obj: any) => void) | undefined): ScopedBridgeManager<"vlocalchain">;
 export function makeFakeTransferBridge(zone: import("@agoric/zone").Zone, onToBridge?: ((obj: any) => void) | undefined): ScopedBridgeManager<"vtransfer">;
 export type Balances = {

package/tools/fake-bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fake-bridge.d.ts","sourceRoot":"","sources":["fake-bridge.js"],"names":[],"mappings":"AAiBA,6EAA6E;AAE7E,sCAAuC;AAchC,yCANI,OAAO,cAAc,EAAE,IAAI,SAEnC;IAAuB,QAAQ,EAAvB,QAAQ;CAChB,GAAU,oBAAoB,MAAM,CAAC,CAwFvC;AAOM,wCAJI,OAAO,cAAc,EAAE,IAAI,cAC3B,CAAC,GAAG,KAAA,KAAK,IAAI,GACX,oBAAoB,MAAM,CAAC,CA8BvC;AAED,iEAAkE;AAO3D,+CAJI,OAAO,cAAc,EAAE,IAAI,8BAClB,IAAI,gBACX,oBAAoB,aAAa,CAAC,CAgE9C;AAOM,6CAJI,OAAO,cAAc,EAAE,IAAI,8BAClB,IAAI,gBACX,oBAAoB,WAAW,CAAC,CAuC5C;uBA3Pa;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;CAAE;yCAPX,iBAAiB"}
+{"version":3,"file":"fake-bridge.d.ts","sourceRoot":"","sources":["fake-bridge.js"],"names":[],"mappings":"AAkBA,6EAA6E;AAE7E,sCAAuC;AAchC,yCANI,OAAO,cAAc,EAAE,IAAI,SAEnC;IAAuB,QAAQ,EAAvB,QAAQ;CAChB,GAAU,oBAAoB,MAAM,CAAC,CA0FvC;AAOM,wCAJI,OAAO,cAAc,EAAE,IAAI,cAC3B,CAAC,GAAG,KAAA,KAAK,IAAI,GACX,oBAAoB,MAAM,CAAC,CAwCvC;AAED,iEAAkE;;;;;AAwB3D,0DALI,MAAM,YACN,MAAM,GACJ,OAAO,CAsCnB;AAED;;;IASE;AAWK,0DAHI,MAAM,GACJ,OAAO,CAsCnB;AAOM,+CAJI,OAAO,cAAc,EAAE,IAAI,8BAClB,IAAI,gBACX,oBAAoB,aAAa,CAAC,CAgD9C;AAOM,6CAJI,OAAO,cAAc,EAAE,IAAI,8BAClB,IAAI,gBACX,oBAAoB,WAAW,CAAC,CAuC5C;uBA5Wa;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;CAAE;yCAPX,iBAAiB"}

package/tools/fake-bridge.js

@@ -1,5 +1,5 @@
 // @ts-check
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 import { makeTracer, VBankAccount } from '@agoric/internal';
 import { E } from '@endo/far';
 import { makeWhen } from '@agoric/vow/src/when.js';
@@ -8,6 +8,7 @@ import { Nat } from '@endo/nat';
 /**
  * @import {JsonSafe} from '@agoric/cosmic-proto';
  * @import {MsgDelegateResponse, MsgUndelegateResponse} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js';
+ * @import {MsgSendResponse} from '@agoric/cosmic-proto/cosmos/bank/v1beta1/tx.js';
  * @import {BridgeHandler, ScopedBridgeManager} from '../src/types.js';
  * @import {Remote} from '@agoric/vow';
  */
@@ -71,6 +72,8 @@ export const makeFakeBankBridge = (zone, opts = { balances: {} }) => {
         case 'VBANK_GIVE': {
           const { amount, denom } = obj;
           const address = type === 'VBANK_GRAB' ? obj.sender : obj.recipient;
+          (address && typeof address === 'string') ||
+            Fail`invalid address ${address}`;
           balances[address] ||= {};
           balances[address][denom] ||= 0n;
 
@@ -135,6 +138,16 @@ export const makeFakeIbcBridge = (zone, onToBridge) => {
       if (method === 'sendPacket') {
         const { packet } = params;
         return { ...packet, sequence: '39' };
+      } else if (method === 'startChannelCloseInit') {
+        const { packet } = params;
+        if (hndlr)
+          E(hndlr)
+            .fromBridge({
+              type: 'IBC_EVENT',
+              event: 'channelCloseConfirm',
+              packet,
+            })
+            .catch(e => console.error(e));
       }
       return undefined;
     },
@@ -155,6 +168,123 @@ export const makeFakeIbcBridge = (zone, onToBridge) => {
 
 export const LOCALCHAIN_DEFAULT_ADDRESS = 'agoric1fakeLCAAddress';
 
+/**
+ * Constants that can be used to force an error state in a bridge transaction.
+ * Typically used for the LocalChainBridge which currently accepts all messages
+ * unless specified otherwise. Less useful for the DibcBridge which rejects all
+ * messages unless specified otherwise.
+ */
+export const SIMULATED_ERRORS = {
+  TIMEOUT: 504n,
+  BAD_REQUEST: 400n,
+};
+
+/**
+ * Used to mock responses from Cosmos Golang back to SwingSet for for
+ * E(lca).executeTx().
+ *
+ * Returns an empty object per message unless specified.
+ *
+ * @param {object} message
+ * @param {number} sequence
+ * @returns {unknown}
+ * @throws {Error} to simulate failures in certain cases
+ */
+export const fakeLocalChainBridgeTxMsgHandler = (message, sequence) => {
+  switch (message['@type']) {
+    // TODO #9402 reference bank to ensure caller has tokens they are transferring
+    case '/ibc.applications.transfer.v1.MsgTransfer': {
+      if (message.token.amount === String(SIMULATED_ERRORS.TIMEOUT)) {
+        throw Error('simulated unexpected MsgTransfer packet timeout');
+      }
+      // like `JsonSafe<MsgTransferResponse>`, but bigints are converted to numbers
+      // FIXME should vlocalchain return a string instead of number for bigint?
+      return {
+        sequence,
+      };
+    }
+    case '/cosmos.bank.v1beta1.MsgSend': {
+      if (message.amount[0].amount === String(SIMULATED_ERRORS.BAD_REQUEST)) {
+        throw Error('simulated error');
+      }
+      return /** @type {JsonSafe<MsgSendResponse>} */ ({});
+    }
+    case '/cosmos.staking.v1beta1.MsgDelegate': {
+      if (message.amount.amount === String(SIMULATED_ERRORS.TIMEOUT)) {
+        throw Error('simulated packet timeout');
+      }
+      return /** @type {JsonSafe<MsgDelegateResponse>} */ ({});
+    }
+    case '/cosmos.staking.v1beta1.MsgUndelegate': {
+      return /** @type {JsonSafe<MsgUndelegateResponse>} */ ({
+        // 5 seconds from unix epoch
+        completionTime: { seconds: 5n, nanos: 0 },
+      });
+    }
+    // returns one empty object per message unless specified
+    default:
+      return {};
+  }
+};
+
+export const LOCALCHAIN_QUERY_ALL_BALANCES_RESPONSE = [
+  {
+    value: 10n,
+    denom: 'ubld',
+  },
+  {
+    value: 10n,
+    denom: 'uist',
+  },
+];
+
+/**
+ * Used to mock responses from Cosmos Golang back to SwingSet for for
+ * E(lca).query() and E(lca).queryMany().
+ *
+ * Returns an empty object per query message unless specified.
+ *
+ * @param {object} message
+ * @returns {unknown}
+ */
+export const fakeLocalChainBridgeQueryHandler = message => {
+  switch (message['@type']) {
+    case '/cosmos.bank.v1beta1.QueryAllBalancesRequest': {
+      return {
+        error: '',
+        height: '1',
+        reply: {
+          '@type': '/cosmos.bank.v1beta1.QueryAllBalancesResponse',
+          balances: LOCALCHAIN_QUERY_ALL_BALANCES_RESPONSE.map(x => ({
+            denom: x.denom,
+            amount: String(x.value),
+          })),
+          pagination: { nextKey: null, total: '2' },
+        },
+      };
+    }
+    case '/cosmos.bank.v1beta1.QueryBalanceRequest': {
+      return {
+        error: '',
+        height: '1',
+        reply: {
+          '@type': '/cosmos.bank.v1beta1.QueryBalanceResponse',
+          balance: {
+            denom: message.denom,
+            // return 10 for all denoms, somewhat arbitrarily.
+            // if a denom is not known to cosmos bank, we'd expect to see
+            // `{denom, amount: '0'}` returned
+            amount: '10',
+          },
+        },
+      };
+    }
+    // returns one empty object per message unless specified
+    default:
+      return {};
+  }
+};
+
 /**
  * @param {import('@agoric/zone').Zone} zone
  * @param {(obj) => void} [onToBridge]
@@ -164,6 +294,7 @@ export const makeFakeLocalchainBridge = (zone, onToBridge = () => {}) => {
   /** @type {Remote<BridgeHandler>} */
   let hndlr;
   let lcaExecuteTxSequence = 0;
+  let accountsCreated = 0;
   return zone.exo('Fake Localchain Bridge Manager', undefined, {
     getBridgeId: () => 'vlocalchain',
     toBridge: async obj => {
@@ -171,38 +302,21 @@ export const makeFakeLocalchainBridge = (zone, onToBridge = () => {}) => {
       const { method, type, ...params } = obj;
       trace('toBridge', type, method, params);
       switch (type) {
-        case 'VLOCALCHAIN_ALLOCATE_ADDRESS':
-          return LOCALCHAIN_DEFAULT_ADDRESS;
+        case 'VLOCALCHAIN_ALLOCATE_ADDRESS': {
+          const address = `${LOCALCHAIN_DEFAULT_ADDRESS}${accountsCreated || ''}`;
+          accountsCreated += 1;
+          return address;
+        }
         case 'VLOCALCHAIN_EXECUTE_TX': {
           lcaExecuteTxSequence += 1;
-          return obj.messages.map(message => {
-            switch (message['@type']) {
-              // TODO #9402 reference bank to ensure caller has tokens they are transferring
-              case '/ibc.applications.transfer.v1.MsgTransfer': {
-                if (message.token.amount === '504') {
-                  throw Error(
-                    'simulated unexpected MsgTransfer packet timeout',
-                  );
-                }
-                // like `JsonSafe<MsgTransferResponse>`, but bigints are converted to numbers
-                // XXX should vlocalchain return a string instead of number for bigint?
-                return {
-                  sequence: lcaExecuteTxSequence,
-                };
-              }
-              case '/cosmos.staking.v1beta1.MsgDelegate': {
-                return /** @type {JsonSafe<MsgDelegateResponse>} */ ({});
-              }
-              case '/cosmos.staking.v1beta1.MsgUndelegate': {
-                return /** @type {JsonSafe<MsgUndelegateResponse>} */ ({
-                  completionTime: new Date().toJSON(),
-                });
-              }
-              // returns one empty object per message unless specified
-              default:
-                return {};
-            }
-          });
+          return obj.messages.map(message =>
+            fakeLocalChainBridgeTxMsgHandler(message, lcaExecuteTxSequence),
+          );
+        }
+        case 'VLOCALCHAIN_QUERY_MANY': {
+          return obj.messages.map(message =>
+            fakeLocalChainBridgeQueryHandler(message),
+          );
         }
         default:
           Fail`unknown type ${type}`;