@agoric/orchestration 0.1.1-dev-a446a00.0 → 0.1.1-dev-ceec1d5.0

package/src/exos/chainAccountKit.js

@@ -1,15 +1,15 @@
 /** @file ChainAccount exo */
 import { NonNullish } from '@agoric/assert';
+import { PurseShape } from '@agoric/ertp';
 import { makeTracer } from '@agoric/internal';
 import { V as E } from '@agoric/vow/vat.js';
 import { M } from '@endo/patterns';
-import { PaymentShape, PurseShape } from '@agoric/ertp';
-import { findAddressField } from '../utils/address.js';
 import {
-  ConnectionHandlerI,
   ChainAddressShape,
+  ConnectionHandlerI,
   Proto3Shape,
 } from '../typeGuards.js';
+import { findAddressField } from '../utils/address.js';
 import { makeTxPacket, parseTxPacket } from '../utils/packet.js';
 
 /**
@@ -30,6 +30,8 @@ const UNPARSABLE_CHAIN_ADDRESS = 'UNPARSABLE_CHAIN_ADDRESS';
 
 export const ChainAccountI = M.interface('ChainAccount', {
   getAddress: M.call().returns(ChainAddressShape),
+  getBalance: M.callWhen(M.string()).returns(M.any()),
+  getBalances: M.callWhen().returns(M.any()),
   getLocalAddress: M.call().returns(M.string()),
   getRemoteAddress: M.call().returns(M.string()),
   getPort: M.call().returns(M.remotable('Port')),
@@ -38,7 +40,6 @@ export const ChainAccountI = M.interface('ChainAccount', {
     .optional(M.record())
     .returns(M.promise()),
   close: M.callWhen().returns(M.undefined()),
-  deposit: M.callWhen(PaymentShape).returns(M.undefined()),
   getPurse: M.callWhen().returns(PurseShape),
 });
 
@@ -63,27 +64,31 @@ export const prepareChainAccountKit = zone =>
      * @param {string} requestedRemoteAddress
      */
     (port, requestedRemoteAddress) =>
