@agoric/vats 0.15.2-dev-de2008a.0 → 0.15.2-dev-9d7a377.0

package/src/ibc.d.ts

@@ -1,24 +1,24 @@
 export function prepareIBCConnectionHandler(zone: Zone): (args_0: {
     protocolUtils: any;
-    channelKeyToConnP: MapStore<string, import('@agoric/vow').Remote<Connection>>;
-    channelKeyToSeqAck: MapStore<string, MapStore<number, import('@agoric/vow').VowKit<Bytes>>>;
+    channelKeyToConnP: MapStore<string, import("@agoric/vow").Remote<Connection>>;
+    channelKeyToSeqAck: MapStore<string, MapStore<number, import("@agoric/vow").VowKit<Bytes>>>;
 }, args_1: {
     channelID: `channel-${number}`;
     portID: string;
     rChannelID: `channel-${number}`;
     rPortID: string;
-    order: 'ORDERED' | 'UNORDERED';
+    order: "ORDERED" | "UNORDERED";
 }) => import("@endo/exo").Guarded<{
     /** @type {Required<ConnectionHandler>['onOpen']} */
-    onOpen(connection: Remote<Connection>, localAddr: string, remoteAddr: string, c: Remote<ConnectionHandler>): PromiseVow<void>;
+    onOpen(connection: Remote<Connection>, localAddr: Endpoint, remoteAddr: Endpoint, c: Remote<ConnectionHandler>): PromiseVow<void>;
     /** @type {Required<ConnectionHandler>['onReceive']} */
-    onReceive(connection: Remote<Connection>, ack: string, c: Remote<ConnectionHandler>, opts?: Record<string, any> | undefined): PromiseVow<string>;
+    onReceive(connection: Remote<Connection>, ack: Bytes, c: Remote<ConnectionHandler>, opts?: Record<string, any>): PromiseVow<string>;
     /** @type {Required<ConnectionHandler>['onClose']} */
-    onClose(connection: Remote<Connection>, reason?: any, c?: Remote<ConnectionHandler> | undefined): PromiseVow<void>;
+    onClose(connection: Remote<Connection>, reason?: CloseReason, c?: Remote<ConnectionHandler>): PromiseVow<void>;
 }>;
 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>;
