feat(orchestrator): membrane-friendly timerUtils

packages/orchestration/src/examples/stakeBld.contract.js

@@ -7,10 +7,12 @@ import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js'
 import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 import { prepareVowTools, heapVowE as E } from '@agoric/vow/vat.js';
+import { makeHeapZone } from '@agoric/zone';
 import { deeplyFulfilled } from '@endo/marshal';
 import { M } from '@endo/patterns';
 import { prepareLocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
 import { makeChainHub } from '../exos/chain-hub.js';
+import { prepareTimeHelper } from '../exos/time-helper.js';
 
 /**
  * @import {NameHub} from '@agoric/vats';
@@ -34,20 +36,23 @@ const trace = makeTracer('StakeBld');
  */
 export const start = async (zcf, privateArgs, baggage) => {
   const zone = makeDurableZone(baggage);
+  const { agoricNames, marshaller, timerService } = privateArgs;
 
-  const { makeRecorderKit } = prepareRecorderKitMakers(
-    baggage,
-    privateArgs.marshaller,
-  );
+  const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
   const vowTools = prepareVowTools(zone.subZone('vows'));
+  const timeHelper = prepareTimeHelper(makeHeapZone(), {
+    timerService,
+    vowTools,
+  });
 
   const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
     zone,
     makeRecorderKit,
     zcf,
-    privateArgs.timerService,
+    timerService,
     vowTools,
-    makeChainHub(privateArgs.agoricNames),
+    makeChainHub(agoricNames),
+    timeHelper,
   );
 
   // ----------------

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

@@ -28,9 +28,12 @@ import {
   CoinShape,
   DelegationShape,
 } from '../typeGuards.js';
-import { maxClockSkew, tryDecodeResponse } from '../utils/cosmos.js';
+import {
+  maxClockSkew,
+  tryDecodeResponse,
+  dateInSeconds,
+} from '../utils/cosmos.js';
 import { orchestrationAccountMethods } from '../utils/orchestrationAccount.js';
-import { dateInSeconds } from '../utils/time.js';
 
 /**
  * @import {AmountArg, IcaAccount, ChainAddress, CosmosValidatorAddress, ICQConnection, StakingAccountActions, DenomAmount, OrchestrationAccountI, DenomArg} from '../types.js';

packages/orchestration/src/exos/local-orchestration-account.js

@@ -12,9 +12,8 @@ import {
   ChainAmountShape,
   IBCTransferOptionsShape,
 } from '../typeGuards.js';
-import { maxClockSkew } from '../utils/cosmos.js';
+import { maxClockSkew, dateInSeconds } from '../utils/cosmos.js';
 import { orchestrationAccountMethods } from '../utils/orchestrationAccount.js';
-import { dateInSeconds, makeTimestampHelper } from '../utils/time.js';
 
 /**
  * @import {LocalChainAccount} from '@agoric/vats/src/localchain.js';
@@ -26,6 +25,7 @@ import { dateInSeconds, makeTimestampHelper } from '../utils/time.js';
  * @import {PromiseVow, VowTools} from '@agoric/vow';
  * @import {TypedJson} from '@agoric/cosmic-proto';
  * @import {ChainHub} from './chain-hub.js';
+ * @import {TimeHelper} from './time-helper.js';
  */
 
 const trace = makeTracer('LOA');
@@ -65,6 +65,7 @@ const PUBLIC_TOPICS = {
  * @param {Remote<TimerService>} timerService
  * @param {VowTools} vowTools
  * @param {ChainHub} chainHub
+ * @param {TimeHelper} timeHelper
  */
 export const prepareLocalOrchestrationAccountKit = (
   zone,
@@ -73,11 +74,10 @@ export const prepareLocalOrchestrationAccountKit = (
   timerService,
   { watch, when, allVows },
   chainHub,
-) => {
-  const timestampHelper = makeTimestampHelper(timerService);
-
+  timeHelper,
+) =>
   /** Make an object wrapping an LCA with Zoe interfaces. */
-  const makeLocalOrchestrationAccountKit = zone.exoClassKit(
+  zone.exoClassKit(
     'Local Orchestration Account Kit',
     {
       holder: HolderI,
@@ -402,7 +402,7 @@ export const prepareLocalOrchestrationAccountKit = (
           // TODO #9324 what's a reasonable default? currently 5 minutes
           // FIXME: do not call `getTimeoutTimestampNS` if `opts.timeoutTimestamp` or `opts.timeoutHeight` is provided
           const timeoutTimestampV = watch(
-            timestampHelper.getTimeoutTimestampNS(),
+            timeHelper.getTimeoutTimestampNS(),
             this.facets.getTimeoutTimestampWatcher,
             { opts },
           );
@@ -422,7 +422,6 @@ export const prepareLocalOrchestrationAccountKit = (
       },
     },
   );
-  return makeLocalOrchestrationAccountKit;
-};
+
 /** @typedef {ReturnType<typeof prepareLocalOrchestrationAccountKit>} MakeLocalOrchestrationAccountKit */
 /** @typedef {ReturnType<MakeLocalOrchestrationAccountKit>} LocalOrchestrationAccountKit */

packages/orchestration/src/exos/time-helper.js

@@ -0,0 +1,130 @@
+import { BrandShape } from '@agoric/ertp';
+import {
+  RelativeTimeRecordShape,
+  TimeMath,
+  TimestampRecordShape,
+} from '@agoric/time';
+import { pickFacet } from '@agoric/vat-data';
+import { VowShape } from '@agoric/vow';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+
+/**
+ * @import {Remote} from '@agoric/internal';*
+ * @import {RelativeTimeRecord, TimerBrand, TimerService, TimestampRecord} from '@agoric/time';
+ * @import {Vow, VowTools} from '@agoric/vow';
+ * @import {Zone} from '@agoric/zone';
+ */
+
+export const SECONDS_PER_MINUTE = 60n;
+export const NANOSECONDS_PER_SECOND = 1_000_000_000n;
+
+/** @typedef {{ timerService: Remote<TimerService>; vowTools: VowTools }} TimeHelperPowers */
+
+/**
+ * @param {Zone} zone
+ * @param {TimeHelperPowers} powers
+ */
+const prepareTimeHelperKit = (
+  zone,
+  { timerService, vowTools: { watch, allVows } },
+) =>
+  zone.exoClassKit(
+    'Time Helper',
+    {
+      getBrandWatcher: M.interface('GetBrandWatcherI', {
+        onFulfilled: M.call(BrandShape)
+          .optional(M.arrayOf(M.undefined())) // does not need watcherContext
+          .returns(BrandShape),
+      }),
+      getTimestampWatcher: M.interface('GetBrandWatcherI', {
+        onFulfilled: M.call([TimestampRecordShape, BrandShape])
+          .optional({
+            relativeTime: M.or(RelativeTimeRecordShape, M.undefined()),
+          })
+          .returns(M.bigint()),
+      }),
+      public: M.interface('TimeHelperI', {
+        getTimeoutTimestampNS: M.call()
+          .optional(RelativeTimeRecordShape)
+          .returns(VowShape),
+        getBrand: M.call().returns(VowShape),
+      }),
+    },
+    () =>
+      /** @type {{ brandCache: TimerBrand | undefined }} */ ({
+        brandCache: undefined,
+      }),
+    {
+      getBrandWatcher: {
+        /** @param {TimerBrand} timerBrand */
+        onFulfilled(timerBrand) {
+          this.state.brandCache = timerBrand;
+          return timerBrand;
+        },
+      },
+      getTimestampWatcher: {
+        /**
+         * @param {[TimestampRecord, TimerBrand]} results
+         * @param {{ relativeTime: RelativeTimeRecord }} ctx
+         */
+        onFulfilled([currentTime, timerBrand], { relativeTime }) {
+          const timeout =
+            relativeTime ||
+            TimeMath.coerceRelativeTimeRecord(
+              SECONDS_PER_MINUTE * 5n,
+              timerBrand,
+            );
+          return (
+            TimeMath.addAbsRel(currentTime, timeout).absValue *
+            NANOSECONDS_PER_SECOND
+          );
+        },
+      },
+      public: {
+        /** @returns {Vow<TimerBrand>} */
+        getBrand() {
+          // XXX this is a common use case that should have a helper like `provideSingleton`
+          if (this.state.brandCache) return watch(this.state.brandCache);
+          return watch(
+            E(timerService).getTimerBrand(),
+            this.facets.getBrandWatcher,
+          );
+        },
+        /**
+         * Takes the current time from ChainTimerService and adds a relative
+         * time to determine a timeout timestamp in nanoseconds. Useful for
+         * {@link MsgTransfer.timeoutTimestamp}.
+         *
+         * @param {RelativeTimeRecord} [relativeTime] defaults to 5 minutes
+         * @returns {Vow<bigint>} Timeout timestamp in absolute nanoseconds
+         *   since unix epoch
+         */
+        getTimeoutTimestampNS(relativeTime) {
+          return watch(
+            allVows([
+              E(timerService).getCurrentTimestamp(),
+              this.facets.public.getBrand(),
+            ]),
+            this.facets.getTimestampWatcher,
+            { relativeTime },
+          );
+        },
+      },
+    },
+  );
+harden(prepareTimeHelperKit);
+
+/**
+ * @param {Zone} zone
+ * @param {TimeHelperPowers} powers
+ */
+export const prepareTimeHelper = (zone, powers) => {
+  const makeTimeHelperKit = prepareTimeHelperKit(zone, powers);
+  const makeTimeHelper = pickFacet(makeTimeHelperKit, 'public');
+  const timeHelper = makeTimeHelper();
+  return harden(timeHelper);
+};
+harden(prepareTimeHelper);
+
+/** @typedef {ReturnType<typeof prepareTimeHelper>} TimeHelper */

packages/orchestration/src/utils/cosmos.js

@@ -34,3 +34,12 @@ export const tryDecodeResponse = (ackStr, fromProtoMsg) => {
     throw assert.error(`bad response: ${ackStr}`, undefined, { cause });
   }
 };
+
+/**
+ * Convert a Date from a Cosmos message, which has millisecond precision, to a
+ * BigInt for number of seconds since epoch, for use in a timer.
+ *
+ * @param {Date} date
+ * @returns {bigint}
+ */
+export const dateInSeconds = date => BigInt(Math.floor(date.getTime() / 1000));

packages/orchestration/src/utils/start-helper.js

@@ -2,12 +2,14 @@ import { prepareAsyncFlowTools } from '@agoric/async-flow';
 import { prepareVowTools } from '@agoric/vow';
 import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
+import { makeHeapZone } from '@agoric/zone';
 import { prepareLocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
 import { makeOrchestrationFacade } from '../facade.js';
 import { makeChainHub } from '../exos/chain-hub.js';
 import { prepareRemoteChainFacade } from '../exos/remote-chain-facade.js';
 import { prepareCosmosOrchestrationAccount } from '../exos/cosmos-orchestration-account.js';
 import { prepareLocalChainFacade } from '../exos/local-chain-facade.js';
+import { prepareTimeHelper } from '../exos/time-helper.js';
 
 /**
  * @import {PromiseKit} from '@endo/promise-kit'
@@ -45,11 +47,13 @@ export const provideOrchestration = (
   marshaller,
 ) => {
   const zone = makeDurableZone(baggage);
+  const vowTools = prepareVowTools(zone.subZone('vows'));
   const { agoricNames, timerService } = remotePowers;
-
   const chainHub = makeChainHub(agoricNames);
-
-  const vowTools = prepareVowTools(zone.subZone('vows'));
+  const timeHelper = prepareTimeHelper(makeHeapZone(), {
+    timerService,
+    vowTools,
+  });
 
   const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
   const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
@@ -59,6 +63,7 @@ export const provideOrchestration = (
     timerService,
     vowTools,
     chainHub,
+    timeHelper,
   );
 
   const asyncFlowTools = prepareAsyncFlowTools(zone.subZone('asyncFlow'), {