@agoric/vats 0.15.2-dev-fbd8633.0 → 0.15.2-dev-a2c6d29.0

package/src/vat-ibc.d.ts

@@ -1,43 +1,15 @@
 export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
     createHandlers: (callbacks: any) => {
-        protocolHandler: ProtocolHandler;
+        protocolHandler: import("@agoric/network").ProtocolHandler;
         bridgeHandler: import("./types.js").BridgeHandler;
-    } | {
-        protocolHandler: import("@endo/exo").Guarded<{
-            onCreate(protocol: Remote<ProtocolImpl>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-            onInstantiate(port: Remote<Port>, localAddr: Endpoint, remote: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<string>;
-            generatePortID(localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<string>;
-            onBind(port: Remote<Port>, localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<void>;
-            onConnect(port: Remote<Port>, localAddr: Endpoint, remote: Endpoint, c: Remote<ConnectionHandler>, p: Remote<ProtocolHandler>): PromiseVow<AttemptDescription>;
-            onListen(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-            onListenRemove(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-            onRevoke(port: Remote<Port>, localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<void>;
-        }>;
-        bridgeHandler: import("@endo/exo").Guarded<{
-            fromBridge(obj: import("./types.js").IBCEvent<import("./types.js").IBCBridgeEvent>): Promise<import("@agoric/vow").Vow<any> | undefined>;
-        }>;
     };
     makeCallbacks: (dibcBridgeManager: import("./types.js").ScopedBridgeManager) => import("@endo/exo").Guarded<{
         downcall(method: string, obj: any): Promise<any>;
     }>;
 } & import("@endo/eventual-send").RemotableBrand<{}, {
     createHandlers: (callbacks: any) => {
-        protocolHandler: ProtocolHandler;
+        protocolHandler: import("@agoric/network").ProtocolHandler;
         bridgeHandler: import("./types.js").BridgeHandler;
-    } | {
-        protocolHandler: import("@endo/exo").Guarded<{
-            onCreate(protocol: Remote<ProtocolImpl>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-            onInstantiate(port: Remote<Port>, localAddr: Endpoint, remote: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<string>;
-            generatePortID(localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<string>;
-            onBind(port: Remote<Port>, localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<void>;
-            onConnect(port: Remote<Port>, localAddr: Endpoint, remote: Endpoint, c: Remote<ConnectionHandler>, p: Remote<ProtocolHandler>): PromiseVow<AttemptDescription>;
-            onListen(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-            onListenRemove(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-            onRevoke(port: Remote<Port>, localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<void>;
-        }>;
-        bridgeHandler: import("@endo/exo").Guarded<{
-            fromBridge(obj: import("./types.js").IBCEvent<import("./types.js").IBCBridgeEvent>): Promise<import("@agoric/vow").Vow<any> | undefined>;
-        }>;
     };
     makeCallbacks: (dibcBridgeManager: import("./types.js").ScopedBridgeManager) => import("@endo/exo").Guarded<{
         downcall(method: string, obj: any): Promise<any>;

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

@@ -1 +1 @@
-{"version":3,"file":"vat-ibc.d.ts","sourceRoot":"","sources":["vat-ibc.js"],"names":[],"mappings":"AAKA;;;;;;;yDAoBgqI,QAAS,UAAc,QAAS;sCAAlyB,QAAS;kDAAkL,QAAS;qDAAmxB,QAAS,UAAc,QAAS;oDAA7pB,QAAS;0DAAmM,QAAS;oDAAqqB,QAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAD1nJ"}
+{"version":3,"file":"vat-ibc.d.ts","sourceRoot":"","sources":["vat-ibc.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAmBC"}

package/src/vat-network.d.ts

@@ -3,29 +3,47 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
         onCreate(_impl: any, _protocolHandler: any): Promise<void>;
         generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
         onBind(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
-        onConnect(_port: any, localAddr: Endpoint, remoteAddr: Endpoint): PromiseVow<AttemptDescription>;
+        onConnect(_port: any, localAddr: string, remoteAddr: string): import("@agoric/vow").PromiseVow<import("@agoric/network").AttemptDescription>;
         onInstantiate(_port: any, _localAddr: any, _remote: any, _protocol: any): Promise<string>;
         onListen(port: any, localAddr: any, listenHandler: any, _protocolHandler: any): Promise<void>;
-        onListenRemove(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, _protocolHandler: any): Promise<void>;
+        onListenRemove(port: import("@agoric/vow").Remote<import("@agoric/network").Port, {}>, localAddr: string, listenHandler: import("@agoric/vow").Remote<import("@agoric/network").ListenHandler, {
+            /**
+             * The listener has been registered
+             */
+            onListen?: undefined;
+            /**
+             * The connection was rejected
+             */
+            onReject?: undefined;
+            /**
+             * There was an error while listening
+             */
+            onError?: undefined;
+            /**
+             * The
+             * listener has been removed
+             */
+            onRemove?: undefined;
+        }>, _protocolHandler: any): Promise<void>;
         onRevoke(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
     }>;
     makeEchoConnectionKit: () => import("@endo/exo").GuardedKit<{
         handler: {
-            onReceive(_connection: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
-            onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+            onReceive(_connection: import("@agoric/network").Connection, bytes: string, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
+            onClose(_connection: import("@agoric/network").Connection, _reason?: any, _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: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
-                onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+                onReceive(_connection: import("@agoric/network").Connection, bytes: string, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
+                onClose(_connection: import("@agoric/network").Connection, _reason?: any, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
             }>>;
             onListen(port: any, _listenHandler: any): Promise<void>;
         };
     }>;
     /** @param {Parameters<typeof protocol.registerProtocolHandler>} args */
-    registerProtocolHandler: (paths: string[], protocolHandler: Remote<ProtocolHandler>) => void;
+    registerProtocolHandler: (paths: string[], protocolHandler: import("@agoric/vow").Remote<import("@agoric/network").ProtocolHandler>) => void;
     /** @param {Parameters<typeof protocol.unregisterProtocolHandler>} args */
-    unregisterProtocolHandler: (prefix: string, protocolHandler: Remote<ProtocolHandler>) => void;
+    unregisterProtocolHandler: (prefix: string, protocolHandler: import("@agoric/vow").Remote<import("@agoric/network").ProtocolHandler>) => void;
     getPortAllocator(): import("@endo/exo").Guarded<{
         allocateCustomIBCPort(specifiedName?: string): import("@agoric/vow").Vow<any>;
         allocateICAControllerPort(): import("@agoric/vow").Vow<any>;
@@ -36,29 +54,60 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
         onCreate(_impl: any, _protocolHandler: any): Promise<void>;
         generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
         onBind(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
-        onConnect(_port: any, localAddr: Endpoint, remoteAddr: Endpoint): PromiseVow<AttemptDescription>;
+        onConnect(_port: any, localAddr: string, remoteAddr: string): import("@agoric/vow").PromiseVow<import("@agoric/network").AttemptDescription>;
         onInstantiate(_port: any, _localAddr: any, _remote: any, _protocol: any): Promise<string>;
         onListen(port: any, localAddr: any, listenHandler: any, _protocolHandler: any): Promise<void>;
-        onListenRemove(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, _protocolHandler: any): Promise<void>;
+        onListenRemove(port: import("@agoric/vow").Remote<import("@agoric/network").Port, {}>, localAddr: string, listenHandler: import("@agoric/vow").Remote<import("@agoric/network").ListenHandler, {
+            /**
+             * The listener has been registered
+             */
+            /**
+             * The listener has been registered
+             */
+            onListen?: undefined;
+            /**
+             * The connection was rejected
+             */
+            /**
+             * The connection was rejected
+             */
+            onReject?: undefined;
+            /**
+             * There was an error while listening
+             */
+            /**
+             * There was an error while listening
+             */
+            onError?: undefined;
+            /**
+             * The
+             * listener has been removed
+             */
+            /**
+             * The
+             * listener has been removed
+             */
+            onRemove?: undefined;
+        }>, _protocolHandler: any): Promise<void>;
         onRevoke(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
     }>;
     makeEchoConnectionKit: () => import("@endo/exo").GuardedKit<{
         handler: {
-            onReceive(_connection: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
-            onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+            onReceive(_connection: import("@agoric/network").Connection, bytes: string, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
+            onClose(_connection: import("@agoric/network").Connection, _reason?: any, _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: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
-                onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+                onReceive(_connection: import("@agoric/network").Connection, bytes: string, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
+                onClose(_connection: import("@agoric/network").Connection, _reason?: any, _connectionHandler?: import("@agoric/network").ConnectionHandler | undefined): Promise<void>;
             }>>;
             onListen(port: any, _listenHandler: any): Promise<void>;
         };
     }>;
     /** @param {Parameters<typeof protocol.registerProtocolHandler>} args */
-    registerProtocolHandler: (paths: string[], protocolHandler: Remote<ProtocolHandler>) => void;
+    registerProtocolHandler: (paths: string[], protocolHandler: import("@agoric/vow").Remote<import("@agoric/network").ProtocolHandler>) => void;
     /** @param {Parameters<typeof protocol.unregisterProtocolHandler>} args */
-    unregisterProtocolHandler: (prefix: string, protocolHandler: Remote<ProtocolHandler>) => void;
+    unregisterProtocolHandler: (prefix: string, protocolHandler: import("@agoric/vow").Remote<import("@agoric/network").ProtocolHandler>) => void;
     getPortAllocator(): import("@endo/exo").Guarded<{
         allocateCustomIBCPort(specifiedName?: string): import("@agoric/vow").Vow<any>;
         allocateICAControllerPort(): import("@agoric/vow").Vow<any>;

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

@@ -1 +1 @@
-{"version":3,"file":"vat-network.d.ts","sourceRoot":"","sources":["vat-network.js"],"names":[],"mappings":"AAWA;;;;;yCAqCusmC,QAAQ,cAA+B,QAAQ;;;sDAAktE,QAAQ;;;;;mCAA1iJ,UAAU,SAAiC,KAAK,sBAA2B,iBAAiB;iCAAoR,UAAU,YAAiC,WAAW;;;;;;;;;;IAXx0iC,wEAAwE;;IAGxE,0EAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAH1E,wEAAwE;;IAGxE,0EAA0E;;;;;;;GAO7E"}
+{"version":3,"file":"vat-network.d.ts","sourceRoot":"","sources":["vat-network.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0BI,wEAAwE;;IAGxE,0EAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAH1E,wEAAwE;;IAGxE,0EAA0E;;;;;;;GAO7E"}

package/src/vat-priceAuthority.d.ts

@@ -6,7 +6,7 @@
  * @param {unknown} _vatParams
  * @param {import('@agoric/vat-data').Baggage} baggage
  */
-export function buildRootObject(_vatPowers: * TerminationVatPowers, _vatParams: unknown, baggage: import("@agoric/vat-data").Baggage): {
+export function buildRootObject(_vatPowers: TerminationVatPowers, _vatParams: unknown, baggage: import("@agoric/vat-data").Baggage): {
     getRegistry: () => import("./priceAuthorityRegistry.js").PriceAuthorityRegistry;
 } & import("@endo/eventual-send").RemotableBrand<{}, {
     getRegistry: () => import("./priceAuthorityRegistry.js").PriceAuthorityRegistry;

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

@@ -1 +1 @@
-{"version":3,"file":"vat-priceAuthority.d.ts","sourceRoot":"","sources":["vat-priceAuthority.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gFAHW,OAAO,WACP,OAAO,kBAAkB,EAAE,OAAO;;;;GAK5C"}
+{"version":3,"file":"vat-priceAuthority.d.ts","sourceRoot":"","sources":["vat-priceAuthority.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,8EAHW,OAAO,WACP,OAAO,kBAAkB,EAAE,OAAO;;;;GAK5C"}

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

@@ -1 +1 @@
-{"version":3,"file":"vat-provisioning.d.ts","sourceRoot":"","sources":["vat-provisioning.js"],"names":[],"mappings":"AAkFA;;;;GAIG;AACH,4CAJW,OAAO,kBACP,OAAO,WACP,OAAO,kBAAkB,EAAE,OAAO;0CAoBhC,YAAY,KACZ,QAAQ;gCASR,MAAM,WACN,MAAM,cACN,MAAM,EAAE;;;;;;;;0CAZR,YAAY,KACZ,QAAQ;gCASR,MAAM,WACN,MAAM,cACN,MAAM,EAAE;;;;;;;GAuDpB"}
+{"version":3,"file":"vat-provisioning.d.ts","sourceRoot":"","sources":["vat-provisioning.js"],"names":[],"mappings":"AAkFA;;;;GAIG;AACH,4CAJW,OAAO,kBACP,OAAO,WACP,OAAO,kBAAkB,EAAE,OAAO;kBAmBhC,IAAI,CAAC,aAAa,CAAC,KACnB,YAAY,KACZ,QAAQ;gCASR,MAAM,WACN,MAAM,cACN,MAAM,EAAE;;;;;;;;kBAbR,IAAI,CAAC,aAAa,CAAC,KACnB,YAAY,KACZ,QAAQ;gCASR,MAAM,WACN,MAAM,cACN,MAAM,EAAE;;;;;;;GAuDpB"}

package/src/virtual-purse.d.ts

@@ -34,38 +34,38 @@ export function makeVirtualPurseKitIKit(brandShape?: Pattern, amountShape?: Patt
     }>;
 };
 export function prepareVirtualPurse(zone: import("@agoric/zone").Zone): (vpc: ERef<VirtualPurseController>, { escrowPurse: defaultEscrowPurse, ...issuerKit }: {
-    issuer: ERef<globalThis.Issuer>;
+    issuer: ERef<Issuer>;
     brand: Brand;
-    mint?: ERef<globalThis.Mint> | undefined;
-    escrowPurse?: ERef<globalThis.Purse> | undefined;
+    mint?: ERef<Mint>;
+    escrowPurse?: ERef<Purse>;
 }) => Promise<{
     /**
      * Get the alleged Brand for this
      * Purse
      */
-    getAllegedBrand: () => ERef<{
+    getAllegedBrand: () => globalThis.ERef<{
         /**
          *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
          */
-        isMyIssuer: (allegedIssuer: ERef<globalThis.Issuer>) => ERef<boolean>;
-        getAllegedName: () => ERef<string>;
+        isMyIssuer: (allegedIssuer: globalThis.ERef<globalThis.Issuer>) => globalThis.ERef<boolean>;
+        getAllegedName: () => globalThis.ERef<string>;
         /**
          * Give information to UI on how
          * to display the amount.
          */
-        getDisplayInfo: () => ERef<globalThis.DisplayInfo<globalThis.AssetKind>>;
+        getDisplayInfo: () => globalThis.ERef<globalThis.DisplayInfo<globalThis.AssetKind>>;
         getAmountShape: () => any;
     }>;
     /**
      * Get the amount contained in this
      * purse.
      */
-    getCurrentAmount: () => ERef<globalThis.Amount<globalThis.AssetKind>>;
+    getCurrentAmount: () => globalThis.ERef<globalThis.Amount<globalThis.AssetKind>>;
     /**
      * Get a lossy
      * notifier for changes to this purse's balance.
      */
-    getCurrentAmountNotifier: () => ERef<{
+    getCurrentAmountNotifier: () => globalThis.ERef<{
         /**
          * Returns a promise for an update record as of an update count.
          * If the `updateCount` argument is omitted or differs from the current update count,
@@ -76,7 +76,7 @@ export function prepareVirtualPurse(zone: import("@agoric/zone").Zone): (vpc: ER
          * Used to make lossy ("latest") iterators.
          * NOTE: Use of `number` as an `updateCount` is deprecated.
          */
-        getUpdateSince: (updateCount?: number | bigint | undefined) => ERef<UpdateRecord<globalThis.Amount<globalThis.AssetKind>>>;
+        getUpdateSince: (updateCount?: number | bigint | undefined) => globalThis.ERef<globalThis.UpdateRecord<globalThis.Amount<globalThis.AssetKind>>>;
     }>;
     /**
      * Deposit all the contents of payment into
@@ -85,12 +85,12 @@ export function prepareVirtualPurse(zone: import("@agoric/zone").Zone): (vpc: ER
      *
      * If payment is a promise, throw an error.
      */
-    deposit: (args_0: globalThis.Payment<globalThis.AssetKind>, args_1?: any) => ERef<globalThis.Amount<globalThis.AssetKind>>;
+    deposit: (args_0: globalThis.Payment<globalThis.AssetKind>, args_1?: any) => globalThis.ERef<globalThis.Amount<globalThis.AssetKind>>;
     /**
      * Return an object whose
      * `receive` method deposits to the current Purse.
      */
-    getDepositFacet: () => ERef<{
+    getDepositFacet: () => globalThis.ERef<{
         /**
          * Deposit all the contents of payment
          * into the purse that made this facet, returning the amount. If the optional
@@ -99,30 +99,30 @@ export function prepareVirtualPurse(zone: import("@agoric/zone").Zone): (vpc: ER
          *
          * If payment is a promise, throw an error.
          */
-        receive: (args_0: globalThis.Payment, args_1?: any) => ERef<globalThis.Amount>;
+        receive: (args_0: globalThis.Payment, args_1?: any) => globalThis.ERef<globalThis.Amount>;
     }>;
     /**
      * Withdraw amount from
      * this purse into a new Payment.
      */
-    withdraw: (amount: globalThis.Amount<globalThis.AssetKind>) => ERef<{
+    withdraw: (amount: globalThis.Amount<globalThis.AssetKind>) => globalThis.ERef<{
         /**
          * Get the allegedBrand, indicating
          * the type of digital asset this payment purports to be, and which issuer to
          * use. Because payments are not trusted, any method calls on payments should
          * be treated with suspicion and verified elsewhere.
          */
-        getAllegedBrand: () => ERef<{
+        getAllegedBrand: () => globalThis.ERef<{
             /**
              *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
              */
-            isMyIssuer: (allegedIssuer: ERef<globalThis.Issuer>) => ERef<boolean>;
-            getAllegedName: () => ERef<string>;
+            isMyIssuer: (allegedIssuer: globalThis.ERef<globalThis.Issuer>) => globalThis.ERef<boolean>;
+            getAllegedName: () => globalThis.ERef<string>;
             /**
              * Give information to UI on how
              * to display the amount.
              */
-            getDisplayInfo: () => ERef<globalThis.DisplayInfo<globalThis.AssetKind>>;
+            getDisplayInfo: () => globalThis.ERef<globalThis.DisplayInfo<globalThis.AssetKind>>;
             getAmountShape: () => any;
         }>;
     }>;
@@ -138,7 +138,7 @@ export function prepareVirtualPurse(zone: import("@agoric/zone").Zone): (vpc: ER
      *
      * Returns an empty set if this issuer does not support recovery sets.
      */
-    getRecoverySet: () => ERef<import("@endo/patterns").CopySet<globalThis.Payment<globalThis.AssetKind>>>;
+    getRecoverySet: () => globalThis.ERef<import("@endo/patterns").CopySet<globalThis.Payment<globalThis.AssetKind>>>;
     /**
      * For use in emergencies, such as coming
      * back from a traumatic crash and upgrade. This deposits all the payments in
@@ -147,7 +147,7 @@ export function prepareVirtualPurse(zone: import("@agoric/zone").Zone): (vpc: ER
      *
      * Returns an empty amount if this issuer does not support recovery sets.
      */
-    recoverAll: () => ERef<globalThis.Amount<globalThis.AssetKind>>;
+    recoverAll: () => globalThis.ERef<globalThis.Amount<globalThis.AssetKind>>;
 }>;
 export type Retain = (pmt: Payment, optAmountShape?: Pattern) => Promise<Amount>;
 export type Redeem = (amt: Amount) => Promise<Payment>;

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

@@ -1 +1 @@
-{"version":3,"file":"virtual-purse.d.ts","sourceRoot":"","sources":["virtual-purse.js"],"names":[],"mappings":"AAsBO,qDAHI,OAAO,gBACP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DjB;AAwLM,0CADK,OAAO,cAAc,EAAE,IAAI;;WASzB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoClB;qBAhOa,CAAC,GAAG,EAAE,OAAO,EAAE,cAAc,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC;qBAC3D,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC;;;;;;;;;;;;gBAKjC,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"}
+{"version":3,"file":"virtual-purse.d.ts","sourceRoot":"","sources":["virtual-purse.js"],"names":[],"mappings":"AAsBO,qDAHI,OAAO,gBACP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DjB;AAwLM,0CADK,OAAO,cAAc,EAAE,IAAI,SAK1B,IAAI,CAAC,sBAAsB,CAAC,qDAE5B;IACV,MAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACzB,KAAS,EAAE,KAAK,CAAC;IACjB,IAAQ,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACtB,WAAe,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;CAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCL;qBAhOa,CAAC,GAAG,EAAE,OAAO,EAAE,cAAc,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC;qBAC3D,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC;;;;;;;;;;;;gBAKjC,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"}

package/tools/bank-utils.d.ts

@@ -1,6 +1,6 @@
 export function makeFakeBankKit(issuerKits: Pick<IssuerKit, "brand" | "issuer">[]): {
     addAsset: (denom: string, issuerName: string, proposedName: string, kit: import("../src/vat-bank.js").AssetIssuerKit) => void;
-    assetPublication: IterationObserver<import("../src/vat-bank.js").AssetDescriptor>;
+    assetPublication: globalThis.IterationObserver<import("../src/vat-bank.js").AssetDescriptor>;
     bank: import("../src/vat-bank.js").Bank;
 };
 //# sourceMappingURL=bank-utils.d.ts.map