-    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1, any> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
+    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow/src/types.js").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(specimenP: import("@agoric/vow/src/types.js").ERef<T_1 | import("@agoric/vow/src/types.js").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1, any> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
     makeVowKit: <T_2>() => VowKit<T_2>;
     allVows: (vows: any) => import("@agoric/vow").Vow<any>;
 }): (ibcdev: {
@@ -31,19 +31,19 @@ export function prepareIBCProtocol(zone: Zone, powers: {
         /** @type {Required<ProtocolHandler>['onCreate']} */
         onCreate(protocol: Remote<ProtocolImpl>, p: Remote<ProtocolHandler>): PromiseVow<void>;
         /** @type {Required<ProtocolHandler>['onInstantiate']} */
-        onInstantiate(port: Remote<Port>, localAddr: string, remote: string, p: Remote<ProtocolHandler>): PromiseVow<string>;
+        onInstantiate(port: Remote<Port>, localAddr: Endpoint, remote: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<string>;
         /** @type {Required<ProtocolHandler>['generatePortID']} */
-        generatePortID(localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<string>;
+        generatePortID(localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<string>;
         /** @type {Required<ProtocolHandler>['onBind']} */
-        onBind(port: Remote<Port>, localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<void>;
+        onBind(port: Remote<Port>, localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<void>;
         /** @type {Required<ProtocolHandler>['onConnect']} */
-        onConnect(port: Remote<Port>, localAddr: string, remote: string, c: Remote<ConnectionHandler>, p: Remote<ProtocolHandler>): PromiseVow<AttemptDescription>;
+        onConnect(port: Remote<Port>, localAddr: Endpoint, remote: Endpoint, c: Remote<ConnectionHandler>, p: Remote<ProtocolHandler>): PromiseVow<AttemptDescription>;
         /** @type {Required<ProtocolHandler>['onListen']} */
-        onListen(port: Remote<Port>, localAddr: string, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
+        onListen(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
         /** @type {Required<ProtocolHandler>['onListenRemove']} */
-        onListenRemove(port: Remote<Port>, localAddr: string, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
+        onListenRemove(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
         /** @type {Required<ProtocolHandler>['onRevoke']} */
-        onRevoke(port: Remote<Port>, localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<void>;
+        onRevoke(port: Remote<Port>, localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<void>;
     }>;
     bridgeHandler: import("@endo/exo").Guarded<{
         /** @param {IBCEvent<IBCBridgeEvent>} obj */
@@ -69,7 +69,6 @@ export type Outbound = Omit<ConnectingInfo, "counterparty" | "channelID" | "coun
     };
 };
 import type { Zone } from '@agoric/base-zone';
-import type { Remote } from '@agoric/vow';
 import type { VowKit } from '@agoric/vow';
 import type { BridgeHandler } from './types.js';
 import type { IBCBridgeEvent } from './types.js';

package/src/ibc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AA6CO;mBAciB,GAAG;uBACC,QAAQ,CAC/B,MAAY,EACZ,OAAa,aAAa,EAAE,MAAM,CAAC,UAAU,CAAC,CACzC;wBACmB,QAAQ,CAChC,MAAY,EACZ,QAAc,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CACtD;;;YAIO,MAAM;;aAEL,MAAM;WACR,SAAS,GAAG,WAAW;;IAuBjC,oDAAoD;;IAepD,uDAAuD;;IAoBvD,qDAAqD;;GA0B1D;AAMM;;;;;;cAOS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;;qBAOpC,eAAe;;;;QAoDjC,oDAAoD;;QAKpD,yDAAyD;;QAKzD,0DAA0D;;QAK1D,kDAAkD;;QAalD,qDAAqD;;QAiDrD,oDAAoD;;QAIpD,0DAA0D;;QAI1D,oDAAoD;;;;QAgBpD,4CAA4C;;;EAudnD;AAIM;IAOD;;;OAGG;qBAFQ,MAAM,OACN,GAAG;GAYnB;;;;;;eArxBe,QAAQ;gBACP,UAAU;kBACR;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;;0BAbf,mBAAmB;4BACc,aAAa;4BAAb,aAAa;mCAFqI,YAAY;oCAAZ,YAAY;8BAAZ,YAAY;yCAAZ,YAAY;iCAE9J,aAAa;oCAFqI,YAAY"}
+{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AA6CO;mBAciB,GAAG;uBACC,QAAQ,CAC/B,MAAY,EACZ,OAAa,aAAa,EAAE,MAAM,CAAC,UAAU,CAAC,CACzC;wBACmB,QAAQ,CAChC,MAAY,EACZ,QAAc,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CACtD;;;YAIO,MAAM;;aAEL,MAAM;WACR,SAAS,GAAG,WAAW;;IAuBjC,oDAAoD;uBAQhD,OAAC,UACX,CAAC,aAAiB,QACb,cACO,QAAS,KAAS,OAAQ,iBAErC,CAAC;IAEI,uDAAuD;0BAAb,OAAQ,UACpD,CAAC,OAAW,KAAM,KACd,OACA,iBAAU,CAAC,SACR,mBACE;IAeP,qDAAqD;wBAZnD,OAAQ,UAAS,CAAC,WAAe,WAClC,MAAU,OAAQ,iBAAiB,CAAC;GAqC1C;AAMM;uFApJN,CAAC,yBAAgD,OAAQ,0BAAY,EAAE,MAAM,CAI9E,CAHA,CACA;uFAyH8B,OACtB,0BACP,EAAO,IAAD,CAAC,GAAC,GAAE,OAAQ,0BAAY,EAAE,GAAG,CAAC,GAAC,CAAC,CAAC;;;;cA8BxB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;;qBAOpC,eAAe;;;;QAoDjC,oDAAoD;2BAhGlD,OAAQ,YAAY,CAAC,KAAK,OAAO,eACnC,CAAC;QAoGD,yDAAyD;4BApEpC,OAAQ,IAAI,CAAC,aAAiB,QAAS,UAG/D,QAAS,KAAS,OAAQ,eAClB,CAAC;QAqEN,0DAA0D;kCAtGxD,QAAG,KAAI,OAAQ,eAChB,CAAC;QA0GF,kDAAkD;qBAtGlD,OAAA,IACR,CAAC,aAAiB,QAAS,KAAS,OAAQ,eAC1C,CAAC;QAiHK,qDAAqD;wBAjF1D,OACA,IAAE,CAAC,aAAiB,QAAS,UAC7B,QAAS,KAAS,OAAQ,iBACtB,CAAC,KACA,OACD,eAAY,CAAC;QA6HZ,oDAAoD;uBAhKxB,OAAQ,IAAI,CAAC,aAEzC,QAAK,iBAAqB,OAAQ,aACrC,CAAC,KAAS,OAAQ,eAAe,CAAC;QAiK/B,0DAA0D;6BA1JhE,OAAO,IAAI,CAAC,aAAiB,QAG9B,iBACiB,OACd,aAAa,CAAC,KACjB,OACE,eAAe,CAAC;QAuJX,oDAAoD;uBAjI3B,OAE7B,IACF,CAAC,aAAiB,QAAS,KAAS,OAAQ,eAAe,CAAC;;;QA8ItD,4CAA4C;;;EAudnD;AAIM;IAOD;;;OAGG;qBAFQ,MAAM,OACN,GAAG;GAYnB;;;;;;eArxBe,QAAQ;gBACP,UAAU;kBACR;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;;0BAbf,mBAAmB;4BACc,aAAa;mCAFqI,YAAY;oCAAZ,YAAY;8BAAZ,YAAY;yCAAZ,YAAY;iCAE9J,aAAa;oCAFqI,YAAY"}

package/src/lib-board.d.ts

@@ -1,7 +1,7 @@
 /** @import {Key} from '@endo/patterns') */
 export const DEFAULT_CRC_DIGITS: 2;
 export const DEFAULT_PREFIX: "board0";
-export function prepareBoardKit(baggage: import('@agoric/vat-data').Baggage): (initSequence?: number | bigint | undefined, args_1?: {
+export function prepareBoardKit(baggage: import("@agoric/vat-data").Baggage): (initSequence?: number | bigint | undefined, args_1?: {
     prefix?: string | undefined;
     crcDigits?: number | undefined;
 } | undefined) => import("@endo/exo").GuardedKit<{
@@ -78,7 +78,7 @@ export function prepareBoardKit(baggage: import('@agoric/vat-data').Baggage): (i
         unserialize(data: any): any;
     };
 }>;
-export function prepareRecorderFactory(zone: import('@agoric/zone').Zone): (label: string, marshaller: Marshaller) => <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
+export function prepareRecorderFactory(zone: import("@agoric/zone").Zone): (label: string, marshaller: Marshaller) => <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
 /**
  * For a value with a known id in the board, we can use that board id as a slot
  * to preserve identity when marshaling.

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

@@ -1 +1 @@
-{"version":3,"file":"lib-board.d.ts","sourceRoot":"","sources":["lib-board.js"],"names":[],"mappings":"AAiBA,2CAA2C;AAE3C,mCAAoC;AACpC,sCAAuC;AAmOhC,yCAHI,OAAO,kBAAkB,EAAE,OAAO;;;;;QAWrC;;;;;;;;;;;;;WAaG;;QAIH;;;WAGG;qBAFQ,OAAO;QAMlB;;;;;;;;;WASG;wBADW,MAAM;QAgBpB,uBAAuB;;;QASvB;;;WAGG;;;;;;;QAIH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;GAuCV;AAGM,6CADK,OAAO,cAAc,EAAE,IAAI,WAS1B,MAAM,cACN,UAAU,oXAYtB;;;;;;;;;;sBA3UY,MAAM;;;;;yBAmBN,UAAU,CAAC,OAAO,qBAAqB,CAAC;AADrD;;;;;;GAMG;AAGH;;;;;;;;GAQG;AACH;;;;;;;;;EA0BC"}
+{"version":3,"file":"lib-board.d.ts","sourceRoot":"","sources":["lib-board.js"],"names":[],"mappings":"AAiBA,2CAA2C;AAE3C,mCAAoC;AACpC,sCAAuC;AAmOhC,yCAHI,OAAO,kBAAkB,EAAE,OAAO;;;;;QAWrC;;;;;;;;;;;;;WAaG;;QAIH;;;WAGG;qBAFQ,OAAO;QAMlB;;;;;;;;;WASG;wBADW,MAAM;QAgBpB,uBAAuB;;;QASvB;;;WAGG;;;;;;;QAIH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;GAuCV;AAGM,6CADK,OAAO,cAAc,EAAE,IAAI,WAS1B,MAAM,cACN,UAAU,sBA1NqB,WAAW,GAAG,QAAQ,OAC7D,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,0KAqOrC;;;;;;;;;;sBA3UY,MAAM;;;;;yBAmBN,UAAU,CAAC,OAAO,qBAAqB,CAAC;AADrD;;;;;;GAMG;AAGH;;;;;;;;GAQG;AACH;;;;;;;;;EA0BC"}

package/src/localchain.d.ts

@@ -16,7 +16,7 @@ export const LocalChainI: import("@endo/patterns").InterfaceGuard<{
 export const LocalChainAdminI: import("@endo/patterns").InterfaceGuard<{
     setPower: import("@endo/patterns").MethodGuard;
 }>;
-export function prepareLocalChainTools(zone: import('@agoric/base-zone').Zone): {
+export function prepareLocalChainTools(zone: import("@agoric/base-zone").Zone): {
     makeLocalChain: (initialPowers?: Partial<LocalChainPowers> | undefined) => import("@endo/exo").GuardedKit<{
         admin: {
             /**
@@ -47,7 +47,7 @@ export function prepareLocalChainTools(zone: import('@agoric/base-zone').Zone):
                  * @param {import('@agoric/cosmic-proto').TypedJson<unknown>[]} messages
                  * @returns {Promise<import('@agoric/cosmic-proto').TypedJson[]>}
                  */
-                executeTx(messages: import('@agoric/cosmic-proto').TypedJson<unknown>[]): Promise<import('@agoric/cosmic-proto').TypedJson[]>;
+                executeTx(messages: import("@agoric/cosmic-proto").TypedJson<unknown>[]): Promise<import("@agoric/cosmic-proto").TypedJson[]>;
             }>>;
             /**
              * Make a single query to the local chain. Will reject with an error if
@@ -57,7 +57,7 @@ export function prepareLocalChainTools(zone: import('@agoric/base-zone').Zone):
              * @param {import('@agoric/cosmic-proto').TypedJson} request
              * @returns {Promise<import('@agoric/cosmic-proto').TypedJson>}
              */
-            query(request: import('@agoric/cosmic-proto').TypedJson): Promise<import('@agoric/cosmic-proto').TypedJson>;
+            query(request: import("@agoric/cosmic-proto").TypedJson): Promise<import("@agoric/cosmic-proto").TypedJson>;
             /**
              * Send a batch of query requests to the local chain. Unless there is a
              * system error, will return all results to indicate their success or
@@ -71,24 +71,24 @@ export function prepareLocalChainTools(zone: import('@agoric/base-zone').Zone):
              *   }[]
              * >}
              */
-            queryMany(requests: import('@agoric/cosmic-proto').TypedJson[]): Promise<{
+            queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
                 error?: string;
-                reply: import('@agoric/cosmic-proto').TypedJson;
+                reply: import("@agoric/cosmic-proto").TypedJson;
             }[]>;
         };
     }>;
 };
 export type LocalChainPowers = {
-    system: import('./types.js').ScopedBridgeManager;
-    bankManager: import('./vat-bank.js').BankManager;
+    system: import("./types.js").ScopedBridgeManager;
+    bankManager: import("./vat-bank.js").BankManager;
 };
 export type PowerStore = MapStore<keyof LocalChainPowers, LocalChainPowers[keyof LocalChainPowers]>;
 export type LocalChainAccount = Awaited<ReturnType<Awaited<ReturnType<typeof prepareLocalChainAccount>>>>;
 export type LocalChainTools = ReturnType<typeof prepareLocalChainTools>;
-export type LocalChainKit = ReturnType<LocalChainTools['makeLocalChain']>;
-export type LocalChain = LocalChainKit['public'];
+export type LocalChainKit = ReturnType<LocalChainTools["makeLocalChain"]>;
+export type LocalChain = LocalChainKit["public"];
 /** @param {import('@agoric/base-zone').Zone} zone */
-declare function prepareLocalChainAccount(zone: import('@agoric/base-zone').Zone): (address: string, powers: PowerStore) => import("@endo/exo").Guarded<{
+declare function prepareLocalChainAccount(zone: import("@agoric/base-zone").Zone): (address: string, powers: PowerStore) => import("@endo/exo").Guarded<{
     getAddress(): Promise<string>;
     /**
      * Deposit a payment into the bank purse that matches the alleged brand.
@@ -102,7 +102,7 @@ declare function prepareLocalChainAccount(zone: import('@agoric/base-zone').Zone
      * @param {import('@agoric/cosmic-proto').TypedJson<unknown>[]} messages
      * @returns {Promise<import('@agoric/cosmic-proto').TypedJson[]>}
      */
-    executeTx(messages: import('@agoric/cosmic-proto').TypedJson<unknown>[]): Promise<import('@agoric/cosmic-proto').TypedJson[]>;
+    executeTx(messages: import("@agoric/cosmic-proto").TypedJson<unknown>[]): Promise<import("@agoric/cosmic-proto").TypedJson[]>;
 }>;
 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":"AA6BA;;;;GAMG;AAuDH;;;;GAIG;AAEH;;;;GAIG;AAEH;;GAEG;AAsGI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;YA9EpC;;;;eAIG;qBAFQ,CAAC;;;YAkBZ;;;;;eAKG;;;gBApGL;;;;;;mBAMG;iCADQ,OAAO;gBAYlB;;;mBAGG;oCAFQ,OAAO,sBAAsB,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,GACjD,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,EAAE,CAAC;;YA0F9D;;;;;;;eAOG;2BAFQ,OAAO,sBAAsB,EAAE,SAAS,GACtC,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,CAAC;YAa9D;;;;;;;;;;;;eAYG;gCAPQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,GACxC,OAAO,CACnB;gBACA,KAAW,CAAC,EAAE,MAAM,CAAC;gBACrB,KAAW,EAAE,OAAO,sBAAsB,EAAE,SAAS,CAAC;aACjD,EAAE,CACJ;;;EAoBX;+BA3MY;IACZ,MAAU,EAAE,OAAO,YAAY,EAAE,mBAAmB,CAAC;IACrD,WAAe,EAAE,OAAO,eAAe,EAAE,WAAW,CAAC;CAClD;yBAES,QAAQ,CACpB,MAAU,gBAAgB,EAC1B,gBAAoB,CAAC,MAAM,gBAAgB,CAAC,CACzC;gCA2ES,OAAO,CACnB,UAAc,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CACjE;8BAyHU,UAAU,CAAC,OAAO,sBAAsB,CAAC;4BACzC,UAAU,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;yBAC7C,aAAa,CAAC,QAAQ,CAAC;AAnLrC,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC;;;;;;OAMG;qBADQ,OAAO;IAYlB;;;OAGG;wBAFQ,OAAO,sBAAsB,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,GACjD,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,EAAE,CAAC;GAkBnE"}
+{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AA6BA;;;;GAMG;AAuDH;;;;GAIG;AAEH;;;;GAIG;AAEH;;GAEG;AAsGI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;YA9EpC;;;;eAIG;qBAFQ,CAAC,uCAAD,CAAC;;;YAkBZ;;;;;eAKG;;;gBApGL;;;;;;mBAMG;iCADQ,OAAO;gBAYlB;;;mBAGG;oCAFQ,OAAO,sBAAsB,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,GACjD,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,EAAE,CAAC;;YA0F9D;;;;;;;eAOG;2BAFQ,OAAO,sBAAsB,EAAE,SAAS,GACtC,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,CAAC;YAa9D;;;;;;;;;;;;eAYG;gCAPQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,GACxC,OAAO,CACnB;gBACA,KAAW,CAAC,EAAE,MAAM,CAAC;gBACrB,KAAW,EAAE,OAAO,sBAAsB,EAAE,SAAS,CAAC;aACjD,EAAE,CACJ;;;EAoBX;+BA3MY;IACZ,MAAU,EAAE,OAAO,YAAY,EAAE,mBAAmB,CAAC;IACrD,WAAe,EAAE,OAAO,eAAe,EAAE,WAAW,CAAC;CAClD;yBAES,QAAQ,CACpB,MAAU,gBAAgB,EAC1B,gBAAoB,CAAC,MAAM,gBAAgB,CAAC,CACzC;gCA2ES,OAAO,CACnB,UAAc,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CACjE;8BAyHU,UAAU,CAAC,OAAO,sBAAsB,CAAC;4BACzC,UAAU,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;yBAC7C,aAAa,CAAC,QAAQ,CAAC;AAnLrC,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC;;;;;;OAMG;qBADQ,OAAO;IAYlB;;;OAGG;wBAFQ,OAAO,sBAAsB,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,GACjD,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,EAAE,CAAC;GAkBnE"}

package/src/mintHolder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mintHolder.d.ts","sourceRoot":"","sources":["mintHolder.js"],"names":[],"mappings":"AA2BA,2BAA2B;AAC3B,mBADW,YAAY,CAGrB;AAYK,sBAJmB,CAAC,sEAChB,SAAS;;;EAUnB;;;;uBArCe,CAAC,iCAFJ;IACZ,OAAW,EAAE,MAAM,CAAC;IACpB,SAAa,EAAE,CAAC,CAAC;IACjB,WAAe,EAAE,WAAW,CAAC;CAC1B;6BAVuB,kBAAkB"}
+{"version":3,"file":"mintHolder.d.ts","sourceRoot":"","sources":["mintHolder.js"],"names":[],"mappings":"AA2BA,2BAA2B;AAC3B,mBADW,YAAY,CAGrB;AAYK,sBAJmB,CAAC,oCAAhB,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,gBAClB,SAAS;;;EAUnB;;;;uBArCe,CAAC,iCAFJ;IACZ,OAAW,EAAE,MAAM,CAAC;IACpB,SAAa,EAAE,CAAC,CAAC;IACjB,WAAe,EAAE,WAAW,CAAC;CAC1B;6BAVuB,kBAAkB"}

package/src/nameHub.d.ts

@@ -18,15 +18,15 @@ export namespace NameHubIKit {
         readonly: import("@endo/patterns").MethodGuard;
     }>;
 }
-export function prepareMixinMyAddress(zone: import('@agoric/zone').Zone): (nameAdmin: import('./types.js').NameAdmin, address: string) => import("@endo/exo").Farable<import("./types.js").MyAddressNameAdmin>;
-export function prepareNameHubKit(zone: import('@agoric/zone').Zone): () => import('./types.js').NameHubKit;
+export function prepareMixinMyAddress(zone: import("@agoric/zone").Zone): (nameAdmin: import("./types.js").NameAdmin, address: string) => import("@endo/exo").Farable<import("./types.js").MyAddressNameAdmin>;
+export function prepareNameHubKit(zone: import("@agoric/zone").Zone): () => import("./types.js").NameHubKit;
 /**
  * Make two facets of a node in a name hierarchy: the nameHub is read access and
  * the nameAdmin is write access.
  *
  * @returns {import('./types.js').NameHubKit}
  */
-export const makeNameHubKit: () => import('./types.js').NameHubKit;
+export const makeNameHubKit: () => import("./types.js").NameHubKit;
 export type NonPrimitive = {
     [key: string]: any;
 };

package/src/priceAuthorityRegistry.d.ts

@@ -1,4 +1,4 @@
-export function providePriceAuthorityRegistry(baggage: import('@agoric/vat-data').Baggage): PriceAuthorityRegistry;
+export function providePriceAuthorityRegistry(baggage: import("@agoric/vat-data").Baggage): PriceAuthorityRegistry;
 export type Deleter = {
     delete: () => void;
 };

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

@@ -1,9 +1,9 @@
 export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, bankManager, }, produce: { localchainVat, localchain, localchainAdmin: localchainAdminP, localchainBridgeManager, }, }: BootstrapPowers & {
     consume: {
         loadCriticalVat: VatLoader<any>;
-        bridgeManager: import('../types').BridgeManager;
-        localchainBridgeManager: import('../types').ScopedBridgeManager;
-        bankManager: Promise<import('../vat-bank.js').BankManager>;
+        bridgeManager: import("../types").BridgeManager;
+        localchainBridgeManager: import("../types").ScopedBridgeManager;
+        bankManager: Promise<import("../vat-bank.js").BankManager>;
     };
     produce: {
         localchain: Producer<any>;
@@ -18,7 +18,7 @@ export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager:
 }): Promise<void>;
 export function addLocalChainToClient({ consume: { client, localchain } }: BootstrapPowers & {
     consume: {
-        localchain: import('../localchain.js').LocalChain;
+        localchain: import("../localchain.js").LocalChain;
     };
 }, _options: object): Promise<void>;
 export function getManifestForLocalChain(_powers: any, { localchainRef }: {
@@ -67,21 +67,15 @@ export type LocalChainVats = {
             public: {
                 createAccount(): Promise<import("@endo/exo").Guarded<{
                     getAddress(): Promise<string>;
-                    deposit(payment: globalThis.Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
-                    executeTx(messages: {
-                        '@type': string;
-                    }[]): Promise<{
+                    deposit(payment: Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
+                    executeTx(messages: import("@agoric/cosmic-proto").TypedJson<unknown>[]): Promise<{
                         '@type': string;
                     }[]>;
                 }>>;
-                query(request: {
-                    '@type': string;
-                }): Promise<{
+                query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
                     '@type': string;
                 }>;
-                queryMany(requests: {
-                    '@type': string;
-                }[]): Promise<{
+                queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
                     error?: string | undefined;
                     reply: {
                         '@type': string;
@@ -97,21 +91,15 @@ export type LocalChainVats = {
             public: {
                 createAccount(): Promise<import("@endo/exo").Guarded<{
                     getAddress(): Promise<string>;
-                    deposit(payment: globalThis.Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
-                    executeTx(messages: {
-                        '@type': string;
-                    }[]): Promise<{
+                    deposit(payment: Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
+                    executeTx(messages: import("@agoric/cosmic-proto").TypedJson<unknown>[]): Promise<{
                         '@type': string;
                     }[]>;
                 }>>;
-                query(request: {
-                    '@type': string;
-                }): Promise<{
+                query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
                     '@type': string;
                 }>;
-                queryMany(requests: {
-                    '@type': string;
-                }[]): Promise<{
+                queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
                     error?: string | undefined;
                     reply: {
                         '@type': string;

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

@@ -1 +1 @@
-{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AA0BO,2QArBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,eAAqB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;QACtC,aAAmB,EAAE,OAAO,UAAU,EAAE,aAAa,CAAC;QACtD,uBAA6B,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC;QACtE,WAAiB,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,WAAW,CAAC,CAAC;KAC5D,CAAC;IACN,OAAW,EAAE;QACb,UAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChC,eAAqB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACrC,aAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACxC,CAAC;CACH;IAEgD,OAAO,EAAhD;QAAE,aAAa,EAAE,YAAY,CAAA;KAAE;kBAoFzC;AAUM,2EAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BL"}
+{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AA0BO,2QArBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,eAAqB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;QACtC,aAAmB,EAAE,OAAO,UAAU,EAAE,aAAa,CAAC;QACtD,uBAA6B,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC;QACtE,WAAiB,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,WAAW,CAAC,CAAC;KAC5D,CAAC;IACN,OAAW,EAAE;QACb,UAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChC,eAAqB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACrC,aAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACxC,CAAC;CACH;IAEgD,OAAO,EAAhD;QAAE,aAAa,EAAE,YAAY,CAAA;KAAE;kBAoFzC;AAUM,2EAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BL;;;;;4FACyK,CAAC;;;;;qCA1F9J,OAAO;wCAWX,OAAO,sBAAsB,EAAE,SACzC,SAAS,EAAE;;;;+BA8Ey8C,OAAO,sBAAsB,EAAE,SAAS;;;oCAAwtB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;;;;;;;;;uEA/ErtE,SACzC;;;;8DA8Em/C,SAAS;;;mEAAuvB,SAAS"}

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

@@ -1,6 +1,6 @@
 export function testLocalChain({ consume: { chainStorage, localchain } }: BootstrapPowers & {
     consume: {
-        localchain: import('../localchain.js').LocalChain;
+        localchain: import("../localchain.js").LocalChain;
     };
 }, { options: { testResultPath } }: {
     options: {

package/src/proposals/namesByAddress-fix-proposal.d.ts

@@ -9,7 +9,7 @@ export function getManifestForProvisioning(_powers: any, { provisioningRef }: {
     provisioningRef: any;
 }): {
     /** @type {import('../core/lib-boot').BootstrapManifest} */
-    manifest: import('../core/lib-boot').BootstrapManifest;
+    manifest: import("../core/lib-boot").BootstrapManifest;
     options: {
         provisioningRef: any;
     };

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

@@ -57,7 +57,7 @@ export function getManifestForNetwork(_powers: any, { networkRef, ibcRef }: {
  * - loopback ports: `E(networkVat).bindPort('/local/')`
  * - an echo port: `E(vats.network).bindPort('/ibc-port/echo')`
  */
-export type VatLoader2 = ((name: 'network') => NetworkVat) & ((name: 'ibc') => IBCVat);
+export type VatLoader2 = ((name: "network") => NetworkVat) & ((name: "ibc") => IBCVat);
 /**
  * Create the network and IBC vats; produce `networkVat` in the core / bootstrap
  * space.

package/src/proposals/restart-vats-proposal.d.ts

@@ -1,4 +1,4 @@
-export function restartVats({ consume }: BootstrapPowers & import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapSpace, { options }: {
+export function restartVats({ consume }: BootstrapPowers & import("@agoric/inter-protocol/src/proposals/econ-behaviors.js").EconomyBootstrapSpace, { options }: {
     options: {
         skip: string[];
     };

package/src/proposals/upgrade-zoe-proposal.d.ts

@@ -29,7 +29,7 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
             noProvisioner: ({ produce: { provisioning } }: BootstrapPowers) => Promise<void>;
             bridgeProvisioner: ({ consume: { provisioning: provisioningP, provisionBridgeManager: provisionBridgeManagerP, provisionWalletBridgeManager: provisionWalletBridgeManagerP, }, }: BootstrapPowers) => Promise<void>;
             setupClientManager: ({ produce: { client, clientCreator: clientCreatorP } }: BootstrapSpace, { template, }?: {
-                template?: Record<string, unknown> | undefined;
+                template?: Record<string, unknown>;
             }) => Promise<void>;
             startTimerService: ({ devices: { timer: timerDevice }, vats: { timer: timerVat }, consume: { client }, produce: { chainTimerService: produceTimer }, brand: { produce: { timer }, }, }: BootstrapPowers) => Promise<void>;
             makeBridgeManager: ({ consume: { loadCriticalVat }, devices: { bridge }, produce: { bridgeManager: bridgeManagerP, provisionBridgeManager, provisionWalletBridgeManager, walletBridgeManager, }, }: BootDevices<ChainDevices> & WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
@@ -62,44 +62,24 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
                     loadCriticalVat: ERef<VatLoader<ChainStorageVat>>;
                 };
             }) => Promise<void>;
-            publishAgoricNamesToChainStorage: ({ consume: { chainStorage: rootP }, namedVat: { consume: { agoricNames, board: vatBoard }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & NamedVatPowers) => Promise<void>;
+            publishAgoricNamesToChainStorage: ({ consume: { chainStorage: rootP }, namedVat: { consume: { agoricNames, board: vatBoard }, }, }: BootstrapPowers & NamedVatPowers) => Promise<void>;
             publishAgoricNames: ({ consume: { agoricNamesAdmin, board, chainStorage: rootP } }: BootstrapPowers, { options: { agoricNamesOptions } }?: {
                 options?: {
                     agoricNamesOptions?: {
-                        topLevel?: string[] | undefined;
-                    } | undefined;
-                } | undefined;
+                        topLevel?: string[];
+                    };
+                };
             }) => Promise<void>;
             connectChainFaucet: ({ consume: { client } }: BootstrapPowers) => Promise<void>;
-            makeVatsFromBundles: ({ vats, devices, consume: { vatStore }, produce: { vatAdminSvc, loadVat, loadCriticalVat }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any) => Promise<void>;
+            makeVatsFromBundles: ({ vats, devices, consume: { vatStore }, produce: { vatAdminSvc, loadVat, loadCriticalVat }, }: BootstrapPowers & {}) => Promise<void>;
             produceDiagnostics: ({ produce }: Pick<ChainBootstrapSpace, "produce">) => Promise<void>;
-            produceStartUpgradable: ({ zone, consume: { diagnostics, zoe }, produce, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & {
-                zone: import("@agoric/base-zone").Zone;
+            produceStartUpgradable: ({ zone, consume: { diagnostics, zoe }, produce, }: BootstrapSpace & {
+                zone: import("@agoric/zone").Zone;
             }) => Promise<void>;
-            produceStartGovernedUpgradable: ({ zone, consume: { chainTimerService, diagnostics, economicCommitteeCreatorFacet, zoe, }, produce, installation: { consume: { contractGovernor }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & {
-                zone: import("@agoric/base-zone").Zone;
+            produceStartGovernedUpgradable: ({ zone, consume: { chainTimerService, diagnostics, economicCommitteeCreatorFacet, zoe, }, produce, installation: { consume: { contractGovernor }, }, }: BootstrapSpace & {
+                zone: import("@agoric/zone").Zone;
                 consume: {
-                    economicCommitteeCreatorFacet: Promise<import("@agoric/governance/src/committee").CommitteeElectorateCreatorFacet>;
+                    economicCommitteeCreatorFacet: import("@agoric/inter-protocol/src/proposals/econ-behaviors.js").EconomyBootstrapPowers["consume"]["economicCommitteeCreatorFacet"];
                 };
             }) => Promise<void>;
             buildZoe: ({ consume: { vatAdminSvc, loadCriticalVat, client }, produce: { zoe, feeMintAccess }, brand: { produce: { Invitation: invitationBrand }, }, issuer: { produce: { Invitation: invitationIssuer }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
@@ -109,7 +89,7 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
                 loadCriticalVat: VatLoader<unknown>;
             }> & any & {
                 consume: {
-                    loadCriticalVat: ERef<VatLoader<import("../core/basic-behaviors").ZoeVat>>;
+                    loadCriticalVat: ERef<VatLoader<import("../core/basic-behaviors.js").ZoeVat>>;
                 };
             }) => Promise<void>;
             startPriceAuthorityRegistry: ({ consume: { loadCriticalVat, client }, produce, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
@@ -119,21 +99,11 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
                 loadCriticalVat: VatLoader<unknown>;
             }> & any & {
                 consume: {
-                    loadCriticalVat: ERef<VatLoader<import("../core/basic-behaviors").PriceAuthorityVat>>;
+                    loadCriticalVat: ERef<VatLoader<import("../core/basic-behaviors.js").PriceAuthorityVat>>;
                 };
             }) => Promise<void>;
-            makeOracleBrands: ({ namedVat: { consume: { agoricNames }, }, oracleBrand: { produce: { USD }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & NamedVatPowers) => Promise<void>;
-            produceBoard: ({ consume: { client }, produce: { board: pBoard }, namedVat: { consume: { board: vatBoard }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
-                vatAdminSvc: VatAdminSvc;
-            }, {}, {
-                loadVat: VatLoader<unknown>;
-                loadCriticalVat: VatLoader<unknown>;
-            }> & any & NamedVatPowers) => Promise<void>;
+            makeOracleBrands: ({ namedVat: { consume: { agoricNames }, }, oracleBrand: { produce: { USD }, }, }: BootstrapPowers & NamedVatPowers) => Promise<void>;
+            produceBoard: ({ consume: { client }, produce: { board: pBoard }, namedVat: { consume: { board: vatBoard }, }, }: BootstrapPowers & NamedVatPowers) => Promise<void>;
             makeBoard: ({ consume: { loadCriticalVat, client }, produce: { board: { resolve: resolveBoard }, }, }: WellKnownSpaces & PromiseSpaceOf<ChainBootstrapSpaceT & {
                 vatAdminSvc: VatAdminSvc;
             }, {}, {
@@ -241,20 +211,20 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
                     comms: CommsVatRoot;
                 };
             }) => Promise<void>;
-            callProperties: (builders: ((...args: any[]) => Record<string, unknown>)[], ...args: unknown[]) => Record<string, unknown>;
-            extract: (template: string | true | Record<string, any>, specimen: unknown, path?: string[] | undefined) => any;
-            extractPowers: (permit: string | true | Record<string, any>, allPowers: unknown) => any;
+            callProperties: (builders: ((...args: any) => Record<string, unknown>)[], ...args: unknown[]) => Record<string, unknown>;
+            extract: (template: true | string | Record<string, any>, specimen: unknown, path?: string[] | undefined) => any;
+            extractPowers: (permit: true | string | Record<string, any>, allPowers: unknown) => any;
             runModuleBehaviors: ({ allPowers, behaviors, manifest, makeConfig, }: {
                 allPowers: unknown;
                 behaviors: Record<string, unknown>;
                 manifest: Record<string, Record<string, unknown>>;
                 makeConfig: (name: string, permit: Record<string, unknown>) => unknown;
             }) => Promise<any[]>;
-            makePromiseSpaceForNameHub: (nameAdmin: ERef<import("../types").NameAdmin>, log?: {
+            makePromiseSpaceForNameHub: (nameAdmin: ERef<import("../types.js").NameAdmin>, log?: {
                 (...data: any[]): void;
                 (message?: any, ...optionalParams: any[]): void;
             } | undefined) => PromiseSpaceOf<any, {}, {}>;
-            makeWellKnownSpaces: (parentAdmin: ERef<import("../types").NameAdmin>, log?: {
+            makeWellKnownSpaces: (parentAdmin: ERef<import("../types.js").NameAdmin>, log?: {
                 (...data: any[]): void;
                 (message?: any, ...optionalParams: any[]): void;
             } | undefined, kinds?: string[] | undefined) => Promise<WellKnownSpaces>;
@@ -262,13 +232,13 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
                 (...data: any[]): void;
                 (message?: any, ...optionalParams: any[]): void;
             } | undefined, reserved?: Record<string, Record<string, unknown>>) => Promise<{
-                agoricNames: import("../types").NameHub;
-                agoricNamesAdmin: import("../types").NameAdmin;
+                agoricNames: import("../types.js").NameHub;
+                agoricNamesAdmin: import("../types.js").NameAdmin;
                 spaces: WellKnownSpaces;
             }>;
             makeMyAddressNameAdminKit: (address: string) => {
-                nameHub: import("../types").NameHub;
-                myAddressNameAdmin: import("../types").MyAddressNameAdmin;
+                nameHub: import("../types.js").NameHub;
+                myAddressNameAdmin: import("../types.js").MyAddressNameAdmin;
             };
             makeVatSpace: (svc: ERef<import("@endo/exo").Guarded<{
                 waitForBundleCap(bundleID: any): any;
@@ -338,20 +308,20 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
                 space: {
                     consume: {
                         agoricNames: Promise<{
-                            getNameHub: () => import("../types").NameHub;
-                            getNameHubKit: () => import("../types").NameHubKit;
+                            getNameHub: () => import("../types.js").NameHub;
+                            getNameHubKit: () => import("../types.js").NameHubKit;
                             publishNameHubs: (nameStorage: ERef<StorageNode>, vatBoard: ERef<BoardVat>, kinds: string[]) => Promise<void>;
-                            provideInertBrand: (keyword: string, displayInfo: globalThis.DisplayInfo) => any;
+                            provideInertBrand: (keyword: string, displayInfo: DisplayInfo) => any;
                         } & import("@endo/eventual-send").RemotableBrand<{}, {
-                            getNameHub: () => import("../types").NameHub;
-                            getNameHubKit: () => import("../types").NameHubKit;
+                            getNameHub: () => import("../types.js").NameHub;
+                            getNameHubKit: () => import("../types.js").NameHubKit;
                             publishNameHubs: (nameStorage: ERef<StorageNode>, vatBoard: ERef<BoardVat>, kinds: string[]) => Promise<void>;
-                            provideInertBrand: (keyword: string, displayInfo: globalThis.DisplayInfo) => any;
+                            provideInertBrand: (keyword: string, displayInfo: DisplayInfo) => any;
                         }>>;
                         board: Promise<{
                             getBoard: () => import("@endo/exo").Guarded<{
                                 getId(value: any): string;
-                                getValue(id: string): any;
+                                getValue(id: BoardId): any;
                                 lookup(...path: string[]): Promise<any>;
                                 has(val: any): boolean;
                                 ids(): string[];
@@ -368,12 +338,12 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
                                     unserialize(data: any): any;
                                 }>;
                             }>;
-                            makePublishingRecorderKit: <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport").RecorderKit<T>;
-                            makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport").RecorderKit<T>;
+                            makePublishingRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
+                            makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
                         } & import("@endo/eventual-send").RemotableBrand<{}, {
                             getBoard: () => import("@endo/exo").Guarded<{
                                 getId(value: any): string;
-                                getValue(id: string): any;
+                                getValue(id: BoardId): any;
                                 lookup(...path: string[]): Promise<any>;
                                 has(val: any): boolean;
                                 ids(): string[];
@@ -390,8 +360,8 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
                                     unserialize(data: any): any;
                                 }>;
                             }>;
-                            makePublishingRecorderKit: <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport").RecorderKit<T>;
-                            makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | (import("@endo/eventual-send").DataOnly<StorageNode> & import("@endo/eventual-send").RemotableBrand<import("@endo/eventual-send").DataOnly<StorageNode>, StorageNode>), valueShape?: import("@agoric/zoe/src/contractSupport").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport").RecorderKit<T>;
+                            makePublishingRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
+                            makeReadOnlyRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<T>;
                         }>>;
                     };
                 };
@@ -402,7 +372,7 @@ export function upgradeZoe({ consume: { vatAdminSvc, vatStore } }: WellKnownSpac
 } & {
     consume: {
         vatAdminSvc: VatAdminSvc;
-        vatStore: MapStore<string, import('@agoric/swingset-vat').CreateVatResults>;
+        vatStore: MapStore<string, import("@agoric/swingset-vat").CreateVatResults>;
     };
 }, options: {
     options: {

package/src/proposals/upgrade-zoe-proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upgrade-zoe-proposal.d.ts","sourceRoot":"","sources":["upgrade-zoe-proposal.js"],"names":[],"mappings":"AAeO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBATU,QAAQ,CACxB,MAAc,EACd,OAAe,sBAAsB,EAAE,gBAAgB,CAChD;;;IAI2D,OAAO,EAA/D;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE;kBAexD;AAEM;;;;;;;;;;;;;;;EAWL"}
+{"version":3,"file":"upgrade-zoe-proposal.d.ts","sourceRoot":"","sources":["upgrade-zoe-proposal.js"],"names":[],"mappings":"AAeO;;;;;;;;;;;;;;;;;wCA2B6I,eAAe;;;;;;;;;;;2DAA8hG,eAAe;8LAA8J,eAAe;yFAA4hE,cAAc,kBAAoB;gBAAC,QAAS,CAAC,EAAC,uBAAwB,CAAA;aAAE;oMAAskF,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gJAA+8H,eAAe,GAAE,cAAe;gGAA6hB,eAAe,wCAAoB;gBAAC,OAAa,CAAC,EAAC;oBAAE,kBAA0B,CAAC,EAAC;wBAAE,QAAkB,CAAC,EAAC,QAAS,CAAC;qBAAS,CAAC;iBAAO,CAAC;aAAK;0DAA8xC,eAAe;iIAAjgb,eAAe,KAAK;8CAAqnE,KAAK,mBAAmB,EAAC,SAAU,CAAC;wFAAwb,cAAc,GAAE;gBAAE,MAAM,OAAQ,cAAc,EAAE,IAAI,CAAA;aAAE;qMAA68G,cAAc,GAAE;gBAAE,MAAW,OAAQ,cAAc,EAAE,IAAI,CAAC;gBAAA,SAAc;oBAAE,+BAAsC,OAAQ,wDAAwD,EAAE,sBAAsB,CAAC,SAAS,CAAC,CAAC,+BAA+B,CAAC,CAAC;iBAAO,CAAC;aAAK;;;;;;;;;;;;;;;;;;;;;iHAAozG,eAAe,GAAE,cAAe;8HAA+V,eAAe,GAAE,cAAe;;;;;;;;;;;6JAAktC,eAAe;gGAAigC,cAAc;qHAA8mC,cAAc;kIAAk9B,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAAp7Z;gBAAC,MAAM;oBAAE,OAAO,QAAS,CAAC;oBAAA,OAAO,YAAa,CAAA;iBAAE,CAAA;aAAE;uCAA6P,CAAC,CAAC,GAAG,SAAI,KAAI,uBAAwB,CAAC,EAAE;gCAAgT,IAAI,YAAW,mBAAoB;oCAAunC,IAAI,YAAW,mBAAoB;;gBAAyhB,SAAS;gBAA0C,SAAS,EAAvC,uBAAuB;gBAA0E,QAAQ,EAAtD,eAAc,uBAAwB,CAAC;gBAA4F,UAAU,EAA3E,CAAC,YAAY,EAAC,QAAQ,uBAAwB,YAAY;;;0BAAmzqrC,KAAM;mDAAztjrC,KAAM;;;;;;;;;sCAAvoC,eAAc,uBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+GAA/2M,QAAQ;8EAAovB,WAAW;;;;;;;;;;6CAA+pL,OAAO;;;;;;;;;;;;;;;;;wEAApzG,WAAW,GAAE,QAAS,OAAO,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;gHAApB,MAAM;;;;;;;;;;;;;;;;;;;;;kHAAN,MAAM;gHAAN,MAAM;;;;;;;;;;;kBApC3xH,QAAQ,CACxB,MAAc,EACd,OAAe,sBAAsB,EAAE,gBAAgB,CAChD;;;IAI2D,OAAO,EAA/D;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE;kBAexD;AAEM;;;;;;;;;;;;;;;EAWL"}