@agoric/vats 0.15.1 → 0.15.2-calypso-dev-84eb287.0

package/src/lib-board.d.ts

@@ -1,141 +1,71 @@
+/**
+ * @import {RemotableObject} from '@endo/pass-style';
+ * @import {Key} from '@endo/patterns');
+ */
 export const DEFAULT_CRC_DIGITS: 2;
 export const DEFAULT_PREFIX: "board0";
-export function prepareBoardKit(baggage: MapStore<string, unknown>): (args_0?: 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) => {
-    board: {
-        /**
-         * Provide an ID for a value, generating one if not already present.
-         *
-         * Each board ID includes a CRC so that the last part is well-distributed,
-         * which mitigates typo risks.
-         *
-         * Scaling Consideration: since we cannot know when consumers
-         * are no longer interested in an ID, a board holds a strong reference
-         * to `value` for its entire lifetime. For a well-known board, this
-         * is essentially forever.
-         *
-         * @param {Key} value
-         * @throws if `value` is not a Key in the @agoric/store sense
-         */
-        getId(value: Key): string;
-        /**
-         * @param {BoardId} id
-         * @throws if id is not in the mapping
-         */
-        getValue(id: BoardId): any;
-        /**
-         * Convenience method for recursively traversing boards and
-         * board-like remotables to get data associated with a sequence of ids
-         * corresponding to each successive board.
-         * For example, `lookup("foo", "bar")` gets the value associated with
-         * id "foo" and returns the result of invoking `lookup("bar")` upon it
-         * to get the value it associates with id "bar".
-         *
-         * @param  {...string} path
-         */
-        lookup(...path: string[]): Promise<any>;
-        /** @param {Key} val */
-        has(val: Key): boolean;
-        ids(): string[];
-        /**
-         * Get a marshaller that implements the convertValToSlot hook using getId(),
-         * "publishing" previously un-mapped objects.
-         */
-        getPublishingMarshaller(): {
-            toCapData(val: any): import("@endo/marshal").CapData<string>;
-            fromCapData(data: any): any;
-            serialize(data: any): import("@endo/marshal").CapData<string>;
-            unserialize(data: any): any;
-        };
-        /**
-         * Get a marshaller that implements the convertValToSlot hook using getId(),
-         * only for objects that the board has().
-         *
-         * For other objects, we don't throw, but we emit a null slot.
-         * Un-serializing a null slot always produces a fresh object
-         * rather than preserving object identity.
-         */
-        getReadonlyMarshaller(): {
-            toCapData(val: any): import("@endo/marshal").CapData<string | null>;
-            fromCapData(data: any): any;
-            serialize(data: any): import("@endo/marshal").CapData<string | null>;
-            unserialize(data: any): any;
-        };
-    };
-    readonlyMarshaller: {
-        toCapData(val: any): import("@endo/marshal").CapData<string | null>;
-        fromCapData(data: any): any;
-        serialize(data: any): import("@endo/marshal").CapData<string | null>;
-        unserialize(data: any): any;
-    };
-    publishingMarshaller: {
-        toCapData(val: any): import("@endo/marshal").CapData<string>;
-        fromCapData(data: any): any;
-        serialize(data: any): import("@endo/marshal").CapData<string>;
-        unserialize(data: any): any;
-    };
-} & import("@endo/eventual-send").RemotableBrand<{}, {
+} | undefined) => import("@endo/exo").GuardedKit<{
     board: {
         /**
          * Provide an ID for a value, generating one if not already present.
          *
-         * Each board ID includes a CRC so that the last part is well-distributed,
-         * which mitigates typo risks.
+         * Each board ID includes a CRC so that the last part is
+         * well-distributed, which mitigates typo risks.
          *
-         * Scaling Consideration: since we cannot know when consumers
-         * are no longer interested in an ID, a board holds a strong reference
-         * to `value` for its entire lifetime. For a well-known board, this
-         * is essentially forever.
+         * Scaling Consideration: since we cannot know when consumers are no
+         * longer interested in an ID, a board holds a strong reference to
+         * `value` for its entire lifetime. For a well-known board, this is
+         * essentially forever.
          *
-         * @param {Key} value
-         * @throws if `value` is not a Key in the @agoric/store sense
+         * @param {RemotableObject} value
          */
-        getId(value: Key): string;
+        getId(value: RemotableObject): string;
         /**
          * @param {BoardId} id
          * @throws if id is not in the mapping
          */
-        getValue(id: BoardId): any;
+        getValue(id: BoardId): RemotableObject;
         /**
-         * Convenience method for recursively traversing boards and
-         * board-like remotables to get data associated with a sequence of ids
-         * corresponding to each successive board.
-         * For example, `lookup("foo", "bar")` gets the value associated with
-         * id "foo" and returns the result of invoking `lookup("bar")` upon it
-         * to get the value it associates with id "bar".
+         * Convenience method for recursively traversing boards and board-like
+         * remotables to get data associated with a sequence of ids
+         * corresponding to each successive board. For example, `lookup("foo",
+         * "bar")` gets the value associated with id "foo" and returns the
+         * result of invoking `lookup("bar")` upon it to get the value it
+         * associates with id "bar".
          *
-         * @param  {...string} path
+         * @param {...string} path
          */
         lookup(...path: string[]): Promise<any>;
-        /** @param {Key} val */
-        has(val: Key): boolean;
+        /** @param {RemotableObject} val */
+        has(val: RemotableObject): boolean;
         ids(): string[];
         /**
-         * Get a marshaller that implements the convertValToSlot hook using getId(),
-         * "publishing" previously un-mapped objects.
+         * Get a marshaller that implements the convertValToSlot hook using
+         * getId(), "publishing" previously un-mapped objects.
          */
-        getPublishingMarshaller(): {
+        getPublishingMarshaller(): import("@endo/exo").Guarded<{
             toCapData(val: any): import("@endo/marshal").CapData<string>;
             fromCapData(data: any): any;
             serialize(data: any): import("@endo/marshal").CapData<string>;
             unserialize(data: any): any;
-        };
+        }>;
         /**
-         * Get a marshaller that implements the convertValToSlot hook using getId(),
-         * only for objects that the board has().
+         * Get a marshaller that implements the convertValToSlot hook using
+         * getId(), only for objects that the board has().
          *
          * For other objects, we don't throw, but we emit a null slot.
-         * Un-serializing a null slot always produces a fresh object
-         * rather than preserving object identity.
+         * Un-serializing a null slot always produces a fresh object rather than
+         * preserving object identity.
          */
-        getReadonlyMarshaller(): {
+        getReadonlyMarshaller(): import("@endo/exo").Guarded<{
             toCapData(val: any): import("@endo/marshal").CapData<string | null>;
             fromCapData(data: any): any;
             serialize(data: any): import("@endo/marshal").CapData<string | null>;
             unserialize(data: any): any;
-        };
+        }>;
     };
     readonlyMarshaller: {
         toCapData(val: any): import("@endo/marshal").CapData<string | null>;
@@ -150,32 +80,29 @@ export function prepareBoardKit(baggage: MapStore<string, unknown>): (args_0?: n
         unserialize(data: any): any;
     };
 }>;
-export function prepareRecorderFactory(zone: import('@agoric/zone').Zone): (label: string, marshaller: Marshaller) => <T>(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) => 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.
+ * For a value with a known id in the board, we can use that board id as a slot
+ * to preserve identity when marshaling.
  *
  * The contents of the string depend on the `prefix` and `crcDigits` options:
- *    \`${prefix}${crc}${seq}\`
+ * `${prefix}${crc}${seq}`
  *
  * For example, 'board0371' for prefix: 'board0', seq: 1, 2 digits crc.
  */
 export type BoardId = string;
 /**
- * // TODO: use Key from
+ * // TODO: use
+ *   Key from
  */
 export type BoardState = ReturnType<typeof initDurableBoardState>;
-export type Key = import('@endo/marshal').Passable;
+import type { RemotableObject } from '@endo/pass-style';
 /**
+ * @typedef {ReturnType<typeof initDurableBoardState>} BoardState // TODO: use
+ *   Key from @agoric/store when available
+ * @import {Passable} from '@endo/marshal'
  * @see {prepareExoClassKit}
- * @see {@link ../../SwingSet/docs/virtual-objects.md|SwingSet Virtual Objects}
- *
- * Hoisting this function makes defining the state type concise.
- * @typedef {ReturnType<typeof initDurableBoardState>} BoardState
- *
- *
- * // TODO: use Key from @agoric/store when available
- * @typedef {import('@endo/marshal').Passable} Key
+ * @see {@link ../../SwingSet/docs/virtual-objects.md|SwingSet Virtual Objects} Hoisting this function makes defining the state type concise.
  */
 /**
  * Make state for the board. Hoisted up to define the BoardState type.
@@ -183,15 +110,16 @@ export type Key = import('@endo/marshal').Passable;
  * @param {bigint | number} [initSequence]
  * @param {object} [options]
  * @param {string} [options.prefix] prefix for all ids generated
- * @param {number} [options.crcDigits] count of digits to use in CRC at end of the id
+ * @param {number} [options.crcDigits] count of digits to use in CRC at end of
+ *   the id
  */
 declare function initDurableBoardState(initSequence?: number | bigint | undefined, { prefix, crcDigits }?: {
     prefix?: string | undefined;
     crcDigits?: number | undefined;
 } | undefined): {
     lastSequence: bigint;
-    idToVal: MapStore<string, any>;
-    valToId: MapStore<any, string>;
+    idToVal: globalThis.MapStore<string, RemotableObject>;
+    valToId: globalThis.MapStore<RemotableObject, string>;
     prefix: string;
     crcDigits: number;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"lib-board.d.ts","sourceRoot":"","sources":["lib-board.js"],"names":[],"mappings":"AAmBA,mCAAoC;AACpC,sCAAuC;AAwOhC;;;;;QAQC;;;;;;;;;;;;;WAaG;qBAFQ,GAAG;QAMd;;;WAGG;qBAFQ,OAAO;QAMlB;;;;;;;;;WASG;wBADY,MAAM;QAgBrB,uBAAuB;iBAAX,GAAG;;QASf;;;WAGG;;;;;;;QAIH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;;;QAvEH;;;;;;;;;;;;;WAaG;qBAFQ,GAAG;QAMd;;;WAGG;qBAFQ,OAAO;QAMlB;;;;;;;;;WASG;wBADY,MAAM;QAgBrB,uBAAuB;iBAAX,GAAG;;QASf;;;WAGG;;;;;;;QAIH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;GAuCV;AAKM,6CAFI,OAAO,cAAc,EAAE,IAAI,WAUzB,MAAM,cACN,UAAU,2MAYtB;;;;;;;;;;sBAlVY,MAAM;;;;yBAuBN,WAAW,4BAA4B,CAAC;kBAIxC,OAAO,eAAe,EAAE,QAAQ;AAT7C;;;;;;;;;;GAUG;AAGH;;;;;;;GAOG;AACH;;;;;;;;;EA0BC"}
+{"version":3,"file":"lib-board.d.ts","sourceRoot":"","sources":["lib-board.js"],"names":[],"mappings":"AAiBA;;;GAGG;AAEH,mCAAoC;AACpC,sCAAuC;AAsOhC,yCAHI,OAAO,kBAAkB,EAAE,OAAO;;;yBAdpB,WAAW;;QAyB5B;;;;;;;;;;;;WAYG;qBADQ,eAAe;QAK1B;;;WAGG;qBAFQ,OAAO;QAMlB;;;;;;;;;WASG;wBADW,MAAM,EAAA;QAiBpB,mCAAmC;iBAAvB,eAAe;;QAS3B;;;WAGG;;;;;;;QAIH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;GAuCV;AAGM,6CADK,OAAO,cAAc,EAAE,IAAI,WAS1B,MAAM,cACN,UAAU,mDA7NuB,WAAW,0IAyOxD;;;;;;;;;;sBA9UY,MAAM;;;;;yBAmBN,UAAU,CAAC,OAAO,qBAAqB,CAAC;qCA9DnB,kBAAkB;AA6DpD;;;;;;GAMG;AAGH;;;;;;;;GAQG;AACH;;;;;;;;;EA0BC"}

package/src/lib-board.js

@@ -1,7 +1,5 @@
-// @ts-check
 /**
  * @file lib-board: share objects by way of plain-data ids
- *
  * @see prepareBoardKit()
  */
 
@@ -13,10 +11,15 @@ import {
   prepareRecorder,
 } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { E, Far } from '@endo/far';
-import { makeMarshal } from '@endo/marshal';
+import { isRemotable, makeMarshal } from '@endo/marshal';
 
 import { crc6 } from './crc.js';
 
+/**
+ * @import {RemotableObject} from '@endo/pass-style';
+ * @import {Key} from '@endo/patterns');
+ */
+
 export const DEFAULT_CRC_DIGITS = 2;
 export const DEFAULT_PREFIX = 'board0';
 
@@ -48,11 +51,11 @@ const BoardKitIKit = {
 //#endregion
 
 /**
- * For a value with a known id in the board, we can use
- * that board id as a slot to preserve identity when marshaling.
+ * For a value with a known id in the board, we can use that board id as a slot
+ * to preserve identity when marshaling.
  *
  * The contents of the string depend on the `prefix` and `crcDigits` options:
- *    \`${prefix}${crc}${seq}\`
+ * `${prefix}${crc}${seq}`
  *
  * For example, 'board0371' for prefix: 'board0', seq: 1, 2 digits crc.
  *
@@ -75,15 +78,11 @@ const calcCrc = (data, crcDigits) => {
 };
 
 /**
+ * @typedef {ReturnType<typeof initDurableBoardState>} BoardState // TODO: use
+ *   Key from @agoric/store when available
+ * @import {Passable} from '@endo/marshal'
  * @see {prepareExoClassKit}
- * @see {@link ../../SwingSet/docs/virtual-objects.md|SwingSet Virtual Objects}
- *
- * Hoisting this function makes defining the state type concise.
- * @typedef {ReturnType<typeof initDurableBoardState>} BoardState
- *
- *
- * // TODO: use Key from @agoric/store when available
- * @typedef {import('@endo/marshal').Passable} Key
+ * @see {@link ../../SwingSet/docs/virtual-objects.md|SwingSet Virtual Objects} Hoisting this function makes defining the state type concise.
  */
 
 // TODO consider tightening initSequence to bigint only
@@ -93,7 +92,8 @@ const calcCrc = (data, crcDigits) => {
  * @param {bigint | number} [initSequence]
  * @param {object} [options]
  * @param {string} [options.prefix] prefix for all ids generated
- * @param {number} [options.crcDigits] count of digits to use in CRC at end of the id
+ * @param {number} [options.crcDigits] count of digits to use in CRC at end of
+ *   the id
  */
 const initDurableBoardState = (
   initSequence = 0,
@@ -102,13 +102,13 @@ const initDurableBoardState = (
   const immutable = { prefix, crcDigits };
 
   const lastSequence = BigInt(initSequence);
-  /** @type {MapStore<BoardId, Key>} */
+  /** @type {MapStore<BoardId, RemotableObject>} */
   const idToVal = makeScalarBigMapStore('idToVal', {
     durable: true,
     keyShape: IdShape,
     valueShape: ValShape,
   });
-  /** @type {MapStore<Key, BoardId>} */
+  /** @type {MapStore<RemotableObject, BoardId>} */
   const valToId = makeScalarBigMapStore('valToId', {
     durable: true,
     keyShape: ValShape,
@@ -130,11 +130,14 @@ const initDurableBoardState = (
 // transient marshallers that get GCed when the function completes.
 
 /**
- * @param {Key} value
+ * @param {RemotableObject} value
  * @param {BoardState} state
  */
 const getId = (value, state) => {
   const { idToVal, valToId, prefix, crcDigits } = state;
+  if (!isRemotable(value)) {
+    Fail`Board cannot create id for non-remotable`;
+  }
 
   if (valToId.has(value)) {
     return valToId.get(value);
@@ -180,9 +183,7 @@ const getValue = (id, { prefix, crcDigits, idToVal }) => {
   throw Fail`board does not have id: ${id}`;
 };
 
-/**
- * @param {BoardState} state
- */
+/** @param {BoardState} state */
 const makeSlotToVal = state => {
   const ifaceAllegedPrefix = 'Alleged: ';
   const ifaceInaccessiblePrefix = 'SEVERED: ';
@@ -190,7 +191,7 @@ const makeSlotToVal = state => {
   /**
    * @param {BoardId} slot
    * @param {string} iface
-   * @returns {unknown}
+   * @returns {any}
    */
   const slotToVal = (slot, iface) => {
     if (slot !== null) {
@@ -243,9 +244,9 @@ const makePublishingMarshaller = state => {
 //#endregion
 
 /**
- * A board is a two-way mapping between objects (such as issuers,
- * brands, installation handles) and plain-data string IDs.
- * A well-known board allows sharing objects by way of their ids.
+ * A board is a two-way mapping between objects (such as issuers, brands,
+ * installation handles) and plain-data string IDs. A well-known board allows
+ * sharing objects by way of their ids.
  *
  * @param {import('@agoric/vat-data').Baggage} baggage for upgrade successors
  * @see {@link packages/SwingSet/docs/vat-upgrade.md|Vat Upgrade}
@@ -261,16 +262,15 @@ export const prepareBoardKit = baggage => {
         /**
          * Provide an ID for a value, generating one if not already present.
          *
-         * Each board ID includes a CRC so that the last part is well-distributed,
-         * which mitigates typo risks.
+         * Each board ID includes a CRC so that the last part is
+         * well-distributed, which mitigates typo risks.
          *
-         * Scaling Consideration: since we cannot know when consumers
-         * are no longer interested in an ID, a board holds a strong reference
-         * to `value` for its entire lifetime. For a well-known board, this
-         * is essentially forever.
+         * Scaling Consideration: since we cannot know when consumers are no
+         * longer interested in an ID, a board holds a strong reference to
+         * `value` for its entire lifetime. For a well-known board, this is
+         * essentially forever.
          *
-         * @param {Key} value
-         * @throws if `value` is not a Key in the @agoric/store sense
+         * @param {RemotableObject} value
          */
         getId(value) {
           return getId(value, this.state);
@@ -283,14 +283,14 @@ export const prepareBoardKit = baggage => {
           return getValue(id, this.state);
         },
         /**
-         * Convenience method for recursively traversing boards and
-         * board-like remotables to get data associated with a sequence of ids
-         * corresponding to each successive board.
-         * For example, `lookup("foo", "bar")` gets the value associated with
-         * id "foo" and returns the result of invoking `lookup("bar")` upon it
-         * to get the value it associates with id "bar".
+         * Convenience method for recursively traversing boards and board-like
+         * remotables to get data associated with a sequence of ids
+         * corresponding to each successive board. For example, `lookup("foo",
+         * "bar")` gets the value associated with id "foo" and returns the
+         * result of invoking `lookup("bar")` upon it to get the value it
+         * associates with id "bar".
          *
-         * @param  {...string} path
+         * @param {...string} path
          */
         async lookup(...path) {
           const {
@@ -300,13 +300,14 @@ export const prepareBoardKit = baggage => {
             return board;
           }
           const [first, ...rest] = path;
+          /** @type {any} */
           const firstValue = board.getValue(/** @type {BoardId} */ (first));
           if (rest.length === 0) {
             return firstValue;
           }
           return E(firstValue).lookup(...rest);
         },
-        /** @param {Key} val */
+        /** @param {RemotableObject} val */
         has(val) {
           const { state } = this;
           return state.valToId.has(val);
@@ -316,19 +317,19 @@ export const prepareBoardKit = baggage => {
           return harden([...state.idToVal.keys()]);
         },
         /**
-         * Get a marshaller that implements the convertValToSlot hook using getId(),
-         * "publishing" previously un-mapped objects.
+         * Get a marshaller that implements the convertValToSlot hook using
+         * getId(), "publishing" previously un-mapped objects.
          */
         getPublishingMarshaller() {
           return this.facets.publishingMarshaller;
         },
         /**
-         * Get a marshaller that implements the convertValToSlot hook using getId(),
-         * only for objects that the board has().
+         * Get a marshaller that implements the convertValToSlot hook using
+         * getId(), only for objects that the board has().
          *
          * For other objects, we don't throw, but we emit a null slot.
-         * Un-serializing a null slot always produces a fresh object
-         * rather than preserving object identity.
+         * Un-serializing a null slot always produces a fresh object rather than
+         * preserving object identity.
          */
         getReadonlyMarshaller() {
           return this.facets.readonlyMarshaller;
@@ -370,9 +371,7 @@ export const prepareBoardKit = baggage => {
   );
 };
 
-/**
- * @param {import('@agoric/zone').Zone} zone
- */
+/** @param {import('@agoric/zone').Zone} zone */
 export const prepareRecorderFactory = zone => {
   const baggage = zone.mapStore(`Recorder Baggage`);
   const makeDurablePublishKit = prepareDurablePublishKit(

package/src/localchain.d.ts

@@ -0,0 +1,195 @@
+/**
+ * @import {TypedJson, ResponseTo, JsonSafe} from '@agoric/cosmic-proto';
+ * @import {PromiseVow, VowTools} from '@agoric/vow';
+ * @import {TargetApp, TargetRegistration} from './bridge-target.js';
+ * @import {BankManager, Bank} from './vat-bank.js';
+ * @import {ScopedBridgeManager} from './types.js';
+ */
+/**
+ * @template {unknown[]} T
+ * @typedef {Promise<T>} PromiseVowOfTupleMappedToGenerics Temporary hack
+ *
+ *   UNTIL(microsoft/TypeScript#57122): This type should be replaced with just
+ *   PromiseVow<T>, but TypeScript doesn't understand that the result of a
+ *   mapping a tuple type using generics is iterable:
+ *
+ *   'JsonSafe<MsgTransferResponse & { '@type':
+ *   "/ibc.applications.transfer.v1.MsgTransferResponse"; }>[] |
+ *   Vow<JsonSafe<MsgTransferResponse & { ...; }>[]>' must have a
+ *   '[Symbol.iterator]()' method that returns an iterator.
+ */
+/**
+ * @typedef {{
+ *   system: ScopedBridgeManager<'vlocalchain'>;
+ *   bank: Bank;
+ *   transfer: import('./transfer.js').TransferMiddleware;
+ * }} AccountPowers
+ */
+/**
+ * @typedef {{
+ *   system: ScopedBridgeManager<'vlocalchain'>;
+ *   bankManager: BankManager;
+ *   transfer: import('./transfer.js').TransferMiddleware;
+ * }} LocalChainPowers
+ */
+export const LocalChainAccountI: import("@endo/patterns").InterfaceGuard<{
+    getAddress: import("@endo/patterns").MethodGuard;
+    getBalance: import("@endo/patterns").MethodGuard;
+    deposit: import("@endo/patterns").MethodGuard;
+    withdraw: import("@endo/patterns").MethodGuard;
+    executeTx: import("@endo/patterns").MethodGuard;
+    monitorTransfers: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareLocalChainAccountKit(zone: import("@agoric/base-zone").Zone, { watch }: VowTools): (address: string, powers: AccountPowers) => import("@endo/exo").GuardedKit<{
+    depositPaymentWatcher: {
+        /**
+         * @param {Brand<'nat'>} brand
+         * @param {{
+         *   payment: Payment<'nat'>;
+         *   optAmountShape: Amount<'nat'>;
+         * }} ctx
+         */
+        onFulfilled(brand: Brand<"nat">, { payment, optAmountShape }: {
+            payment: Payment<"nat">;
+            optAmountShape: Amount<"nat">;
+        }): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
+    };
+    account: {
+        getAddress(): string;
+        /**
+         * @param {Brand<'nat'>} brand
+         * @returns {PromiseVow<Amount<'nat'>>}
+         */
+        getBalance(brand: Brand<"nat">): PromiseVow<Amount<"nat">>;
+        /**
+         * Deposit a payment into the bank purse that matches the alleged brand.
+         * This is safe, since even if the payment lies about its brand, ERTP
+         * will reject spoofed payment objects when depositing into a purse.
+         *
+         * @param {Payment<'nat'>} payment
+         * @param {Pattern} [optAmountShape] throws if the Amount of the Payment
+         *   does not match the provided Pattern
+         * @returns {PromiseVow<Amount<'nat'>>}
+         */
+        deposit(payment: Payment<"nat">, optAmountShape?: Pattern): PromiseVow<Amount<"nat">>;
+        /**
+         * Withdraw a payment from the account's bank purse of the amount's
+         * brand.
+         *
+         * @param {Amount<'nat'>} amount
+         * @returns {PromiseVow<Payment<'nat'>>} payment
+         */
+        withdraw(amount: Amount<"nat">): PromiseVow<Payment<"nat">>;
+        /**
+         * Execute a batch of messages in order as a single atomic transaction
+         * and return the responses. If any of the messages fails, the entire
+         * batch will be rolled back. Use `typedJson()` on the arguments to get
+         * typed return values.
+         *
+         * @template {TypedJson[]} MT messages tuple (use const with multiple
+         *   elements or it will be a mixed array)
+         * @param {MT} messages
+         * @returns {PromiseVowOfTupleMappedToGenerics<{
+         *   [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>;
+         * }>}
+         */
+        executeTx<MT extends TypedJson[]>(messages: MT): PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>; }>;
+        /**
+         * @param {TargetApp} tap
+         * @returns {PromiseVow<TargetRegistration>}
+         */
+        monitorTransfers(tap: TargetApp): PromiseVow<TargetRegistration>;
+    };
+}>;
+/**
+ * @typedef {Awaited<
+ *   ReturnType<ReturnType<typeof prepareLocalChainAccountKit>>
+ * >} LocalChainAccountKit
+ */
+/** @typedef {LocalChainAccountKit['account']} LocalChainAccount */
+export const LocalChainI: import("@endo/patterns").InterfaceGuard<{
+    makeAccount: import("@endo/patterns").MethodGuard;
+    query: import("@endo/patterns").MethodGuard;
+    queryMany: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareLocalChainTools(zone: import("@agoric/base-zone").Zone, vowTools: VowTools): {
+    makeLocalChain: (powers: LocalChainPowers) => import("@endo/exo").Guarded<{
+        /**
+         * Allocate a fresh address that doesn't correspond with a public key,
+         * and follows the ICA guidelines to help reduce collisions. See
+         * x/vlocalchain/keeper/keeper.go AllocateAddress for the use of the app
+         * hash and block data hash.
+         *
+         * @returns {PromiseVow<LocalChainAccount>}
+         */
+        makeAccount(): PromiseVow<LocalChainAccount>;
+        /**
+         * Make a single query to the local chain. Will reject with an error if
+         * the query fails. Otherwise, return the response as a JSON-compatible
+         * object.
+         *
+         * @template {TypedJson} [T=TypedJson]
+         * @param {T} request
+         * @returns {PromiseVow<JsonSafe<ResponseTo<T>>>}
+         */
+        query<T extends TypedJson = {
+            '@type': string;
+        }>(request: T): PromiseVow<JsonSafe<ResponseTo<T>>>;
+        /**
+         * Send a batch of query requests to the local chain. Unless there is a
+         * system error, will return all results to indicate their success or
+         * failure.
+         *
+         * @template {import('@agoric/cosmic-proto').TypedJson[]} RT
+         * @param {RT} requests
+         * @returns {PromiseVowOfTupleMappedToGenerics<{
+         *   [K in keyof RT]: JsonSafe<{
+         *     error?: string;
+         *     reply: ResponseTo<RT[K]>;
+         *   }>;
+         * }>}
+         */
+        queryMany<RT extends import("@agoric/cosmic-proto").TypedJson[]>(requests: RT): PromiseVowOfTupleMappedToGenerics<{ [K in keyof RT]: JsonSafe<{
+            error?: string;
+            reply: ResponseTo<RT[K]>;
+        }>; }>;
+    }>;
+};
+/**
+ * Temporary hack
+ *
+ *   UNTIL(microsoft/TypeScript#57122): This type should be replaced with just
+ *   PromiseVow<T>, but TypeScript doesn't understand that the result of a
+ *   mapping a tuple type using generics is iterable:
+ *
+ *   'JsonSafe<MsgTransferResponse & { '@type':
+ *   "/ibc.applications.transfer.v1.MsgTransferResponse"; }>[] |
+ *   Vow<JsonSafe<MsgTransferResponse & { ...; }>[]>' must have a
+ *   '[Symbol.iterator]()' method that returns an iterator.
+ */
+export type PromiseVowOfTupleMappedToGenerics<T extends unknown[]> = Promise<T>;
+export type AccountPowers = {
+    system: ScopedBridgeManager<"vlocalchain">;
+    bank: Bank;
+    transfer: import("./transfer.js").TransferMiddleware;
+};
+export type LocalChainPowers = {
+    system: ScopedBridgeManager<"vlocalchain">;
+    bankManager: BankManager;
+    transfer: import("./transfer.js").TransferMiddleware;
+};
+export type LocalChainAccountKit = Awaited<ReturnType<ReturnType<typeof prepareLocalChainAccountKit>>>;
+export type LocalChainAccount = LocalChainAccountKit["account"];
+export type LocalChainTools = ReturnType<typeof prepareLocalChainTools>;
+export type LocalChain = ReturnType<LocalChainTools["makeLocalChain"]>;
+import type { VowTools } from '@agoric/vow';
+import type { PromiseVow } from '@agoric/vow';
+import type { TypedJson } from '@agoric/cosmic-proto';
+import type { ResponseTo } from '@agoric/cosmic-proto';
+import type { JsonSafe } from '@agoric/cosmic-proto';
+import type { TargetApp } from './bridge-target.js';
+import type { TargetRegistration } from './bridge-target.js';
+import type { ScopedBridgeManager } from './types.js';
+import type { Bank } from './vat-bank.js';
+import type { BankManager } from './vat-bank.js';
+//# sourceMappingURL=localchain.d.ts.map