@agoric/orchestration 0.1.1-dev-989aa19.0 → 0.1.1-dev-f3f87b1.0

package/src/exos/cosmos-orchestration-account.js

@@ -11,7 +11,6 @@ import {
 import {
   MsgBeginRedelegate,
   MsgDelegate,
-  MsgDelegateResponse,
   MsgUndelegate,
   MsgUndelegateResponse,
 } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js';
@@ -26,13 +25,10 @@ import {
   AmountArgShape,
   ChainAddressShape,
   ChainAmountShape,
+  CoinShape,
   DelegationShape,
 } from '../typeGuards.js';
-import {
-  encodeTxResponse,
-  maxClockSkew,
-  tryDecodeResponse,
-} from '../utils/cosmos.js';
+import { maxClockSkew, tryDecodeResponse } from '../utils/cosmos.js';
 import { orchestrationAccountMethods } from '../utils/orchestrationAccount.js';
 import { dateInSeconds } from '../utils/time.js';
 
@@ -43,7 +39,10 @@ import { dateInSeconds } from '../utils/time.js';
  * @import {Delegation} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
  * @import {Remote} from '@agoric/internal';
  * @import {TimerService} from '@agoric/time';
+ * @import {VowTools} from '@agoric/vow';
  * @import {Zone} from '@agoric/zone';
+ * @import {ResponseQuery} from '@agoric/cosmic-proto/tendermint/abci/types.js';
+ * @import {JsonSafe} from '@agoric/cosmic-proto';
  */
 
 const trace = makeTracer('ComosOrchestrationAccountHolder');
@@ -94,28 +93,19 @@ const PUBLIC_TOPICS = {
   account: ['Staking Account holder status', M.any()],
 };
 
-export const trivialDelegateResponse = encodeTxResponse(
-  {},
-  MsgDelegateResponse.toProtoMsg,
-);
-
-const expect = (actual, expected, message) => {
-  if (actual !== expected) {
-    console.log(message, { actual, expected });
-  }
-};
-
 /** @type {(c: { denom: string; amount: string }) => DenomAmount} */
 const toDenomAmount = c => ({ denom: c.denom, value: BigInt(c.amount) });
 
 /**
  * @param {Zone} zone
  * @param {MakeRecorderKit} makeRecorderKit
+ * @param {VowTools} vowTools
  * @param {ZCF} zcf
  */
 export const prepareCosmosOrchestrationAccountKit = (
   zone,
   makeRecorderKit,
+  { when, watch },
   zcf,
 ) => {
   const makeCosmosOrchestrationAccountKit = zone.exoClassKit(
@@ -126,6 +116,26 @@ export const prepareCosmosOrchestrationAccountKit = (
         getUpdater: M.call().returns(M.remotable()),
         amountToCoin: M.call(AmountArgShape).returns(M.record()),
       }),
+      returnVoidWatcher: M.interface('returnVoidWatcher', {
+        onFulfilled: M.call(M.or(M.string(), M.record()))
+          .optional(M.arrayOf(M.undefined()))
+          .returns(M.undefined()),
+      }),
+      balanceQueryWatcher: M.interface('balanceQueryWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record()))
+          .optional(M.arrayOf(M.undefined())) // empty context
+          .returns(M.or(M.record(), M.undefined())),
+      }),
+      undelegateWatcher: M.interface('undelegateWatcher', {
+        onFulfilled: M.call(M.string())
+          .optional(M.arrayOf(M.undefined())) // empty context
+          .returns(M.promise()),
+      }),
+      withdrawRewardWatcher: M.interface('withdrawRewardWatcher', {
+        onFulfilled: M.call(M.string())
+          .optional(M.arrayOf(M.undefined())) // empty context
+          .returns(M.arrayOf(CoinShape)),
+      }),
       holder: IcaAccountHolderI,
       invitationMakers: M.interface('invitationMakers', {
         Delegate: M.callWhen(ChainAddressShape, AmountArgShape).returns(
@@ -195,6 +205,59 @@ export const prepareCosmosOrchestrationAccountKit = (
           });
         },
       },
+      balanceQueryWatcher: {
+        /**
+         * @param {JsonSafe<ResponseQuery>[]} results
+         */
+        onFulfilled([result]) {
+          if (!result?.key) throw Fail`Error parsing result ${result}`;
+          const { balance } = QueryBalanceResponse.decode(
+            decodeBase64(result.key),
+          );
+          if (!balance) throw Fail`Result lacked balance key: ${result}`;
+          return harden(toDenomAmount(balance));
+        },
+      },
+      undelegateWatcher: {
+        /**
+         * @param {string} result
+         */
+        onFulfilled(result) {
+          const response = tryDecodeResponse(
+            result,
+            MsgUndelegateResponse.fromProtoMsg,
+          );
+          trace('undelegate response', response);
+          const { completionTime } = response;
+          completionTime || Fail`No completion time result ${result}`;
+          return E(this.state.timer).wakeAt(
+            dateInSeconds(completionTime) + maxClockSkew,
+          );
+        },
+      },
+      /**
+       * takes an array of results (from `executeEncodedTx`) and returns void
+       * since we are not interested in the result
+       */
+      returnVoidWatcher: {
+        /** @param {string | Record<string, unknown>} result */
+        onFulfilled(result) {
+          trace('Result', result);
+          return undefined;
+        },
+      },
+      withdrawRewardWatcher: {
+        /** @param {string} result */
+        onFulfilled(result) {
+          const response = tryDecodeResponse(
+            result,
+            MsgWithdrawDelegatorRewardResponse.fromProtoMsg,
+          );
+          trace('withdrawReward response', response);
+          const { amount: coins } = response;
+          return harden(coins.map(toDenomAmount));
+        },
+      },
       invitationMakers: {
         /**
          * @param {CosmosValidatorAddress} validator
@@ -292,7 +355,7 @@ export const prepareCosmosOrchestrationAccountKit = (
           const { helper } = this.facets;
           const { chainAddress } = this.state;
 
-          const result = await E(helper.owned()).executeEncodedTx([
+          const results = E(helper.owned()).executeEncodedTx([
             Any.toJSON(
               MsgDelegate.toProtoMsg({
                 delegatorAddress: chainAddress.address,
@@ -301,8 +364,7 @@ export const prepareCosmosOrchestrationAccountKit = (
               }),
             ),
           ]);
-
-          expect(result, trivialDelegateResponse, 'MsgDelegateResponse');
+          return when(watch(results, this.facets.returnVoidWatcher));
         },
         async deposit(payment) {
           trace('deposit', payment);
@@ -325,8 +387,7 @@ export const prepareCosmosOrchestrationAccountKit = (
           const { helper } = this.facets;
           const { chainAddress } = this.state;
 
-          // NOTE: response, including completionTime, is currently discarded.
-          await E(helper.owned()).executeEncodedTx([
+          const results = E(helper.owned()).executeEncodedTx([
             Any.toJSON(
               MsgBeginRedelegate.toProtoMsg({
                 delegatorAddress: chainAddress.address,
@@ -336,8 +397,15 @@ export const prepareCosmosOrchestrationAccountKit = (
               }),
             ),
           ]);
-        },
 
+          return when(
+            watch(
+              results,
+              // NOTE: response, including completionTime, is currently discarded.
+              this.facets.returnVoidWatcher,
+            ),
+          );
+        },
         /**
          * @param {CosmosValidatorAddress} validator
          * @returns {Promise<DenomAmount[]>}
@@ -351,14 +419,9 @@ export const prepareCosmosOrchestrationAccountKit = (
             validatorAddress: validator.address,
           });
           const account = helper.owned();
-          const result = await E(account).executeEncodedTx([Any.toJSON(msg)]);
-          const response = tryDecodeResponse(
-            result,
-            MsgWithdrawDelegatorRewardResponse.fromProtoMsg,
-          );
-          trace('withdrawReward response', response);
-          const { amount: coins } = response;
-          return harden(coins.map(toDenomAmount));
+
+          const results = E(account).executeEncodedTx([Any.toJSON(msg)]);
+          return when(watch(results, this.facets.withdrawRewardWatcher));
         },
         /**
          * @param {DenomArg} denom
@@ -372,7 +435,7 @@ export const prepareCosmosOrchestrationAccountKit = (
           // TODO #9211 lookup denom from brand
           assert.typeof(denom, 'string');
 
-          const [result] = await E(icqConnection).query([
+          const results = E(icqConnection).query([
             toRequestQueryJson(
               QueryBalanceRequest.toProtoMsg({
                 address: chainAddress.address,
@@ -380,12 +443,7 @@ export const prepareCosmosOrchestrationAccountKit = (
               }),
             ),
           ]);
-          if (!result?.key) throw Fail`Error parsing result ${result}`;
-          const { balance } = QueryBalanceResponse.decode(
-            decodeBase64(result.key),
-          );
-          if (!balance) throw Fail`Result lacked balance key: ${result}`;
-          return harden(toDenomAmount(balance));
+          return when(watch(results, this.facets.balanceQueryWatcher));
         },
 
         send(toAccount, amount) {
@@ -411,28 +469,23 @@ export const prepareCosmosOrchestrationAccountKit = (
         async undelegate(delegations) {
           trace('undelegate', delegations);
           const { helper } = this.facets;
-          const { chainAddress, bondDenom, timer } = this.state;
-
-          const result = await E(helper.owned()).executeEncodedTx(
-            delegations.map(d =>
-              Any.toJSON(
-                MsgUndelegate.toProtoMsg({
-                  delegatorAddress: chainAddress.address,
-                  validatorAddress: d.validatorAddress,
-                  amount: { denom: bondDenom, amount: d.shares },
-                }),
+          const { chainAddress, bondDenom } = this.state;
+
+          const undelegateV = watch(
+            E(helper.owned()).executeEncodedTx(
+              delegations.map(d =>
+                Any.toJSON(
+                  MsgUndelegate.toProtoMsg({
+                    delegatorAddress: chainAddress.address,
+                    validatorAddress: d.validatorAddress,
+                    amount: { denom: bondDenom, amount: d.shares },
+                  }),
+                ),
               ),
             ),
+            this.facets.undelegateWatcher,
           );
-
-          const response = tryDecodeResponse(
-            result,
-            MsgUndelegateResponse.fromProtoMsg,
-          );
-          trace('undelegate response', response);
-          const { completionTime } = response;
-
-          await E(timer).wakeAt(dateInSeconds(completionTime) + maxClockSkew);
+          return when(watch(undelegateV, this.facets.returnVoidWatcher));
         },
       },
     },
@@ -450,6 +503,7 @@ export const prepareCosmosOrchestrationAccountKit = (
 /**
  * @param {Zone} zone
  * @param {MakeRecorderKit} makeRecorderKit
+ * @param {VowTools} vowTools
  * @param {ZCF} zcf
  * @returns {(
  *   ...args: Parameters<
@@ -460,11 +514,13 @@ export const prepareCosmosOrchestrationAccountKit = (
 export const prepareCosmosOrchestrationAccount = (
   zone,
   makeRecorderKit,
+  vowTools,
   zcf,
 ) => {
   const makeKit = prepareCosmosOrchestrationAccountKit(
     zone,
     makeRecorderKit,
+    vowTools,
     zcf,
   );
   return (...args) => makeKit(...args).holder;

package/src/exos/icq-connection-kit.d.ts

@@ -4,7 +4,12 @@ export const ICQConnectionI: import("@endo/patterns").InterfaceGuard<{
     getRemoteAddress: import("@endo/patterns").MethodGuard;
     query: import("@endo/patterns").MethodGuard;
 }>;
-export function prepareICQConnectionKit(zone: Zone): (port: Port) => import("@endo/exo").GuardedKit<{
+export function prepareICQConnectionKit(zone: Zone, { watch, when }: {
+    when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
+    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+}): (port: Port) => import("@endo/exo").GuardedKit<{
     connection: {
         getLocalAddress(): `/ibc-port/${string}`;
         getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
@@ -15,6 +20,10 @@ export function prepareICQConnectionKit(zone: Zone): (port: Port) => import("@en
          */
         query(msgs: JsonSafe<RequestQuery>[]): Promise<JsonSafe<ResponseQuery>[]>;
     };
+    parseQueryPacketWatcher: {
+        /** @param {string} ack packet acknowledgement string */
+        onFulfilled(ack: string): JsonSafe<ResponseQuery>[];
+    };
     connectionHandler: {
         /**
          * @param {Remote<Connection>} connection

package/src/exos/icq-connection-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"icq-connection-kit.d.ts","sourceRoot":"","sources":["icq-connection-kit.js"],"names":[],"mappings":"AAoBA,2DAGE;AAEF;;;;GAIG;AA0BI;;;;QA4BC;;;;WAIG;;;;QAYH;;;;WAIG;;;;;GAgBR;;;;;;;+BAEW,UAAU,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;4BACtD,gBAAgB,CAAC,YAAY,CAAC;0BAjHrB,mBAAmB;0BACP,iBAAiB;kCAGN,+CAA+C;8BADlE,sBAAsB;mCACH,+CAA+C;gCAH1D,iBAAiB;4BAC3B,aAAa"}
+{"version":3,"file":"icq-connection-kit.d.ts","sourceRoot":"","sources":["icq-connection-kit.js"],"names":[],"mappings":"AAoBA,2DAGE;AAEF;;;;GAIG;AA2BI;wFA7CqC,CAAC;;;oBAW7B,SAAS;;;;;QAoEjB;;;;WAIG;;;;QAeH,wDAAwD;yBAA5C,MAAM;;;QAMlB;;;;WAIG;;;;;GAgBR;;;;;;;+BAEW,UAAU,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;4BACtD,gBAAgB,CAAC,YAAY,CAAC;0BAjIrB,mBAAmB;0BACP,iBAAiB;kCAGN,+CAA+C;8BADlE,sBAAsB;mCACH,+CAA+C;gCAH1D,iBAAiB;4BACjB,aAAa"}

package/src/exos/icq-connection-kit.js

@@ -1,7 +1,7 @@
 /** @file ICQConnection Exo */
 import { NonNullish } from '@agoric/assert';
 import { makeTracer } from '@agoric/internal';
-import { V as E } from '@agoric/vow/vat.js';
+import { E } from '@endo/far';
 import { M } from '@endo/patterns';
 import { makeQueryPacket, parseQueryPacket } from '../utils/packet.js';
 import { ConnectionHandlerI } from '../typeGuards.js';
@@ -9,7 +9,7 @@ import { ConnectionHandlerI } from '../typeGuards.js';
 /**
  * @import {Zone} from '@agoric/base-zone';
  * @import {Connection, Port} from '@agoric/network';
- * @import {Remote} from '@agoric/vow';
+ * @import {Remote, VowTools} from '@agoric/vow';
  * @import {JsonSafe} from '@agoric/cosmic-proto';
  * @import {RequestQuery, ResponseQuery} from '@agoric/cosmic-proto/tendermint/abci/types.js';
  * @import {LocalIbcAddress, RemoteIbcAddress} from '@agoric/vats/tools/ibc-utils.js';
@@ -52,14 +52,21 @@ export const ICQConnectionI = M.interface('ICQConnection', {
  * sending queries and handling connection events.
  *
  * @param {Zone} zone
+ * @param {VowTools} vowTools
  */
-export const prepareICQConnectionKit = zone =>
+export const prepareICQConnectionKit = (zone, { watch, when }) =>
   zone.exoClassKit(
     'ICQConnectionKit',
-    { connection: ICQConnectionI, connectionHandler: ConnectionHandlerI },
-    /**
-     * @param {Port} port
-     */
+    {
+      connection: ICQConnectionI,
+      connectionHandler: ConnectionHandlerI,
+      parseQueryPacketWatcher: M.interface('ParseQueryPacketWatcher', {
+        onFulfilled: M.call(M.string())
+          .optional(M.arrayOf(M.undefined())) // does not need watcherContext
+          .returns(M.arrayOf(M.record())),
+      }),
+    },
+    /** @param {Port} port */
     port =>
       /** @type {ICQConnectionKitState} */ ({
         port,
@@ -88,14 +95,23 @@ export const prepareICQConnectionKit = zone =>
          */
         query(msgs) {
           const { connection } = this.state;
+          // TODO #9281 do not throw synchronously when returning a promise; return a rejected Vow
+          /// see https://github.com/Agoric/agoric-sdk/pull/9454#discussion_r1626898694
           if (!connection) throw Fail`connection not available`;
-          return E.when(
-            E(connection).send(makeQueryPacket(msgs)),
-            // if parseTxPacket cannot find a `result` key, it throws
-            ack => parseQueryPacket(ack),
+          return when(
+            watch(
+              E(connection).send(makeQueryPacket(msgs)),
+              this.facets.parseQueryPacketWatcher,
+            ),
           );
         },
       },
+      parseQueryPacketWatcher: {
+        /** @param {string} ack packet acknowledgement string */
+        onFulfilled(ack) {
+          return parseQueryPacket(ack);
+        },
+      },
       connectionHandler: {
         /**
          * @param {Remote<Connection>} connection

package/src/exos/local-chain-facade.d.ts

@@ -14,12 +14,50 @@ export function prepareLocalChainFacade(zone: Zone, { makeLocalOrchestrationAcco
         storageNode: Remote<globalThis.StorageNode>;
     }) => import("@endo/exo").GuardedKit<{
         invitationMakers: {
-            Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgDelegateResponse & {
-                '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
-            }>, undefined>>;
-            Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<void, undefined>>;
+            Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<Record<unknown, unknown>, undefined>>;
+            Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<void | import("@agoric/time").TimestampRecord | import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>, undefined>>;
             CloseAccount(): never;
         };
+        undelegateWatcher: {
+            onFulfilled(response: [import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgUndelegateResponse & {
+                '@type': "/cosmos.staking.v1beta1.MsgUndelegateResponse";
+            }]): Promise<import("@agoric/time").TimestampRecord>;
+        };
+        getChainInfoWatcher: {
+            onFulfilled(agoricChainInfo: ChainInfo, { destination }: {
+                destination: import("../orchestration-api.js").ChainAddress;
+            }): Promise<IBCConnectionInfo>;
+        };
+        getTimeoutTimestampWatcher: {
+            onFulfilled(timeoutTimestamp: bigint, { opts }: {
+                opts: import("../cosmos-api.js").IBCMsgTransferOptions;
+            }): bigint;
+        };
+        transferWatcher: {
+            onFulfilled([{ transferChannel }, timeoutTimestamp]: [{
+                transferChannel: {
+                    portId: string;
+                    channelId: `channel-${number}`;
+                    counterPartyPortId: string;
+                    counterPartyChannelId: `channel-${number}`;
+                    ordering: import("@agoric/cosmic-proto/ibc/core/channel/v1/channel.js").Order;
+                    state: import("@agoric/cosmic-proto/ibc/core/channel/v1/channel.js").State;
+                    version: string;
+                };
+            }, bigint], { opts, amount, destination }: {
+                destination: import("../orchestration-api.js").ChainAddress;
+                opts: import("../cosmos-api.js").IBCMsgTransferOptions;
+                amount: import("../orchestration-api.js").DenomAmount;
+            }): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/ibc/applications/transfer/v1/tx.js").MsgTransferResponse & {
+                '@type': "/ibc.applications.transfer.v1.MsgTransferResponse";
+            }>[]>;
+        };
+        extractFirstResultWatcher: {
+            onFulfilled(results: Record<unknown, unknown>[]): Record<unknown, unknown>;
+        };
+        returnVoidWatcher: {
+            onFulfilled(results: Record<unknown, unknown>[]): undefined;
+        };
         holder: {
             getBalance(denom: DenomArg): Promise<import("../orchestration-api.js").DenomAmount>;
             getBalances(): never;
@@ -30,10 +68,8 @@ export function prepareLocalChainFacade(zone: Zone, { makeLocalOrchestrationAcco
                     storagePath: Promise<string>;
                 };
             };
-            delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgDelegateResponse & {
-                '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
-            }>>;
-            undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<void>;
+            delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Record<unknown, unknown>>;
+            undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").PromiseVow<void | import("@agoric/time").TimestampRecord>;
             deposit(payment: globalThis.Payment<"nat">): Promise<void>;
             withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
             executeTx<MT extends {
@@ -100,6 +136,7 @@ export function prepareLocalChainFacade(zone: Zone, { makeLocalOrchestrationAcco
 export type MakeLocalChainFacade = ReturnType<typeof prepareLocalChainFacade>;
 import type { Zone } from '@agoric/base-zone';
 import type { Remote } from '@agoric/internal';
-import type { TimerService } from '@agoric/time';
+import type { ChainInfo } from '../types.js';
 import type { IBCConnectionInfo } from '../types.js';
+import type { TimerService } from '@agoric/time';
 //# sourceMappingURL=local-chain-facade.d.ts.map

package/src/exos/local-chain-facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AAyBO;;;;8BA0C6pC,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;2DAAxlD,OAAO,KAAK,CAAC;;;6DAAid,OAAO,KAAK,CAAC;;;;8BAA0tB,QAAS;;;;;;;;;2DAAiyB,OAAO,KAAK,CAAC;;;6DAA+yB,OAAO,KAAK,CAAC;;6BAA56D,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;kCAA46B,SAAU,OAAM,WAAY;;;;;;;;;;;;;;;;8BAAvxF,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;;;;;;;;;;;;;;;;;IAtBloN,0DAA0D;;GAmB7D;mCAEW,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA5DjC,mBAAmB;4BAEjB,kBAAkB;kCADZ,cAAc;uCAKyC,aAAa"}
+{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AAyBO;;;;8BA0C4mC,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;2DAAiI,OAAO,KAAK,CAAC;6DAAid,OAAO,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAgkG,wBAAwB,EAAE;;;iCAAsZ,wBAAwB,EAAE;;;8BAAzgJ,QAAS;;;;;;;;;2DAAywL,OAAO,KAAK,CAAC;6DAAksB,OAAO,KAAK,CAAC;;6BAAvyN,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;kCAA46B,SAAU,OAAM,WAAY;;;;;;;;;;;;;;;;8BAAvxF,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;;;;;;;;;;;;;;;;;IAtBjlN,0DAA0D;;GAmB7D;mCAEW,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA5DjC,mBAAmB;4BAEjB,kBAAkB;+BAI2C,aAAa;uCAAb,aAAa;kCALpE,cAAc"}

package/src/exos/local-chain-facade.js

@@ -55,7 +55,7 @@ export const prepareLocalChainFacade = (
             chainId: localChainInfo.chainId,
             addressEncoding: 'bech32',
           }),
-          // FIXME storage path
+          // FIXME storage path https://github.com/Agoric/agoric-sdk/issues/9066
           storageNode,
         });