@agoric/orchestration 0.1.1-dev-8e82183.0 → 0.1.1-dev-5a4779a.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-8e82183.0+8e82183",
+  "version": "0.1.1-dev-5a4779a.0+5a4779a",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -29,18 +29,18 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-8e82183.0+8e82183",
-    "@agoric/cosmic-proto": "0.4.1-dev-8e82183.0+8e82183",
-    "@agoric/ertp": "0.16.3-dev-8e82183.0+8e82183",
-    "@agoric/internal": "0.3.3-dev-8e82183.0+8e82183",
-    "@agoric/network": "0.1.1-dev-8e82183.0+8e82183",
-    "@agoric/notifier": "0.6.3-dev-8e82183.0+8e82183",
-    "@agoric/store": "0.9.3-dev-8e82183.0+8e82183",
-    "@agoric/time": "0.3.3-dev-8e82183.0+8e82183",
-    "@agoric/vat-data": "0.5.3-dev-8e82183.0+8e82183",
-    "@agoric/vats": "0.15.2-dev-8e82183.0+8e82183",
-    "@agoric/zoe": "0.26.3-dev-8e82183.0+8e82183",
-    "@agoric/zone": "0.2.3-dev-8e82183.0+8e82183",
+    "@agoric/assert": "0.6.1-dev-5a4779a.0+5a4779a",
+    "@agoric/cosmic-proto": "0.4.1-dev-5a4779a.0+5a4779a",
+    "@agoric/ertp": "0.16.3-dev-5a4779a.0+5a4779a",
+    "@agoric/internal": "0.3.3-dev-5a4779a.0+5a4779a",
+    "@agoric/network": "0.1.1-dev-5a4779a.0+5a4779a",
+    "@agoric/notifier": "0.6.3-dev-5a4779a.0+5a4779a",
+    "@agoric/store": "0.9.3-dev-5a4779a.0+5a4779a",
+    "@agoric/time": "0.3.3-dev-5a4779a.0+5a4779a",
+    "@agoric/vat-data": "0.5.3-dev-5a4779a.0+5a4779a",
+    "@agoric/vats": "0.15.2-dev-5a4779a.0+5a4779a",
+    "@agoric/zoe": "0.26.3-dev-5a4779a.0+5a4779a",
+    "@agoric/zone": "0.2.3-dev-5a4779a.0+5a4779a",
     "@endo/base64": "^1.0.4",
     "@endo/far": "^1.1.1",
     "@endo/marshal": "^1.4.1",
@@ -82,5 +82,5 @@
   "typeCoverage": {
     "atLeast": 96.39
   },
-  "gitHead": "8e821833bce43984d493d297c0513b474bb4532b"
+  "gitHead": "5a4779a5b0240bccd150607474d80beac23da3cd"
 }

package/src/examples/stakeAtom.contract.js

@@ -47,17 +47,17 @@ export const start = async (zcf, privateArgs, baggage) => {
     zcf,
   );
 