-      /** @type {State} */ (
-        harden({
-          port,
-          connection: undefined,
-          requestedRemoteAddress,
-          remoteAddress: undefined,
-          chainAddress: undefined,
-          localAddress: undefined,
-        })
-      ),
+      /** @type {State} */ ({
+        port,
+        connection: undefined,
+        requestedRemoteAddress,
+        remoteAddress: undefined,
+        chainAddress: undefined,
+        localAddress: undefined,
+      }),
     {
       account: {
-        /**
-         * @returns {ChainAddress}
-         */
+        /** @returns {ChainAddress} */
         getAddress() {
           return NonNullish(
             this.state.chainAddress,
             'ICA channel creation acknowledgement not yet received.',
           );
         },
+        getBalance(_denom) {
+          // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
+          throw new Error('not yet implemented');
+        },
+        getBalances() {
+          // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
+          throw new Error('not yet implemented');
+        },
         getLocalAddress() {
           return NonNullish(
             this.state.localAddress,
@@ -121,9 +126,7 @@ export const prepareChainAccountKit = zone =>
             ack => parseTxPacket(ack),
           );
         },
-        /**
-         * Close the remote account
-         */
+        /** Close the remote account */
         async close() {
           /// XXX what should the behavior be here? and `onClose`?
           // - retrieve assets?
@@ -132,10 +135,6 @@ export const prepareChainAccountKit = zone =>
           if (!connection) throw Fail`connection not available`;
           await E(connection).close();
         },
-        async deposit(payment) {
-          console.log('deposit got', payment);
-          throw new Error('not yet implemented');
-        },
         /**
          * get Purse for a brand to .withdraw() a Payment from the account
          *

package/src/exos/{stakingAccountKit.d.ts → cosmosOrchestrationAccount.d.ts}

@@ -1,42 +1,49 @@
 /**
- * @typedef {object} StakingAccountNotification
+ * @typedef {object} ComosOrchestrationAccountNotification
  * @property {ChainAddress} chainAddress
  */
 /**
  * @typedef {{
- *   topicKit: RecorderKit<StakingAccountNotification>;
+ *   topicKit: RecorderKit<ComosOrchestrationAccountNotification>;
  *   account: IcaAccount;
  *   chainAddress: ChainAddress;
  *   icqConnection: ICQConnection;
  *   bondDenom: string;
- *   timer: TimerService;
+ *   timer: Remote<TimerService>;
  * }} State
  */
+/** @see {OrchestrationAccountI} */
 export const IcaAccountHolderI: import("@endo/patterns").InterfaceGuard<{
+    asContinuingOffer: import("@endo/patterns").MethodGuard;
     getPublicTopics: import("@endo/patterns").MethodGuard;
-    getAddress: import("@endo/patterns").MethodGuard;
-    getBalance: import("@endo/patterns").MethodGuard;
     delegate: import("@endo/patterns").MethodGuard;
     redelegate: import("@endo/patterns").MethodGuard;
     withdrawReward: import("@endo/patterns").MethodGuard;
     withdrawRewards: import("@endo/patterns").MethodGuard;
     undelegate: import("@endo/patterns").MethodGuard;
+    getAddress: import("@endo/patterns").MethodGuard;
+    getBalance: import("@endo/patterns").MethodGuard;
+    getBalances: import("@endo/patterns").MethodGuard;
+    send: import("@endo/patterns").MethodGuard;
+    transfer: import("@endo/patterns").MethodGuard;
+    transferSteps: import("@endo/patterns").MethodGuard;
+    deposit: import("@endo/patterns").MethodGuard;
 }>;
 export const trivialDelegateResponse: string;
-export function prepareStakingAccountKit(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, zcf: ZCF): (chainAddress: ChainAddress, bondDenom: string, io: {
+export function prepareCosmosOrchestrationAccountKit(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, zcf: ZCF): (chainAddress: ChainAddress, bondDenom: string, io: {
     account: IcaAccount;
-    storageNode: StorageNode;
+    storageNode: Remote<globalThis.StorageNode>;
     icqConnection: import("@endo/exo").Guarded<{
         getLocalAddress(): `/ibc-port/${string}`;
         getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
         query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
     }>;
-    timer: TimerService;
+    timer: Remote<TimerService>;
 }) => import("@endo/exo").GuardedKit<{
     helper: {
         /** @throws if this holder no longer owns the account */
         owned(): IcaAccount;
-        getUpdater(): import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<StakingAccountNotification>;
+        getUpdater(): import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<ComosOrchestrationAccountNotification>;
         /**
          * @param {AmountArg} amount
          * @returns {Coin}
@@ -57,9 +64,7 @@ export function prepareStakingAccountKit(zone: Zone, makeRecorderKit: <T>(storag
         Redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<void, undefined>>;
         /** @param {CosmosValidatorAddress} validator */
         WithdrawReward(validator: CosmosValidatorAddress): Promise<Invitation<DenomAmount[], undefined>>;
-        /**
-         * @param {Delegation[]} delegations
-         */
+        /** @param {Delegation[]} delegations */
         Undelegate(delegations: Delegation[]): Promise<Invitation<void, undefined>>;
         CloseAccount(): never;
         /**
@@ -70,10 +75,44 @@ export function prepareStakingAccountKit(zone: Zone, makeRecorderKit: <T>(storag
         TransferAccount(): never;
     };
     holder: {
+        asContinuingOffer(): {
+            publicSubscribers: {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<ComosOrchestrationAccountNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                /**
+                 * @param {CosmosValidatorAddress} validator
+                 * @param {Amount<'nat'>} amount
+                 */
+                Delegate(validator: CosmosValidatorAddress, amount: Amount<"nat">): Promise<Invitation<void, undefined>>;
+                /**
+                 * @param {CosmosValidatorAddress} srcValidator
+                 * @param {CosmosValidatorAddress} dstValidator
+                 * @param {AmountArg} amount
+                 */
+                Redelegate(srcValidator: CosmosValidatorAddress, dstValidator: CosmosValidatorAddress, amount: AmountArg): Promise<Invitation<void, undefined>>;
+                /** @param {CosmosValidatorAddress} validator */
+                WithdrawReward(validator: CosmosValidatorAddress): Promise<Invitation<DenomAmount[], undefined>>;
+                /** @param {Delegation[]} delegations */
+                Undelegate(delegations: Delegation[]): Promise<Invitation<void, undefined>>;
+                CloseAccount(): never;
+                /**
+                 * Starting a transfer revokes the account holder. The associated
+                 * updater will get a special notification that the account is being
+                 * transferred.
+                 */
+                TransferAccount(): never;
+            }>;
+            holder: import("@endo/exo").Guarded<any>;
+        };
         getPublicTopics(): {
             account: {
                 description: string;
-                subscriber: globalThis.Subscriber<StakingAccountNotification>;
+                subscriber: globalThis.Subscriber<ComosOrchestrationAccountNotification>;
                 storagePath: Promise<string>;
             };
         };
@@ -86,6 +125,8 @@ export function prepareStakingAccountKit(zone: Zone, makeRecorderKit: <T>(storag
          * @param {AmountArg} amount
          */
         delegate(validator: CosmosValidatorAddress, amount: AmountArg): Promise<void>;
+        deposit(payment: any): Promise<void>;
+        getBalances(): Promise<never>;
         /**
          * _Assumes users has already sent funds to their ICA, until #9193
          *
@@ -100,22 +141,24 @@ export function prepareStakingAccountKit(zone: Zone, makeRecorderKit: <T>(storag
          */
         withdrawReward(validator: CosmosValidatorAddress): Promise<DenomAmount[]>;
         /**
-         * @param {DenomAmount['denom']} [denom] - defaults to bondDenom
+         * @param {DenomArg} denom
          * @returns {Promise<DenomAmount>}
          */
-        getBalance(denom?: string | undefined): Promise<DenomAmount>;
+        getBalance(denom: DenomArg): Promise<DenomAmount>;
+        send(toAccount: any, amount: any): never;
+        transfer(amount: any, msg: any): never;
+        transferSteps(amount: any, msg: any): never;
         withdrawRewards(): never;
-        /**
-         * @param {Delegation[]} delegations
-         */
+        /** @param {Delegation[]} delegations */
         undelegate(delegations: Delegation[]): Promise<void>;
     };
 }>;
-export type StakingAccountNotification = {
+export function prepareCosmosOrchestrationAccount(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, zcf: ZCF): (...args: Parameters<ReturnType<typeof prepareCosmosOrchestrationAccountKit>>) => CosmosOrchestrationAccountKit["holder"];
+export type ComosOrchestrationAccountNotification = {
     chainAddress: ChainAddress;
 };
 export type State = {
-    topicKit: RecorderKit<StakingAccountNotification>;
+    topicKit: RecorderKit<ComosOrchestrationAccountNotification>;
     account: IcaAccount;
     chainAddress: ChainAddress;
     icqConnection: import("@endo/exo").Guarded<{
@@ -124,18 +167,20 @@ export type State = {
         query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
     }>;
     bondDenom: string;
-    timer: TimerService;
+    timer: Remote<TimerService>;
 };
-export type StakingAccountKit = ReturnType<ReturnType<typeof prepareStakingAccountKit>>;
-export type StakingAccounHolder = StakingAccountKit["holder"];
+export type CosmosOrchestrationAccountKit = ReturnType<ReturnType<typeof prepareCosmosOrchestrationAccountKit>>;
+export type CosmosOrchestrationAccount = CosmosOrchestrationAccountKit["holder"];
 import type { Zone } from '@agoric/zone';
 import type { RecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
 import type { ChainAddress } from '../types.js';
 import type { IcaAccount } from '../types.js';
+import type { Remote } from '@agoric/internal';
 import type { TimerService } from '@agoric/time';
 import type { AmountArg } from '../types.js';
 import type { Coin } from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
 import type { CosmosValidatorAddress } from '../types.js';
 import type { DenomAmount } from '../types.js';
 import type { Delegation } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
-//# sourceMappingURL=stakingAccountKit.d.ts.map
+import type { DenomArg } from '../types.js';
+//# sourceMappingURL=cosmosOrchestrationAccount.d.ts.map

package/src/exos/cosmosOrchestrationAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmosOrchestrationAccount.d.ts","sourceRoot":"","sources":["cosmosOrchestrationAccount.js"],"names":[],"mappings":"AAoDA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,mCAAmC;AACnC;;;;;;;;;;;;;;;GAmBG;AAOH,6CAGE;AAgBK,mGAgCW,WAAW,GAAE,QAAS,OACnC,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,0HAnC3B,GAAG;;;;;;;;;;;QAqDN,wDAAwD;;;QAWxD;;;WAGG;;;;QAgBH;;;WAGG;4DADQ,MAAM,CAAC,KAAK,CAAC;QAUxB;;;;WAIG;;QAaH,gDAAgD;;QAShD,wCAAwC;;;QAYxC;;;;WAIG;;;;;;;;;;;;;gBAtDH;;;mBAGG;oEADQ,MAAM,CAAC,KAAK,CAAC;gBAUxB;;;;mBAIG;;gBAaH,gDAAgD;;gBAShD,wCAAwC;;;gBAYxC;;;;mBAIG;;;;;;;;;;;;QA2BH,8BAA8B;;QAI9B;;;;;WAKG;;;;QA2BH;;;;;;WAMG;;QAmBH;;;WAGG;;QAmBH;;;WAGG;;;;;;QAyCH,wCAAwC;;;GAgC/C;AAkBM,0IAlTW,MAAM,wIA2Sb,GAAG,GACD,CACZ,GAAO,IAAI,EAAE,UAAU,CACvB,UAAgB,CAAC,OAAO,oCAAoC,CAAC,CACxD,KACE,6BAA6B,CAAC,QAAQ,CAAC,CAa9C;;;;;;;;;;;;;eAjZe,MAAM;;;4CAuXT,UAAU,CACtB,UAAc,CAAC,OAAO,oCAAoC,CAAC,CACxD;yCAyBU,6BAA6B,CAAC,QAAQ,CAAC;0BAna9B,cAAc;iCALU,6CAA6C;kCADsE,aAAa;gCAAb,aAAa;4BAItJ,kBAAkB;kCACZ,cAAc;+BALqH,aAAa;0BAExJ,kDAAkD;4CAFyF,aAAa;iCAAb,aAAa;gCAGlJ,wDAAwD;8BAH6E,aAAa"}

package/src/exos/{stakingAccountKit.js → cosmosOrchestrationAccount.js}

@@ -27,7 +27,6 @@ import {
   AmountArgShape,
   ChainAddressShape,
   ChainAmountShape,
-  CoinShape,
   DelegationShape,
 } from '../typeGuards.js';
 import {
@@ -35,40 +34,47 @@ import {
   maxClockSkew,
   tryDecodeResponse,
 } from '../utils/cosmos.js';
+import { orchestrationAccountMethods } from '../utils/orchestrationAccount.js';
 import { dateInSeconds } from '../utils/time.js';
 
 /**
- * @import {AmountArg, IcaAccount, ChainAddress, CosmosValidatorAddress, ICQConnection, StakingAccountActions, DenomAmount} from '../types.js';
+ * @import {AmountArg, IcaAccount, ChainAddress, CosmosValidatorAddress, ICQConnection, StakingAccountActions, DenomAmount, OrchestrationAccountI, DenomArg} from '../types.js';
  * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js';
  * @import {Coin} from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
  * @import {Delegation} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
+ * @import {Remote} from '@agoric/internal';
  * @import {TimerService} from '@agoric/time';
  * @import {Zone} from '@agoric/zone';
  */
 
-const trace = makeTracer('StakingAccountHolder');
+const trace = makeTracer('ComosOrchestrationAccountHolder');
 
 const { Fail } = assert;
 /**
- * @typedef {object} StakingAccountNotification
+ * @typedef {object} ComosOrchestrationAccountNotification
  * @property {ChainAddress} chainAddress
  */
 
 /**
  * @typedef {{
- *   topicKit: RecorderKit<StakingAccountNotification>;
+ *   topicKit: RecorderKit<ComosOrchestrationAccountNotification>;
  *   account: IcaAccount;
  *   chainAddress: ChainAddress;
  *   icqConnection: ICQConnection;
  *   bondDenom: string;
- *   timer: TimerService;
+ *   timer: Remote<TimerService>;
  * }} State
  */
 
+/** @see {OrchestrationAccountI} */
 export const IcaAccountHolderI = M.interface('IcaAccountHolder', {
+  ...orchestrationAccountMethods,
+  asContinuingOffer: M.call().returns({
+    publicSubscribers: M.any(),
+    invitationMakers: M.any(),
+    holder: M.any(),
+  }),
   getPublicTopics: M.call().returns(TopicsRecordShape),
-  getAddress: M.call().returns(ChainAddressShape),
-  getBalance: M.callWhen().optional(M.string()).returns(CoinShape),
   delegate: M.callWhen(ChainAddressShape, AmountShape).returns(M.undefined()),
   redelegate: M.callWhen(
     ChainAddressShape,
@@ -106,8 +112,12 @@ const toDenomAmount = c => ({ denom: c.denom, value: BigInt(c.amount) });
  * @param {MakeRecorderKit} makeRecorderKit
  * @param {ZCF} zcf
  */
-export const prepareStakingAccountKit = (zone, makeRecorderKit, zcf) => {
-  const makeStakingAccountKit = zone.exoClassKit(
+export const prepareCosmosOrchestrationAccountKit = (
+  zone,
+  makeRecorderKit,
+  zcf,
+) => {
+  const makeCosmosOrchestrationAccountKit = zone.exoClassKit(
     'Staking Account Holder',
     {
       helper: M.interface('helper', {
@@ -138,9 +148,9 @@ export const prepareStakingAccountKit = (zone, makeRecorderKit, zcf) => {
      * @param {string} bondDenom e.g. 'uatom'
      * @param {object} io
      * @param {IcaAccount} io.account
-     * @param {StorageNode} io.storageNode
+     * @param {Remote<StorageNode>} io.storageNode
      * @param {ICQConnection} io.icqConnection
-     * @param {TimerService} io.timer
+     * @param {Remote<TimerService>} io.timer
      * @returns {State}
      */
     (chainAddress, bondDenom, io) => {
@@ -221,9 +231,7 @@ export const prepareStakingAccountKit = (zone, makeRecorderKit, zcf) => {
             return this.facets.holder.withdrawReward(validator);
           }, 'WithdrawReward');
         },
-        /**
-         * @param {Delegation[]} delegations
-         */
+        /** @param {Delegation[]} delegations */
         Undelegate(delegations) {
           trace('Undelegate', delegations);
 
@@ -245,6 +253,14 @@ export const prepareStakingAccountKit = (zone, makeRecorderKit, zcf) => {
         },
       },
       holder: {
+        asContinuingOffer() {
+          const { holder, invitationMakers } = this.facets;
+          return harden({
+            publicSubscribers: holder.getPublicTopics(),
+            invitationMakers,
+            holder,
+          });
+        },
         getPublicTopics() {
           const { topicKit } = this.state;
           return harden({
@@ -285,6 +301,15 @@ export const prepareStakingAccountKit = (zone, makeRecorderKit, zcf) => {
 
           expect(result, trivialDelegateResponse, 'MsgDelegateResponse');
         },
+        async deposit(payment) {
+          trace('deposit', payment);
+          console.error(
+            'FIXME deposit noop until https://github.com/Agoric/agoric-sdk/issues/9193',
+          );
+        },
+        async getBalances() {
+          throw Error('not yet implemented');
+        },
         /**
          * _Assumes users has already sent funds to their ICA, until #9193
          *
@@ -333,12 +358,12 @@ export const prepareStakingAccountKit = (zone, makeRecorderKit, zcf) => {
           return harden(coins.map(toDenomAmount));
         },
         /**
-         * @param {DenomAmount['denom']} [denom] - defaults to bondDenom
+         * @param {DenomArg} denom
          * @returns {Promise<DenomAmount>}
          */
         async getBalance(denom) {
-          const { chainAddress, icqConnection, bondDenom } = this.state;
-          denom ||= bondDenom;
+          const { chainAddress, icqConnection } = this.state;
+          // TODO #9211 lookup denom from brand
           assert.typeof(denom, 'string');
 
           const [result] = await E(icqConnection).query([
@@ -357,13 +382,26 @@ export const prepareStakingAccountKit = (zone, makeRecorderKit, zcf) => {
           return harden(toDenomAmount(balance));
         },
 
+        send(toAccount, amount) {
+          console.log('send got', toAccount, amount);
+          throw Error('not yet implemented');
+        },
+
+        transfer(amount, msg) {
+          console.log('transferSteps got', amount, msg);
+          throw Error('not yet implemented');
+        },
+
+        transferSteps(amount, msg) {
+          console.log('transferSteps got', amount, msg);
+          throw Error('not yet implemented');
+        },
+
         withdrawRewards() {
           throw assert.error('Not implemented');
         },
 
-        /**
-         * @param {Delegation[]} delegations
-         */
+        /** @param {Delegation[]} delegations */
         async undelegate(delegations) {
           trace('undelegate', delegations);
           const { helper } = this.facets;
@@ -394,18 +432,35 @@ export const prepareStakingAccountKit = (zone, makeRecorderKit, zcf) => {
     },
   );
 
-  /** check holder facet against StakingAccountActions interface. */
-  // eslint-disable-next-line no-unused-vars
-  const typeCheck = () => {
-    /** @type {any} */
-    const arg = null;
-    /** @satisfies {StakingAccountActions} */
-    // eslint-disable-next-line no-unused-vars
-    const kit = makeStakingAccountKit(arg, arg, arg).holder;
-  };
-
-  return makeStakingAccountKit;
+  return makeCosmosOrchestrationAccountKit;
 };
 
-/** @typedef {ReturnType<ReturnType<typeof prepareStakingAccountKit>>} StakingAccountKit */
-/** @typedef {StakingAccountKit['holder']} StakingAccounHolder */
+/**
+ * @typedef {ReturnType<
+ *   ReturnType<typeof prepareCosmosOrchestrationAccountKit>
+ * >} CosmosOrchestrationAccountKit
+ */
+
+/**
+ * @param {Zone} zone
+ * @param {MakeRecorderKit} makeRecorderKit
+ * @param {ZCF} zcf
+ * @returns {(
+ *   ...args: Parameters<
+ *     ReturnType<typeof prepareCosmosOrchestrationAccountKit>
+ *   >
+ * ) => CosmosOrchestrationAccountKit['holder']}
+ */
+export const prepareCosmosOrchestrationAccount = (
+  zone,
+  makeRecorderKit,
+  zcf,
+) => {
+  const makeKit = prepareCosmosOrchestrationAccountKit(
+    zone,
+    makeRecorderKit,
+    zcf,
+  );
+  return (...args) => makeKit(...args).holder;
+};
+/** @typedef {CosmosOrchestrationAccountKit['holder']} CosmosOrchestrationAccount */

package/src/exos/icqConnectionKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"icqConnectionKit.d.ts","sourceRoot":"","sources":["icqConnectionKit.js"],"names":[],"mappings":"AAoBA,2DAGE;AAEF;;;;GAIG;AA0BI;;;;QA8BC;;;;WAIG;;;;QAYH;;;;WAIG;;;;;GAgBR;;;;;;;+BAEW,UAAU,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;4BACtD,gBAAgB,CAAC,YAAY,CAAC;0BAnHrB,mBAAmB;0BACP,iBAAiB;kCAGN,+CAA+C;8BADlE,sBAAsB;mCACH,+CAA+C;gCAH1D,iBAAiB;4BAC3B,aAAa"}
+{"version":3,"file":"icqConnectionKit.d.ts","sourceRoot":"","sources":["icqConnectionKit.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"}

package/src/exos/icqConnectionKit.js

@@ -61,14 +61,12 @@ export const prepareICQConnectionKit = zone =>
      * @param {Port} port
      */
     port =>
-      /** @type {ICQConnectionKitState} */ (
-        harden({
-          port,
-          connection: undefined,
-          remoteAddress: undefined,
-          localAddress: undefined,
-        })
-      ),
+      /** @type {ICQConnectionKitState} */ ({
+        port,
+        connection: undefined,
+        remoteAddress: undefined,
+        localAddress: undefined,
+      }),
     {
       connection: {
         getLocalAddress() {

package/src/exos/local-chain-account-kit.d.ts

@@ -77,7 +77,7 @@ export function prepareLocalChainAccountKit(zone: Zone, makeRecorderKit: <T>(sto
     };
 }>;
 export type AgoricChainInfo = {
-    connections: globalThis.MapStore<string, import("@agoric/orchestration").IBCConnectionInfo>;
+    connections: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
 };
 export type LocalChainAccountNotification = {
     address: string;

package/src/exos/local-chain-account-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-chain-account-kit.d.ts","sourceRoot":"","sources":["local-chain-account-kit.js"],"names":[],"mappings":"AAsEO,0FAuED,WACD,GAAE,QACC,OAAA,WAAU,EAAE,MAAM,CAChB,WAAA,CAAC,CAAC,0HA/ED,GAAG,uEAGH,eAAe;;;0BA5Bd,MAAM,KAAK,CAAC;yBAWX,QAAQ,KAAK,CAAC,mBACZ,OAAO;yBAkBmB,OACvC,KAAK,CACP;;;uBAiBoB,EAAE;;;iBASP,WAAW;;;QAalB;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;;;;;;;;QA0BxB;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;QAsBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,IAAI,CAAC;QA2B1B;;;;WAIG;QACH,2CAA2C;yBAjKtC,QAAQ,KAAK,CAAC,mBACZ,OAAO;QAoKd,4CAA4C;yBAlJX,OACvC,KAAK,CACP;QAoJQ,6CAA6C;;;uBAnIjC,EAAE;QAwId;;WAEG;;QAIH;;;;;;;;WAQG;0GADU,OAAO,CAAC,IAAI,CAAC;;GA6CjC;;;;;aA1Pa,MAAM;;;;;;0BAOR,MAAM,KAAK,CAAC;yBAWX,QAAQ,KAAK,CAAC,mBACZ,OAAO;yBAkBmB,OACvC,KAAK,CACP;;;uBAiBoB,EAAE;;;;mCAmMR,UAAU,CAAC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC;0BAvQjD,cAAc;iCADU,6CAA6C;kCAEjD,cAAc;gCAAd,cAAc;+BAHsC,uBAAuB;kCAAvB,uBAAuB;2CAAvB,uBAAuB"}
+{"version":3,"file":"local-chain-account-kit.d.ts","sourceRoot":"","sources":["local-chain-account-kit.js"],"names":[],"mappings":"AAsEO,0FAuED,WACD,GAAE,QACC,OAAA,WAAU,EAAE,MAAM,CAChB,WAAA,CAAC,CAAC,0HA/ED,GAAG,uEAGH,eAAe;;;0BA5Bd,MAAM,KAAK,CAAC;yBAWX,QAAQ,KAAK,CAAC,mBACZ,OAAO;yBAkBmB,OACvC,KAAK,CACP;;;uBAiBoB,EAAE;;;iBASP,WAAW;;;QAalB;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;;;;;;;;QA0BxB;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;QAsBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,IAAI,CAAC;QA2B1B;;;;WAIG;QACH,2CAA2C;yBAjKtC,QAAQ,KAAK,CAAC,mBACZ,OAAO;QAoKd,4CAA4C;yBAlJX,OACvC,KAAK,CACP;QAoJQ,6CAA6C;;;uBAnIjC,EAAE;QAwId;;WAEG;;QAIH;;;;;;;;WAQG;0GADU,OAAO,CAAC,IAAI,CAAC;;GA+CjC;;;;;aA5Pa,MAAM;;;;;;0BAOR,MAAM,KAAK,CAAC;yBAWX,QAAQ,KAAK,CAAC,mBACZ,OAAO;yBAkBmB,OACvC,KAAK,CACP;;;uBAiBoB,EAAE;;;;mCAqMR,UAAU,CAAC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC;0BAzQjD,cAAc;iCADU,6CAA6C;kCAEjD,cAAc;gCAAd,cAAc;+BAHsC,uBAAuB;kCAAvB,uBAAuB;2CAAvB,uBAAuB"}

package/src/exos/local-chain-account-kit.js

@@ -243,10 +243,12 @@ export const prepareLocalChainAccountKit = (
           // TODO #9211 lookup denom from brand
           if ('brand' in amount) throw Fail`ERTP Amounts not yet supported`;
 
+          destination.chainId in agoricChainInfo.connections ||
+            Fail`Unknown chain ${destination.chainId}`;
+
           // TODO #8879 chainInfo and #9063 well-known chains
-          const { transferChannel } = agoricChainInfo.connections.get(
-            destination.chainId,
-          );
+          const { transferChannel } =
+            agoricChainInfo.connections[destination.chainId];
 
           await null;
           // set a `timeoutTimestamp` if caller does not supply either `timeoutHeight` or `timeoutTimestamp`

package/src/facade.d.ts

@@ -1,16 +1,16 @@
 export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, }: {
     zone: Zone;
-    timerService: Remote<TimerService> | null;
+    timerService: Remote<TimerService>;
     zcf: ZCF;
     storageNode: Remote<globalThis.StorageNode>;
     orchestrationService: Remote<import("@endo/exo").Guarded<{
         makeAccount(hostConnectionId: `connection-${number}`, controllerConnectionId: `connection-${number}`): Promise<import("./cosmos-api.js").IcaAccount>;
         provideICQConnection(controllerConnectionId: `connection-${number}`): Promise<import("@endo/exo").Guarded<{
-            getLocalAddress(): `/ibc-port/${string}`;
+            getLocalAddress(): `/ibc-port/${string}`; /** @type {CosmosChainInfo} */
             getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
             query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
         }>>;
-    }>> | null;
+    }>>;
     localchain: Remote<import("@endo/exo").Guarded<{
         makeAccount(): Promise<import("@endo/exo").Guarded<{
             getAddress(): Promise<string>;

package/src/facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AA8IO;;;SANG,GAAG;;;;;;;;;;;;;8BA5ER,MAAM,KAAK,CAAC;6BAeT,QAAA,KAAK,CAAC,mBACA,OAAO;6BAkBX,OAAG,KAAK,CAAC;;;2BAiBW,EAAE;;uBA6E6L,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;IA7Bp9B;;;;;;;OAOG;gBAFkC,OAAO,EACrB,IAAI,6BAHhB,MAAM,OAEoB,OAAO,AAD1B,gCACmB,OAAO,WACrB,IAAI,AADgC,KAAK,MAAM,GACzD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC;EAoBnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAtLjC,cAAc;kCACN,cAAc;4BAEpB,kBAAkB;kCAE4B,YAAY"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAuJO;;;SANG,GAAG;;;;;sDAnDO,8BAA8B;;;;;;;;8BA1CxC,MAAC,KAAK,CAAC;6BAgBP,QADG,KAAI,CAAC,mBACF,OAAO;6BAqBhB,OAAO,KAAK,CAAC;;;2BAmBhB,EAAA;;uBAyF6C,OAC7C,sBAGI,EAAE,SAAS;;;4BAEujB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;IAnChnB;;;;;;;OAOG;gBAFkC,OAAO,EACrB,IAAI,6BAHhB,MAAM,OAEoB,OAAO,AAD1B,gCACmB,OAAO,WACrB,IAAI,AADgC,KAAK,MAAM,GACzD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC;EA0BnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BApMjC,cAAc;kCACN,cAAc;4BAEpB,kBAAkB;kCAE0D,YAAY"}