@agoric/orchestration 0.1.1-dev-81a66f2.0 → 0.1.1-dev-e468caa.0

package/index.js

@@ -1,4 +1,5 @@
 // eslint-disable-next-line import/export
 export * from './src/types.js';
 export * from './src/utils/address.js';
+export * from './src/utils/tx.js';
 export * from './src/orchestration.js';

package/package.json

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

package/src/contracts/localchainAccountHolder.js

@@ -1,5 +1,6 @@
 // @ts-check
 /** @file Use-object for the owner of a localchain account */
+import { typedJson } from '@agoric/cosmic-proto/vatsafe';
 import { AmountShape } from '@agoric/ertp';
 import { makeTracer } from '@agoric/internal';
 import { UnguardedHelperI } from '@agoric/internal/src/typeGuards.js';
@@ -114,7 +115,7 @@ export const prepareAccountHolder = (baggage, makeRecorderKit, zcf) => {
           // FIXME get values from proposal or args
           // FIXME brand handling and amount scaling
           const amount = {
-            amount: ertpAmount.value,
+            amount: String(ertpAmount.value),
             denom: 'ubld',
           };
 
@@ -126,12 +127,11 @@ export const prepareAccountHolder = (baggage, makeRecorderKit, zcf) => {
             const delegatorAddress = await E(lca).getAddress();
             trace('delegatorAddress', delegatorAddress);
             const result = await E(lca).executeTx([
-              {
-                '@type': '/cosmos.staking.v1beta1.MsgDelegate',
+              typedJson('/cosmos.staking.v1beta1.MsgDelegate', {
                 amount,
                 validatorAddress,
                 delegatorAddress,
-              },
+              }),
             ]);
             trace('got result', result);
             return result;

package/src/contracts/stakeAtom.contract.js

@@ -2,20 +2,24 @@
 /**
  * @file Example contract that uses orchestration
  */
-
+import { makeTracer } from '@agoric/internal';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 import { V as E } from '@agoric/vat-data/vow.js';
 import { M } from '@endo/patterns';
+import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport';
+import { prepareStakingAccountHolder } from './stakingAccountHolder.js';
 
+const trace = makeTracer('StakeAtom');
 /**
- * @import * as orchestration from '../types'
- * @import * as vatData from '@agoric/vat-data'
+ * @import { Orchestration } from '../types.js';
+ * @import { Baggage } from '@agoric/vat-data';
+ * @import { IBCConnectionID } from '@agoric/vats';
  */
 
 /**
  * @typedef {{
- *  hostConnectionId: orchestration.ConnectionId;
- *  controllerConnectionId: orchestration.ConnectionId;
+ *  hostConnectionId: IBCConnectionID;
+ *  controllerConnectionId: IBCConnectionID;
  * }} StakeAtomTerms
  */
 
@@ -23,26 +27,66 @@ import { M } from '@endo/patterns';
  *
  * @param {ZCF<StakeAtomTerms>} zcf
  * @param {{
- *   orchestration: orchestration.Orchestration;
+ *  orchestration: Orchestration;
+ *  storageNode: StorageNode;
+ *  marshaller: Marshaller;
  * }} privateArgs
- * @param {vatData.Baggage} baggage
+ * @param {Baggage} baggage
  */
 export const start = async (zcf, privateArgs, baggage) => {
   const { hostConnectionId, controllerConnectionId } = zcf.getTerms();
-  const { orchestration } = privateArgs;
+  const { orchestration, marshaller, storageNode } = privateArgs;
 
   const zone = makeDurableZone(baggage);
 
+  const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
+
+  const makeStakingAccountHolder = prepareStakingAccountHolder(
+    baggage,
+    makeRecorderKit,
+    zcf,
+  );
+
+  async function createAccount() {
+    const account = await E(orchestration).createAccount(
+      hostConnectionId,
+      controllerConnectionId,
+    );
+    const accountAddress = await E(account).getAccountAddress();
+    trace('account address', accountAddress);
+    const { holder, invitationMakers } = makeStakingAccountHolder(
+      account,
+      storageNode,
+      accountAddress,
+    );
+    return {
+      publicSubscribers: holder.getPublicTopics(),
+      invitationMakers,
+      account: holder,
+    };
+  }
+
   const publicFacet = zone.exo(
     'StakeAtom',
     M.interface('StakeAtomI', {
       createAccount: M.callWhen().returns(M.remotable('ChainAccount')),
+      makeCreateAccountInvitation: M.call().returns(M.promise()),
     }),
     {
       async createAccount() {
-        return E(orchestration).createAccount(
-          hostConnectionId,
-          controllerConnectionId,
+        trace('createAccount');
+        return createAccount().then(({ account }) => account);
+      },
+      makeCreateAccountInvitation() {
+        trace('makeCreateAccountInvitation');
+        return zcf.makeInvitation(
+          async seat => {
+            seat.exit();
+            return createAccount();
+          },
+          'wantStakingAccount',
+          undefined,
+          undefined,
         );
       },
     },
@@ -50,3 +94,5 @@ export const start = async (zcf, privateArgs, baggage) => {
 
   return { publicFacet };
 };
+
+/** @typedef {typeof start} StakeAtomSF */

package/src/contracts/stakingAccountHolder.js

@@ -0,0 +1,192 @@
+// @ts-check
+/** @file Use-object for the owner of a staking account */
+import {
+  MsgDelegate,
+  MsgDelegateResponse,
+} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js';
+import { AmountShape } from '@agoric/ertp';
+import { makeTracer } from '@agoric/internal';
+import { UnguardedHelperI } from '@agoric/internal/src/typeGuards.js';
+import { M, prepareExoClassKit } from '@agoric/vat-data';
+import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/index.js';
+import { decodeBase64 } from '@endo/base64';
+import { E } from '@endo/far';
+import { txToBase64 } from '../utils/tx.js';
+
+/**
+ * @import { ChainAccount, ChainAddress } from '../types.js';
+ * @import { RecorderKit, MakeRecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+ * @import { Baggage } from '@agoric/swingset-liveslots';
+ */
+
+const trace = makeTracer('StakingAccountHolder');
+
+const { Fail } = assert;
+/**
+ * @typedef {object} StakingAccountNotification
+ * @property {string} address
+ */
+
+/**
+ * @typedef {{
+ *  topicKit: RecorderKit<StakingAccountNotification>;
+ *  account: ChainAccount;
+ *  chainAddress: ChainAddress;
+ * }} State
+ */
+
+const HolderI = M.interface('holder', {
+  getPublicTopics: M.call().returns(TopicsRecordShape),
+  makeDelegateInvitation: M.call(M.string(), AmountShape).returns(M.promise()),
+  makeCloseAccountInvitation: M.call().returns(M.promise()),
+  makeTransferAccountInvitation: M.call().returns(M.promise()),
+  delegate: M.callWhen(M.string(), AmountShape).returns(M.string()),
+});
+
+/** @type {{ [name: string]: [description: string, valueShape: Pattern] }} */
+const PUBLIC_TOPICS = {
+  account: ['Staking Account holder status', M.any()],
+};
+
+/**
+ * @param {Baggage} baggage
+ * @param {MakeRecorderKit} makeRecorderKit
+ * @param {ZCF} zcf
+ */
+export const prepareStakingAccountHolder = (baggage, makeRecorderKit, zcf) => {
+  const makeAccountHolderKit = prepareExoClassKit(
+    baggage,
+    'Staking Account Holder',
+    {
+      helper: UnguardedHelperI,
+      holder: HolderI,
+      invitationMakers: M.interface('invitationMakers', {
+        Delegate: HolderI.payload.methodGuards.makeDelegateInvitation,
+        CloseAccount: HolderI.payload.methodGuards.makeCloseAccountInvitation,
+        TransferAccount:
+          HolderI.payload.methodGuards.makeTransferAccountInvitation,
+      }),
+    },
+    /**
+     * @param {ChainAccount} account
+     * @param {StorageNode} storageNode
+     * @param {ChainAddress} chainAddress
+     * @returns {State}
+     */
+    (account, storageNode, chainAddress) => {
+      // must be the fully synchronous maker because the kit is held in durable state
+      const topicKit = makeRecorderKit(storageNode, PUBLIC_TOPICS.account[1]);
+
+      return { account, chainAddress, topicKit };
+    },
+    {
+      helper: {
+        /** @throws if this holder no longer owns the account */
+        owned() {
+          const { account } = this.state;
+          if (!account) {
+            throw Fail`Using account holder after transfer`;
+          }
+          return account;
+        },
+        getUpdater() {
+          return this.state.topicKit.recorder;
+        },
+        /**
+         * _Assumes users has already sent funds to their ICA, until #9193
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        async delegate(validatorAddress, ertpAmount) {
+          // FIXME get values from proposal or args
+          // FIXME brand handling and amount scaling
+          const amount = {
+            amount: String(ertpAmount.value),
+            denom: 'uatom',
+          };
+
+          const account = this.facets.helper.owned();
+          const delegatorAddress = this.state.chainAddress;
+
+          const result = await E(account).executeEncodedTx([
+            txToBase64(
+              MsgDelegate.toProtoMsg({
+                delegatorAddress,
+                validatorAddress,
+                amount,
+              }),
+            ),
+          ]);
+
+          if (!result) throw Fail`Failed to delegate.`;
+          try {
+            const decoded = MsgDelegateResponse.decode(decodeBase64(result));
+            if (JSON.stringify(decoded) === '{}') return 'Success';
+            throw Fail`Unexpected response: ${result}`;
+          } catch (e) {
+            throw Fail`Unable to decode result: ${result}`;
+          }
+        },
+      },
+      invitationMakers: {
+        Delegate(validatorAddress, amount) {
+          return this.facets.holder.makeDelegateInvitation(
+            validatorAddress,
+            amount,
+          );
+        },
+        CloseAccount() {
+          return this.facets.holder.makeCloseAccountInvitation();
+        },
+        TransferAccount() {
+          return this.facets.holder.makeTransferAccountInvitation();
+        },
+      },
+      holder: {
+        getPublicTopics() {
+          const { topicKit } = this.state;
+          return harden({
+            account: {
+              description: PUBLIC_TOPICS.account[0],
+              subscriber: topicKit.subscriber,
+              storagePath: topicKit.recorder.getStoragePath(),
+            },
+          });
+        },
+        /**
+         *
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        async delegate(validatorAddress, ertpAmount) {
+          trace('delegate', validatorAddress, ertpAmount);
+          return this.facets.helper.delegate(validatorAddress, ertpAmount);
+        },
+        /**
+         *
+         * @param {string} validatorAddress
+         * @param {Amount<'nat'>} ertpAmount
+         */
+        makeDelegateInvitation(validatorAddress, ertpAmount) {
+          trace('makeDelegateInvitation', validatorAddress, ertpAmount);
+
+          return zcf.makeInvitation(async seat => {
+            seat.exit();
+            return this.facets.helper.delegate(validatorAddress, ertpAmount);
+          }, 'Delegate');
+        },
+        makeCloseAccountInvitation() {
+          throw Error('not yet implemented');
+        },
+        /**
+         * Starting a transfer revokes the account holder. The associated updater
+         * will get a special notification that the account is being transferred.
+         */
+        makeTransferAccountInvitation() {
+          throw Error('not yet implemented');
+        },
+      },
+    },
+  );
+  return makeAccountHolderKit;
+};

package/src/orchestration.js

@@ -5,24 +5,27 @@ import { makeTracer } from '@agoric/internal';
 import { V as E } from '@agoric/vat-data/vow.js';
 import { M } from '@endo/patterns';
 import { makeICAConnectionAddress, parseAddress } from './utils/address.js';
+import { makeTxPacket, parsePacketAck } from './utils/tx.js';
 import '@agoric/network/exported.js';
 
 /**
- * @import { ConnectionId } from './types';
+ * @import { AttenuatedNetwork } from './types.js';
+ * @import { IBCConnectionID } from '@agoric/vats';
  * @import { Zone } from '@agoric/base-zone';
+ * @import { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
  */
 
 const { Fail, bare } = assert;
 const trace = makeTracer('Orchestration');
 
+/** @import {Proto3Msg} from './utils/tx.js'; */
+
 // TODO improve me
 /** @typedef {string} ChainAddress */
 
 /**
  * @typedef {object} OrchestrationPowers
- * @property {ERef<
- *   import('@agoric/orchestration/src/types').AttenuatedNetwork
- * >} network
+ * @property {ERef<AttenuatedNetwork>} network
  */
 
 /**
@@ -46,11 +49,19 @@ 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')),
+  executeEncodedTx: M.call(M.arrayOf(Proto3Shape))
+    .optional(M.record())
+    .returns(M.promise()),
   close: M.callWhen().returns(M.string()),
 });
 
@@ -73,7 +84,7 @@ const prepareChainAccount = zone =>
       /**
        * @type {{
        *   port: Port;
-       *   connection: Connection | undefined;
+       *   connection: Remote<Connection> | undefined;
        *   localAddress: string | undefined;
        *   requestedRemoteAddress: string;
        *   remoteAddress: string | undefined;
@@ -112,24 +123,34 @@ const prepareChainAccount = zone =>
         getPort() {
           return this.state.port;
         },
+        /**
+         * @param {Proto3Msg[]} 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),
+          );
+        },
         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 null;
-          try {
-            await E(connection).close();
-          } catch (e) {
-            throw Fail`Failed to close connection: ${e}`;
-          }
+          await E(connection).close();
           return 'Connection closed';
         },
       },
       connectionHandler: {
         /**
-         * @param {Connection} connection
+         * @param {Remote<Connection>} connection
          * @param {string} localAddr
          * @param {string} remoteAddr
          */
@@ -188,18 +209,18 @@ const prepareOrchestration = (zone, createChainAccount) =>
       self: {
         async bindPort() {
           const network = getPower(this.state.powers, 'network');
-          const port = await E(network)
-            .bind(`/ibc-port/icacontroller-${this.state.icaControllerNonce}`)
-            .catch(e => Fail`Failed to bind port: ${e}`);
+          const port = await E(network).bind(
+            `/ibc-port/icacontroller-${this.state.icaControllerNonce}`,
+          );
           this.state.icaControllerNonce += 1;
           return port;
         },
       },
       public: {
         /**
-         * @param {ConnectionId} hostConnectionId
+         * @param {IBCConnectionID} hostConnectionId
          *   the counterparty connection_id
-         * @param {ConnectionId} controllerConnectionId
+         * @param {IBCConnectionID} controllerConnectionId
          *   self connection_id
          * @returns {Promise<ChainAccount>}
          */
@@ -213,10 +234,8 @@ const prepareOrchestration = (zone, createChainAccount) =>
           const chainAccount = createChainAccount(port, remoteConnAddr);
 
           // await so we do not return a ChainAccount before it successfully instantiates
-          await E(port)
-            .connect(remoteConnAddr, chainAccount.connectionHandler)
-            // XXX if we fail, should we close the port (if it was created in this flow)?
-            .catch(e => Fail`Failed to create ICA connection: ${bare(e)}`);
+          await E(port).connect(remoteConnAddr, chainAccount.connectionHandler);
+          // XXX if we fail, should we close the port (if it was created in this flow)?
 
           return chainAccount.account;
         },

package/src/proposals/start-stakeAtom.js

@@ -1,16 +1,25 @@
 // @ts-check
 import { makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
 import { E } from '@endo/far';
 
+/** @import { StakeAtomSF,  StakeAtomTerms} from '../contracts/stakeAtom.contract' */
+
 const trace = makeTracer('StartStakeAtom', true);
 
 /**
  * @param {BootstrapPowers & { installation: {consume: {stakeAtom: Installation<import('../contracts/stakeAtom.contract.js').start>}}}} powers
- * @param {{options: import('../contracts/stakeAtom.contract.js').StakeAtomTerms}} options
+ * @param {{options: StakeAtomTerms }} options
  */
 export const startStakeAtom = async (
   {
-    consume: { orchestration, startUpgradable },
+    consume: {
+      agoricNames,
+      board,
+      chainStorage,
+      orchestration,
+      startUpgradable,
+    },
     installation: {
       consume: { stakeAtom },
     },
@@ -20,19 +29,28 @@ export const startStakeAtom = async (
   },
   { options: { hostConnectionId, controllerConnectionId } },
 ) => {
+  const VSTORAGE_PATH = 'stakeAtom';
   trace('startStakeAtom', { hostConnectionId, controllerConnectionId });
   await null;
 
-  /** @type {StartUpgradableOpts<import('../contracts/stakeAtom.contract.js').start>} */
+  const storageNode = await makeStorageNodeChild(chainStorage, VSTORAGE_PATH);
+  const marshaller = await E(board).getPublishingMarshaller();
+  const atomIssuer = await E(agoricNames).lookup('issuer', 'ATOM');
+  trace('ATOM Issuer', atomIssuer);
+
+  /** @type {StartUpgradableOpts<StakeAtomSF>} */
   const startOpts = {
     label: 'stakeAtom',
     installation: stakeAtom,
+    issuerKeywordRecord: harden({ ATOM: atomIssuer }),
     terms: {
       hostConnectionId,
       controllerConnectionId,
     },
     privateArgs: {
       orchestration: await orchestration,
+      storageNode,
+      marshaller,
     },
   };
 
@@ -49,6 +67,9 @@ export const getManifestForStakeAtom = (
     manifest: {
       [startStakeAtom.name]: {
         consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
           orchestration: true,
           startUpgradable: true,
         },

package/src/types.d.ts

@@ -1,8 +1,7 @@
 import type { RouterProtocol } from '@agoric/network/src/router';
 
-export type ConnectionId = `connection-${number}`;
-
 export type AttenuatedNetwork = Pick<RouterProtocol, 'bind'>;
 
 export type * from './orchestration.js';
 export type * from './vat-orchestration.js';
+export type * from './utils/tx.js';

package/src/utils/address.js

@@ -1,11 +1,11 @@
 // @ts-check
 import { Fail } from '@agoric/assert';
 
-/** @import { ConnectionId } from '../types'; */
+/** @import { IBCConnectionID } from '@agoric/vats'; */
 
 /**
- * @param {ConnectionId} hostConnectionId Counterpart Connection ID
- * @param {ConnectionId} controllerConnectionId Self Connection ID
+ * @param {IBCConnectionID} hostConnectionId Counterpart Connection ID
+ * @param {IBCConnectionID} controllerConnectionId Self Connection ID
  * @param {object} [opts]
  * @param {string} [opts.encoding] - message encoding format for the channel. default is `proto3`
  * @param {'ordered' | 'unordered'} [opts.ordering] - channel ordering. currently only `ordered` is supported for ics27-1

package/src/utils/tx.js

@@ -0,0 +1,65 @@
+// @ts-check
+import { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+import { decodeBase64, encodeBase64 } from '@endo/base64';
+
+/** @typedef {{ typeUrl: string; value: string; }} Proto3Msg */
+
+/**
+ * Makes an IBC packet from an array of messages. Expects the `value` of each message
+ * to be base64 encoded bytes.
+ * Skips checks for malformed messages in favor of interface guards.
+ * @param {Proto3Msg[]} msgs
+ * // XXX intellisense does not seem to infer well here
+ * @param {Omit<TxBody, 'messages'>} [opts]
+ * @returns {string} - IBC TX packet
+ * @throws {Error} if malformed messages are provided
+ */
+export function makeTxPacket(msgs, opts) {
+  const messages = msgs.map(msg => ({
+    typeUrl: msg.typeUrl,
+    value: decodeBase64(msg.value),
+  }));
+  const bytes = TxBody.encode(
+    TxBody.fromPartial({
+      messages,
+      ...opts,
+    }),
+  ).finish();
+
+  return JSON.stringify({
+    type: 1,
+    data: encodeBase64(bytes),
+    memo: '',
+  });
+}
+harden(makeTxPacket);
+
+/**
+ * base64 encode an EncodeObject for cross-vat communication
+ * @param {{ typeUrl: string, value: Uint8Array }} tx
+ * @returns {Proto3Msg}
+ */
+export function txToBase64(tx) {
+  return {
+    typeUrl: tx.typeUrl,
+    value: encodeBase64(tx.value),
+  };
+}
+harden(txToBase64);
+
+/**
+ * Looks for a result or error key in the response string, and returns
+ * a Base64Bytes string. This string can be decoded using the corresponding
+ * Msg*Response object.
+ * Error strings seem to be plain text and do not need decoding.
+ * @param {string} response
+ * @returns {string} - base64 encoded bytes string
+ * @throws {Error} if error key is detected in response string, or result key is not found
+ */
+export function parsePacketAck(response) {
+  const { result, error } = JSON.parse(response);
+  if (result) return result;
+  else if (error) throw Error(error);
+  else throw Error(response);
+}
+harden(parsePacketAck);