-  async function createAccount() {
-    const account = await E(orchestration).createAccount(
+  async function makeAccount() {
+    const account = await E(orchestration).makeAccount(
       hostConnectionId,
       controllerConnectionId,
     );
-    const accountAddress = await E(account).getAccountAddress();
-    trace('account address', accountAddress);
+    const address = await E(account).getAddress();
+    trace('chain address', address);
     const { holder, invitationMakers } = makeStakingAccountKit(
       account,
       storageNode,
-      accountAddress,
+      address,
     );
     return {
       publicSubscribers: holder.getPublicTopics(),
@@ -69,20 +69,20 @@ export const start = async (zcf, privateArgs, baggage) => {
   const publicFacet = zone.exo(
     'StakeAtom',
     M.interface('StakeAtomI', {
-      createAccount: M.callWhen().returns(M.remotable('ChainAccount')),
-      makeCreateAccountInvitation: M.call().returns(M.promise()),
+      makeAccount: M.callWhen().returns(M.remotable('ChainAccount')),
+      makeAcountInvitationMaker: M.call().returns(M.promise()),
     }),
     {
-      async createAccount() {
-        trace('createAccount');
-        return createAccount().then(({ account }) => account);
+      async makeAccount() {
+        trace('makeAccount');
+        return makeAccount().then(({ account }) => account);
       },
-      makeCreateAccountInvitation() {
+      makeAcountInvitationMaker() {
         trace('makeCreateAccountInvitation');
         return zcf.makeInvitation(
           async seat => {
             seat.exit();
-            return createAccount();
+            return makeAccount();
           },
           'wantStakingAccount',
           undefined,

package/src/examples/stakeBld.contract.js

@@ -48,7 +48,7 @@ export const start = async (zcf, privateArgs, baggage) => {
           const { give } = seat.getProposal();
           trace('makeStakeBldInvitation', give);
           // XXX type appears local but it's remote
-          const account = await E(privateArgs.localchain).createAccount();
+          const account = await E(privateArgs.localchain).makeAccount();
           const lcaSeatKit = zcf.makeEmptySeatKit();
           atomicTransfer(zcf, seat, lcaSeatKit.zcfSeat, give);
           seat.exit();

package/src/examples/swapExample.contract.js

@@ -48,11 +48,11 @@ export const start = async (zcf, privateArgs) => {
       const agoric = await orch.getChain('agoric');
 
       const [celestiaAccount, localAccount] = await Promise.all([
-        celestia.createAccount(),
-        agoric.createAccount(),
+        celestia.makeAccount(),
+        agoric.makeAccount(),
       ]);
 
-      const tiaAddress = await celestiaAccount.getChainAddress();
+      const tiaAddress = await celestiaAccount.getAddress();
 
       // deposit funds from user seat to LocalChainAccount
       const seatKit = zcf.makeEmptySeatKit();

package/src/examples/unbondExample.contract.js

@@ -47,21 +47,19 @@ export const start = async (zcf, privateArgs) => {
       // ??? could these be passed in? It would reduce the size of this handler,
       // keeping it focused on long-running operations.
       const celestia = await orch.getChain('celestia');
-      const celestiaAccount = await celestia.createAccount();
+      const celestiaAccount = await celestia.makeAccount();
 
       const delegations = await celestiaAccount.getDelegations();
-      const [undelegation] = await celestiaAccount.undelegate(delegations);
-
       // wait for the undelegations to be complete (may take weeks)
-      await undelegation.completion;
+      await celestiaAccount.undelegate(delegations);
 
       // ??? should this be synchronous? depends on how names are resolved.
       const stride = await orch.getChain('stride');
-      const strideAccount = await stride.createAccount();
+      const strideAccount = await stride.makeAccount();
 
       // TODO the `TIA` string actually needs to be the Brand from AgoricNames
       const tiaAmt = await celestiaAccount.getBalance('TIA');
-      await celestiaAccount.transfer(tiaAmt, strideAccount.getChainAddress());
+      await celestiaAccount.transfer(tiaAmt, strideAccount.getAddress());
 
       await strideAccount.liquidStake(tiaAmt);
     },

package/src/exos/chainAccountKit.js

@@ -0,0 +1,200 @@
+// @ts-check
+/** @file Orchestration service */
+import { NonNullish } from '@agoric/assert';
+import { makeTracer } from '@agoric/internal';
+
+// XXX ambient types runtime imports until https://github.com/Agoric/agoric-sdk/issues/6512
+import '@agoric/network/exported.js';
+
+import { V as E } from '@agoric/vat-data/vow.js';
+import { M } from '@endo/patterns';
+import { PaymentShape, PurseShape } from '@agoric/ertp';
+import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { parseAddress } from '../utils/address.js';
+import { makeTxPacket, parsePacketAck } from '../utils/tx.js';
+
+/**
+ * @import { Connection, Port } from '@agoric/network';
+ * @import { Remote } from '@agoric/vow';
+ * @import { Zone } from '@agoric/base-zone';
+ * @import { AnyJson } from '@agoric/cosmic-proto';
+ * @import { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+ * @import { LocalIbcAddress, RemoteIbcAddress } from '@agoric/vats/tools/ibc-utils.js';
+ * @import { ChainAddress } from '../types.js';
+ */
+
+const { Fail } = assert;
+const trace = makeTracer('ChainAccount');
+
+export const Proto3Shape = {
+  typeUrl: M.string(),
+  value: M.string(),
+};
+
+export const ChainAddressShape = {
+  address: M.string(),
+  chainId: M.string(),
+  addressEncoding: M.string(),
+};
+
+/** @typedef {'UNPARSABLE_CHAIN_ADDRESS'}  UnparsableChainAddress */
+const UNPARSABLE_CHAIN_ADDRESS = 'UNPARSABLE_CHAIN_ADDRESS';
+
+export const ChainAccountI = M.interface('ChainAccount', {
+  getAddress: M.call().returns(ChainAddressShape),
+  getLocalAddress: M.call().returns(M.string()),
+  getRemoteAddress: M.call().returns(M.string()),
+  getPort: M.call().returns(M.remotable('Port')),
+  executeTx: M.call(M.arrayOf(M.record())).returns(M.promise()),
+  executeEncodedTx: M.call(M.arrayOf(Proto3Shape))
+    .optional(M.record())
+    .returns(M.promise()),
+  close: M.callWhen().returns(M.undefined()),
+  deposit: M.callWhen(PaymentShape).returns(M.undefined()),
+  getPurse: M.callWhen().returns(PurseShape),
+  prepareTransfer: M.callWhen().returns(InvitationShape),
+});
+
+export const ConnectionHandlerI = M.interface('ConnectionHandler', {
+  onOpen: M.callWhen(M.any(), M.string(), M.string(), M.any()).returns(M.any()),
+  onClose: M.callWhen(M.any(), M.any(), M.any()).returns(M.any()),
+  onReceive: M.callWhen(M.any(), M.string()).returns(M.any()),
+});
+
+/** @param {Zone} zone */
+export const prepareChainAccountKit = zone =>
+  zone.exoClassKit(
+    'ChainAccount',
+    { account: ChainAccountI, connectionHandler: ConnectionHandlerI },
+    /**
+     * @param {Port} port
+     * @param {string} requestedRemoteAddress
+     */
+    (port, requestedRemoteAddress) =>
+      /**
+       * @type {{
+       *   port: Port;
+       *   connection: Remote<Connection> | undefined;
+       *   localAddress: LocalIbcAddress | undefined;
+       *   requestedRemoteAddress: string;
+       *   remoteAddress: RemoteIbcAddress | undefined;
+       *   chainAddress: ChainAddress | undefined;
+       * }}
+       */ (
+        harden({
+          port,
+          connection: undefined,
+          requestedRemoteAddress,
+          remoteAddress: undefined,
+          chainAddress: undefined,
+          localAddress: undefined,
+        })
+      ),
+    {
+      account: {
+        /**
+         * @returns {ChainAddress}
+         */
+        getAddress() {
+          return NonNullish(
+            this.state.chainAddress,
+            'ICA channel creation acknowledgement not yet received.',
+          );
+        },
+        getLocalAddress() {
+          return NonNullish(
+            this.state.localAddress,
+            'local address not available',
+          );
+        },
+        getRemoteAddress() {
+          return NonNullish(
+            this.state.remoteAddress,
+            'remote address not available',
+          );
+        },
+        getPort() {
+          return this.state.port;
+        },
+        executeTx() {
+          throw new Error('not yet implemented');
+        },
+        /**
+         * Submit a transaction on behalf of the remote account for execution on the remote chain.
+         * @param {AnyJson[]} msgs
+         * @param {Omit<TxBody, 'messages'>} [opts]
+         * @returns {Promise<string>} - base64 encoded bytes string. Can be decoded using the corresponding `Msg*Response` object.
+         * @throws {Error} if packet fails to send or an error is returned
+         */
+        executeEncodedTx(msgs, opts) {
+          const { connection } = this.state;
+          if (!connection) throw Fail`connection not available`;
+          return E.when(
+            E(connection).send(makeTxPacket(msgs, opts)),
+            // if parsePacketAck cannot find a `result` key, it throws
+            ack => parsePacketAck(ack),
+          );
+        },
+        /**
+         * Close the remote account
+         */
+        async close() {
+          /// XXX what should the behavior be here? and `onClose`?
+          // - retrieve assets?
+          // - revoke the port?
+          const { connection } = this.state;
+          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
+         * @param {Brand} brand
+         */
+        async getPurse(brand) {
+          console.log('getPurse got', brand);
+          throw new Error('not yet implemented');
+        },
+
+        /* transfer account to new holder */
+        async prepareTransfer() {
+          throw new Error('not yet implemented');
+        },
+      },
+      connectionHandler: {
+        /**
+         * @param {Remote<Connection>} connection
+         * @param {LocalIbcAddress} localAddr
+         * @param {RemoteIbcAddress} remoteAddr
+         */
+        async onOpen(connection, localAddr, remoteAddr) {
+          trace(`ICA Channel Opened for ${localAddr} at ${remoteAddr}`);
+          this.state.connection = connection;
+          this.state.remoteAddress = remoteAddr;
+          this.state.localAddress = localAddr;
+          // XXX parseAddress currently throws, should it return '' instead?
+          this.state.chainAddress = harden({
+            address: parseAddress(remoteAddr) || UNPARSABLE_CHAIN_ADDRESS,
+            // TODO get this from `Chain` object #9063
+            // XXX how do we get a chainId for an unknown chain? seems it may need to be a user supplied arg
+            chainId: 'FIXME',
+            addressEncoding: 'bech32',
+          });
+        },
+        async onClose(_connection, reason) {
+          trace(`ICA Channel closed. Reason: ${reason}`);
+          // XXX handle connection closing
+          // XXX is there a scenario where a connection will unexpectedly close? _I think yes_
+        },
+        async onReceive(connection, bytes) {
+          trace(`ICA Channel onReceive`, connection, bytes);
+          return '';
+        },
+      },
+    },
+  );
+
+/** @typedef {ReturnType<ReturnType<typeof prepareChainAccountKit>>} ChainAccountKit */

package/src/exos/stakingAccountKit.js

@@ -25,14 +25,14 @@ const trace = makeTracer('StakingAccountHolder');
 const { Fail } = assert;
 /**
  * @typedef {object} StakingAccountNotification
- * @property {string} address
+ * @property {ChainAddress} chainAddress
  */
 
 /**
  * @typedef {{
  *  topicKit: RecorderKit<StakingAccountNotification>;
  *  account: ChainAccount;
- *  chainAddress: string;
+ *  chainAddress: ChainAddress;
  * }} State
  */
 
@@ -71,7 +71,7 @@ export const prepareStakingAccountKit = (baggage, makeRecorderKit, zcf) => {
     /**
      * @param {ChainAccount} account
      * @param {StorageNode} storageNode
-     * @param {string} chainAddress
+     * @param {ChainAddress} chainAddress
      * @returns {State}
      */
     (account, storageNode, chainAddress) => {
@@ -94,7 +94,7 @@ export const prepareStakingAccountKit = (baggage, makeRecorderKit, zcf) => {
           return this.state.topicKit.recorder;
         },
         // TODO move this beneath the Orchestration abstraction,
-        // to the OrchestrationAccount provided by createAccount()
+        // to the OrchestrationAccount provided by makeAccount()
         /**
          * _Assumes users has already sent funds to their ICA, until #9193
          * @param {string} validatorAddress
@@ -109,7 +109,7 @@ export const prepareStakingAccountKit = (baggage, makeRecorderKit, zcf) => {
           };
 
           const account = this.facets.helper.owned();
-          const delegatorAddress = this.state.chainAddress;
+          const delegatorAddress = this.state.chainAddress.address;
 
           const result = await E(account).executeEncodedTx([
             /** @type {AnyJson} */ (

package/src/service.js

@@ -1,31 +1,22 @@
 // @ts-check
 /** @file Orchestration service */
-import { NonNullish } from '@agoric/assert';
-import { makeTracer } from '@agoric/internal';
 
 // XXX ambient types runtime imports until https://github.com/Agoric/agoric-sdk/issues/6512
 import '@agoric/network/exported.js';
 
 import { V as E } from '@agoric/vat-data/vow.js';
 import { M } from '@endo/patterns';
-import { PaymentShape, PurseShape } from '@agoric/ertp';
-import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
-import { makeICAConnectionAddress, parseAddress } from './utils/address.js';
-import { makeTxPacket, parsePacketAck } from './utils/tx.js';
+import { prepareChainAccountKit } from './exos/chainAccountKit.js';
+import { makeICAConnectionAddress } from './utils/address.js';
 
 /**
- * @import {Connection, Port, PortAllocator} from '@agoric/network';
- * @import {Remote} from '@agoric/vow';
+ * @import { PortAllocator} from '@agoric/network';
  * @import { IBCConnectionID } from '@agoric/vats';
  * @import { Zone } from '@agoric/base-zone';
- * @import { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
- * @import { AttenuatedNetwork, ChainAccount, ChainAddress } from './types.js';
+ * @import { ChainAccount } from './types.js';
  */
 
 const { Fail, bare } = assert;
-const trace = makeTracer('Orchestration');
-
-/** @import {AnyJson} from '@agoric/cosmic-proto'; */
 
 /**
  * @typedef {object} OrchestrationPowers
@@ -53,173 +44,17 @@ const getPower = (powers, name) => {
   return /** @type {OrchestrationPowers[K]} */ (powers.get(name));
 };
 
-export const Proto3Shape = {
-  typeUrl: M.string(),
-  value: M.string(),
-};
-
-export const ChainAccountI = M.interface('ChainAccount', {
-  getAccountAddress: M.call().returns(M.string()),
-  getLocalAddress: M.call().returns(M.string()),
-  getRemoteAddress: M.call().returns(M.string()),
-  getPort: M.call().returns(M.remotable('Port')),
-  executeTx: M.call(M.arrayOf(M.record())).returns(M.promise()),
-  executeEncodedTx: M.call(M.arrayOf(Proto3Shape))
-    .optional(M.record())
-    .returns(M.promise()),
-  close: M.callWhen().returns(M.undefined()),
-  deposit: M.callWhen(PaymentShape).returns(M.undefined()),
-  getPurse: M.callWhen().returns(PurseShape),
-  prepareTransfer: M.callWhen().returns(InvitationShape),
-});
-
-export const ConnectionHandlerI = M.interface('ConnectionHandler', {
-  onOpen: M.callWhen(M.any(), M.string(), M.string(), M.any()).returns(M.any()),
-  onClose: M.callWhen(M.any(), M.any(), M.any()).returns(M.any()),
-  onReceive: M.callWhen(M.any(), M.string()).returns(M.any()),
-});
-
-/** @param {Zone} zone */
-const prepareChainAccount = zone =>
-  zone.exoClassKit(
-    'ChainAccount',
-    { account: ChainAccountI, connectionHandler: ConnectionHandlerI },
-    /**
-     * @param {Port} port
-     * @param {string} requestedRemoteAddress
-     */
-    (port, requestedRemoteAddress) =>
-      /**
-       * @type {{
-       *   port: Port;
-       *   connection: Remote<Connection> | undefined;
-       *   localAddress: string | undefined;
-       *   requestedRemoteAddress: string;
-       *   remoteAddress: string | undefined;
-       *   accountAddress: string | undefined;
-       * }}
-       */ (
-        harden({
-          port,
-          connection: undefined,
-          requestedRemoteAddress,
-          remoteAddress: undefined,
-          accountAddress: undefined,
-          localAddress: undefined,
-        })
-      ),
-    {
-      account: {
-        /**
-         * @returns {string} the address of the account on the chain
-         */
-        getAccountAddress() {
-          return NonNullish(
-            this.state.accountAddress,
-            'Error parsing account address from remote address',
-          );
-        },
-        getLocalAddress() {
-          return NonNullish(
-            this.state.localAddress,
-            'local address not available',
-          );
-        },
-        getRemoteAddress() {
-          return NonNullish(
-            this.state.remoteAddress,
-            'remote address not available',
-          );
-        },
-        getPort() {
-          return this.state.port;
-        },
-        executeTx() {
-          throw new Error('not yet implemented');
-        },
-        /**
-         * Submit a transaction on behalf of the remote account for execution on the remote chain.
-         * @param {AnyJson[]} msgs
-         * @param {Omit<TxBody, 'messages'>} [opts]
-         * @returns {Promise<string>} - base64 encoded bytes string. Can be decoded using the corresponding `Msg*Response` object.
-         * @throws {Error} if packet fails to send or an error is returned
-         */
-        executeEncodedTx(msgs, opts) {
-          const { connection } = this.state;
-          if (!connection) throw Fail`connection not available`;
-          return E.when(
-            E(connection).send(makeTxPacket(msgs, opts)),
-            // if parsePacketAck cannot find a `result` key, it throws
-            ack => parsePacketAck(ack),
-          );
-        },
-        /**
-         * Close the remote account
-         */
-        async close() {
-          /// XXX what should the behavior be here? and `onClose`?
-          // - retrieve assets?
-          // - revoke the port?
-          const { connection } = this.state;
-          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
-         * @param {Brand} brand
-         */
-        async getPurse(brand) {
-          console.log('getPurse got', brand);
-          throw new Error('not yet implemented');
-        },
-
-        /* transfer account to new holder */
-        async prepareTransfer() {
-          throw new Error('not yet implemented');
-        },
-      },
-      connectionHandler: {
-        /**
-         * @param {Remote<Connection>} connection
-         * @param {string} localAddr
-         * @param {string} remoteAddr
-         */
-        async onOpen(connection, localAddr, remoteAddr) {
-          trace(`ICA Channel Opened for ${localAddr} at ${remoteAddr}`);
-          this.state.connection = connection;
-          this.state.remoteAddress = remoteAddr;
-          this.state.localAddress = localAddr;
-          // XXX parseAddress currently throws, should it return '' instead?
-          this.state.accountAddress = parseAddress(remoteAddr);
-        },
-        async onClose(_connection, reason) {
-          trace(`ICA Channel closed. Reason: ${reason}`);
-          // XXX handle connection closing
-          // XXX is there a scenario where a connection will unexpectedly close? _I think yes_
-        },
-        async onReceive(connection, bytes) {
-          trace(`ICA Channel onReceive`, connection, bytes);
-          return '';
-        },
-      },
-    },
-  );
-
 export const OrchestrationI = M.interface('Orchestration', {
-  createAccount: M.callWhen(M.string(), M.string()).returns(
+  makeAccount: M.callWhen(M.string(), M.string()).returns(
     M.remotable('ChainAccount'),
   ),
 });
 
 /**
  * @param {Zone} zone
- * @param {ReturnType<typeof prepareChainAccount>} createChainAccount
+ * @param {ReturnType<typeof prepareChainAccountKit>} makeChainAccountKit
  */
-const prepareOrchestration = (zone, createChainAccount) =>
+const prepareOrchestration = (zone, makeChainAccountKit) =>
   zone.exoClassKit(
     'Orchestration',
     {
@@ -254,20 +89,23 @@ const prepareOrchestration = (zone, createChainAccount) =>
          *   self connection_id
          * @returns {Promise<ChainAccount>}
          */
-        async createAccount(hostConnectionId, controllerConnectionId) {
+        async makeAccount(hostConnectionId, controllerConnectionId) {
           const port = await this.facets.self.bindPort();
 
           const remoteConnAddr = makeICAConnectionAddress(
             hostConnectionId,
             controllerConnectionId,
           );
-          const chainAccount = createChainAccount(port, remoteConnAddr);
+          const chainAccountKit = makeChainAccountKit(port, remoteConnAddr);
 
           // await so we do not return a ChainAccount before it successfully instantiates
-          await E(port).connect(remoteConnAddr, chainAccount.connectionHandler);
+          await E(port).connect(
+            remoteConnAddr,
+            chainAccountKit.connectionHandler,
+          );
           // XXX if we fail, should we close the port (if it was created in this flow)?
 
-          return chainAccount.account;
+          return chainAccountKit.account;
         },
       },
     },
@@ -275,14 +113,13 @@ const prepareOrchestration = (zone, createChainAccount) =>
 
 /** @param {Zone} zone */
 export const prepareOrchestrationTools = zone => {
-  const createChainAccount = prepareChainAccount(zone);
-  const makeOrchestration = prepareOrchestration(zone, createChainAccount);
+  const makeChainAccountKit = prepareChainAccountKit(zone);
+  const makeOrchestration = prepareOrchestration(zone, makeChainAccountKit);
 
   return harden({ makeOrchestration });
 };
 harden(prepareOrchestrationTools);
 
-/** @typedef {ReturnType<ReturnType<typeof prepareChainAccount>>} ChainAccountKit */
 /** @typedef {ReturnType<typeof prepareOrchestrationTools>} OrchestrationTools */
 /** @typedef {ReturnType<OrchestrationTools['makeOrchestration']>} OrchestrationKit */
 /** @typedef {OrchestrationKit['public']} OrchestrationService */

package/src/types.d.ts

@@ -4,7 +4,7 @@ import type { Invitation } from '@agoric/zoe/exported.js';
 import type { Any } from '@agoric/cosmic-proto/google/protobuf/any';
 import type { AnyJson } from '@agoric/cosmic-proto';
 import type {
-  MsgCancelUnbondingDelegation,
+  MsgBeginRedelegateResponse,
   MsgUndelegateResponse,
 } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js';
 import type {
@@ -12,6 +12,13 @@ import type {
   Redelegation,
   UnbondingDelegation,
 } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
+import type { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+import type {
+  LocalIbcAddress,
+  RemoteIbcAddress,
+} from '@agoric/vats/tools/ibc-utils.js';
+import type { Port } from '@agoric/network';
+import { MsgTransferResponse } from '@agoric/cosmic-proto/ibc/applications/transfer/v1/tx.js';
 
 /**
  * static declaration of known chain types will allow type support for
@@ -203,7 +210,7 @@ export interface Chain<C extends keyof KnownChains> {
    * Creates a new account on the remote chain.
    * @returns an object that controls a new remote account on Chain
    */
-  createAccount: () => Promise<OrchestrationAccount<C>>;
+  makeAccount: () => Promise<OrchestrationAccount<C>>;
   // FUTURE supply optional port object; also fetch port object
 
   /**
@@ -230,7 +237,7 @@ export interface ChainAccount {
   /**
    * @returns the address of the account on the remote chain
    */
-  getAccountAddress: () => string;
+  getAddress: () => ChainAddress;
   /**
    * Submit a transaction on behalf of the remote account for execution on the remote chain.
    * @param msgs - records for the transaction
@@ -239,10 +246,14 @@ export interface ChainAccount {
   executeTx: (msgs: Proto3JSONMsg[]) => Promise<string>;
   /**
    * Submit a transaction on behalf of the remote account for execution on the remote chain.
-   * @param msgs - records for the transaction
-   * @returns acknowledge string
+   * @param {AnyJson[]} msgs - records for the transaction
+   * @param {Partial<Omit<TxBody, 'messages'>>} [opts] - optional parameters for the Tx, like `timeoutHeight` and `memo`
+   * @returns acknowledgement string
    */
-  executeEncodedTx: (msgs: AnyJson[]) => Promise<string>;
+  executeEncodedTx: (
+    msgs: AnyJson[],
+    opts?: Partial<Omit<TxBody, 'messages'>>,
+  ) => Promise<string>;
   /** deposit payment from zoe to the account*/
   deposit: (payment: Payment) => Promise<void>;
   /** get Purse for a brand to .withdraw() a Payment from the account */
@@ -253,16 +264,12 @@ export interface ChainAccount {
   close: () => Promise<void>;
   /* transfer account to new holder */
   prepareTransfer: () => Promise<Invitation>;
-}
-
-export interface Undelegation {
-  cancel: () => Promise<MsgCancelUnbondingDelegation>;
-  response: MsgUndelegateResponse;
-  /**
-   * Resolves when the undelegation is complete and the tokens are no longer bonded.
-   * Note it may take weeks.
-   */
-  completion: Promise<void>;
+  /** @returns the address of the remote channel */
+  getRemoteAddress: () => RemoteIbcAddress;
+  /** @returns the address of the local channel */
+  getLocalAddress: () => LocalIbcAddress;
+  /** @returns the port the ICA channel is bound to */
+  getPort: () => Port;
 }
 
 /**
@@ -275,7 +282,7 @@ export interface BaseOrchestrationAccount {
   /**
    * @returns the address of the account on the remote chain
    */
-  getChainAddress: () => ChainAddress;
+  getAddress: () => ChainAddress;
 
   /** @returns an array of amounts for every balance in the account. */
   getBalances: () => Promise<ChainAmount[]>;
@@ -361,13 +368,14 @@ export interface BaseOrchestrationAccount {
     srcValidator: CosmosValidatorAddress,
     dstValidator: CosmosValidatorAddress,
     amount: AmountArg,
-  ) => Promise<void>;
+  ) => Promise<MsgBeginRedelegateResponse>;
 
   /**
    * Undelegate multiple delegations (concurrently). To delegate independently, pass an array with one item.
-   * @param delegations - the delegation to undelegate
+   * Resolves when the undelegation is complete and the tokens are no longer bonded. Note it may take weeks.
+   * @param {Delegation[]} delegations - the delegation to undelegate
    */
-  undelegate: (delegations: Delegation[]) => Promise<Undelegation[]>;
+  undelegate: (delegations: Delegation[]) => Promise<MsgUndelegateResponse>;
 
   /**
    * Withdraw rewards from all validators. The promise settles when the rewards are withdrawn.
@@ -396,7 +404,7 @@ export interface BaseOrchestrationAccount {
     amount: AmountArg,
     destination: ChainAddress,
     memo?: string,
-  ) => Promise<void>;
+  ) => Promise<MsgTransferResponse>;
 
   /**
    * Transfer an amount to another account in multiple steps. The promise settles when
@@ -405,7 +413,10 @@ export interface BaseOrchestrationAccount {
    * @param msg - the transfer message, including follow-up steps
    * @returns void
    */
-  transferSteps: (amount: AmountArg, msg: TransferMsg) => Promise<void>;
+  transferSteps: (
+    amount: AmountArg,
+    msg: TransferMsg,
+  ) => Promise<MsgTransferResponse>;
   /**
    * deposit payment from zoe to the account. For remote accounts,
    * an IBC Transfer will be executed to transfer funds there.
@@ -428,12 +439,11 @@ export type TransferMsg = {
   data?: object;
 };
 
-// Example
-// await icaNoble.transferSteps(usdcAmt,
-//   osmosisSwap(tiaBrand, { pool: 1224, slippage: 0.05 }, icaCel.getAddress()));
-
 /**
  * @param pool - Required. Pool number
+ * @example
+ * await icaNoble.transferSteps(usdcAmt,
+ *  osmosisSwap(tiaBrand, { pool: 1224, slippage: 0.05 }, icaCel.getAddress()));
  */
 export type OsmoSwapOptions = {
   pool: string;
@@ -452,6 +462,10 @@ export type OsmoSwapFn = (
   next: TransferMsg | ChainAddress,
 ) => TransferMsg;
 
-type AfterAction = { destChain: string; destAddress: ChainAddress };
-type SwapExact = { amountIn: Amount; amountOut: Amount };
-type SwapMaxSlippage = { amountIn: Amount; brandOut: Brand; slippage: number };
+export type AfterAction = { destChain: string; destAddress: ChainAddress };
+export type SwapExact = { amountIn: Amount; amountOut: Amount };
+export type SwapMaxSlippage = {
+  amountIn: Amount;
+  brandOut: Brand;
+  slippage: number;
+};