@agoric/orchestration 0.1.1-calypso-dev-84eb287.0

package/src/utils/start-helper.js

@@ -0,0 +1,109 @@
+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 { 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 {PromiseKit} from '@endo/promise-kit'
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {TimerService, TimerBrand} from '@agoric/time';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Remote} from '@agoric/vow';
+ * @import {OrchestrationService} from '../service.js';
+ */
+
+/**
+ * @typedef {{
+ *   localchain: Remote<LocalChain>;
+ *   orchestrationService: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timerService: Remote<TimerService>;
+ *   agoricNames: Remote<NameHub>;
+ * }} OrchestrationPowers
+ */
+
+/**
+ * Helper that a contract start function can use to set up the objects needed
+ * for orchestration.
+ *
+ * @param {ZCF} zcf
+ * @param {Baggage} baggage
+ * @param {OrchestrationPowers} remotePowers
+ * @param {Marshaller} marshaller
+ */
+export const provideOrchestration = (
+  zcf,
+  baggage,
+  remotePowers,
+  marshaller,
+) => {
+  const zone = makeDurableZone(baggage);
+  const { agoricNames, timerService } = remotePowers;
+
+  const chainHub = makeChainHub(agoricNames);
+
+  const vowTools = prepareVowTools(zone.subZone('vows'));
+
+  const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
+  const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
+    zone,
+    makeRecorderKit,
+    zcf,
+    timerService,
+    vowTools,
+    chainHub,
+  );
+
+  const asyncFlowTools = prepareAsyncFlowTools(zone.subZone('asyncFlow'), {
+    vowTools,
+  });
+
+  const makeCosmosOrchestrationAccount = prepareCosmosOrchestrationAccount(
+    // FIXME what zone?
+    zone,
+    makeRecorderKit,
+    vowTools,
+    zcf,
+  );
+
+  const makeRemoteChainFacade = prepareRemoteChainFacade(zone, {
+    makeCosmosOrchestrationAccount,
+    orchestration: remotePowers.orchestrationService,
+    storageNode: remotePowers.storageNode,
+    timer: remotePowers.timerService,
+    vowTools,
+  });
+
+  const makeLocalChainFacade = prepareLocalChainFacade(zone, {
+    makeLocalOrchestrationAccountKit,
+    localchain: remotePowers.localchain,
+    // FIXME what path?
+    storageNode: remotePowers.storageNode,
+    orchestration: remotePowers.orchestrationService,
+    timer: remotePowers.timerService,
+    vowTools,
+  });
+
+  const facade = makeOrchestrationFacade({
+    zcf,
+    zone,
+    chainHub,
+    makeLocalOrchestrationAccountKit,
+    makeRecorderKit,
+    makeCosmosOrchestrationAccount,
+    makeLocalChainFacade,
+    makeRemoteChainFacade,
+    asyncFlowTools,
+    vowTools,
+    ...remotePowers,
+  });
+  return { ...facade, chainHub, vowTools, zone };
+};
+harden(provideOrchestration);

package/src/utils/time.d.ts

@@ -0,0 +1,31 @@
+/**
+ * XXX should this be durable? resumable?
+ *
+ * @param {Remote<TimerService>} timer
+ */
+export function makeTimestampHelper(timer: Remote<TimerService>): {
+    /**
+     * XXX do this need to be resumable / use Vows?
+     *
+     * 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 {Promise<bigint>} Timeout timestamp in absolute nanoseconds
+     *   since unix epoch
+     */
+    getTimeoutTimestampNS(relativeTime?: RelativeTimeRecord | undefined): Promise<bigint>;
+};
+/**
+ * @import {RelativeTimeRecord, TimerBrand, TimerService} from '@agoric/time';
+ * @import {Remote} from '@agoric/internal';
+ */
+export const SECONDS_PER_MINUTE: 60n;
+export const NANOSECONDS_PER_SECOND: 1000000000n;
+export function dateInSeconds(date: Date): bigint;
+export type TimestampHelper = Awaited<ReturnType<typeof makeTimestampHelper>>;
+import type { TimerService } from '@agoric/time';
+import type { Remote } from '@agoric/internal';
+import type { RelativeTimeRecord } from '@agoric/time';
+//# sourceMappingURL=time.d.ts.map

package/src/utils/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["time.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,2CAFW,OAAO,YAAY,CAAC;IAY3B;;;;;;;;;;OAUG;0EAFU,OAAO,CAAC,MAAM,CAAC;EAiB/B;AAhDD;;;GAGG;AAEH,qCAAsC;AACtC,iDAAqD;AAqD9C,oCAHI,IAAI,GACF,MAAM,CAE2D;8BAThE,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;kCAjDE,cAAc;4BACpD,kBAAkB;wCADoB,cAAc"}

package/src/utils/time.js

@@ -0,0 +1,63 @@
+import { E } from '@endo/far';
+import { TimeMath } from '@agoric/time';
+
+/**
+ * @import {RelativeTimeRecord, TimerBrand, TimerService} from '@agoric/time';
+ * @import {Remote} from '@agoric/internal';
+ */
+
+export const SECONDS_PER_MINUTE = 60n;
+export const NANOSECONDS_PER_SECOND = 1_000_000_000n;
+
+/**
+ * XXX should this be durable? resumable?
+ *
+ * @param {Remote<TimerService>} timer
+ */
+export function makeTimestampHelper(timer) {
+  /** @type {TimerBrand | undefined} */
+  let brandCache;
+  const getBrand = async () => {
+    if (brandCache) return brandCache;
+    brandCache = await E(timer).getTimerBrand();
+    return brandCache;
+  };
+
+  return harden({
+    /**
+     * XXX do this need to be resumable / use Vows?
+     *
+     * 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 {Promise<bigint>} Timeout timestamp in absolute nanoseconds
+     *   since unix epoch
+     */
+    async getTimeoutTimestampNS(relativeTime) {
+      const currentTime = await E(timer).getCurrentTimestamp();
+      const timeout =
+        relativeTime ||
+        TimeMath.coerceRelativeTimeRecord(
+          SECONDS_PER_MINUTE * 5n,
+          await getBrand(),
+        );
+      return (
+        TimeMath.addAbsRel(currentTime, timeout).absValue *
+        NANOSECONDS_PER_SECOND
+      );
+    },
+  });
+}
+
+/** @typedef {Awaited<ReturnType<typeof makeTimestampHelper>>} TimestampHelper */
+
+/**
+ * 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));

package/src/vat-orchestration.d.ts

@@ -0,0 +1,58 @@
+export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
+    /** @param {Partial<OrchestrationPowers>} [initialPowers] */
+    makeOrchestrationKit(initialPowers?: Partial<OrchestrationPowers> | undefined): import("@endo/exo").GuardedKit<{
+        requestICAChannelWatcher: {
+            onFulfilled(port: import("@agoric/network").Port, { chainId, remoteConnAddr }: {
+                chainId: string;
+                remoteConnAddr: import("@agoric/vats/tools/ibc-utils.js").RemoteIbcAddress;
+            }): import("@agoric/vow").Vow<any>;
+        };
+        requestICQChannelWatcher: {
+            onFulfilled(port: import("@agoric/network").Port, { remoteConnAddr, controllerConnectionId }: {
+                remoteConnAddr: import("@agoric/vats/tools/ibc-utils.js").RemoteIbcAddress;
+                controllerConnectionId: import("@agoric/vats").IBCConnectionID;
+            }): import("@agoric/vow").Vow<any>;
+        };
+        channelOpenWatcher: {
+            onFulfilled(_connection: import("@agoric/network").Connection, { connectionKit, returnFacet, saveICQConnection }: {
+                connectionKit: ConnectionKit;
+                returnFacet: string;
+                saveICQConnection?: import("@agoric/vats").IBCConnectionID;
+            }): any;
+        };
+        public: {
+            makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
+            provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
+        };
+    }>;
+} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+    /** @param {Partial<OrchestrationPowers>} [initialPowers] */
+    makeOrchestrationKit(initialPowers?: Partial<OrchestrationPowers> | undefined): import("@endo/exo").GuardedKit<{
+        requestICAChannelWatcher: {
+            onFulfilled(port: import("@agoric/network").Port, { chainId, remoteConnAddr }: {
+                chainId: string;
+                remoteConnAddr: import("@agoric/vats/tools/ibc-utils.js").RemoteIbcAddress;
+            }): import("@agoric/vow").Vow<any>;
+        };
+        requestICQChannelWatcher: {
+            onFulfilled(port: import("@agoric/network").Port, { remoteConnAddr, controllerConnectionId }: {
+                remoteConnAddr: import("@agoric/vats/tools/ibc-utils.js").RemoteIbcAddress;
+                controllerConnectionId: import("@agoric/vats").IBCConnectionID;
+            }): import("@agoric/vow").Vow<any>;
+        };
+        channelOpenWatcher: {
+            onFulfilled(_connection: import("@agoric/network").Connection, { connectionKit, returnFacet, saveICQConnection }: {
+                connectionKit: ConnectionKit;
+                returnFacet: string;
+                saveICQConnection?: import("@agoric/vats").IBCConnectionID;
+            }): any;
+        };
+        public: {
+            makeAccount(chainId: string, hostConnectionId: import("@agoric/vats").IBCConnectionID, controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./cosmos-api.js").IcaAccount>;
+            provideICQConnection(controllerConnectionId: import("@agoric/vats").IBCConnectionID): import("@agoric/vow").Vow<import("./types.js").ICQConnection> | import("./types.js").ICQConnection;
+        };
+    }>;
+}>;
+export type OrchestrationVat = ReturnType<typeof buildRootObject>;
+import type { OrchestrationPowers } from './service.js';
+//# sourceMappingURL=vat-orchestration.d.ts.map

package/src/vat-orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vat-orchestration.d.ts","sourceRoot":"","sources":["vat-orchestration.js"],"names":[],"mappings":"AAOO;IASH,4DAA4D;;;;;;;;;;;;;;;;;;iCAQ01J,CAAC;;;;;;;;;IARv5J,4DAA4D;;;;;;;;;;;;;;;;;;iCAQ01J,CAAC;;;;;;;;GAH15J;+BAEa,UAAU,CAAC,OAAO,eAAe,CAAC;yCAlBT,cAAc"}

package/src/vat-orchestration.js

@@ -0,0 +1,24 @@
+import { Far } from '@endo/far';
+import { prepareVowTools } from '@agoric/vow/vat.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+import { prepareOrchestrationTools } from './service.js';
+
+/** @import {OrchestrationPowers} from './service.js' */
+
+export const buildRootObject = (_vatPowers, _args, baggage) => {
+  const zone = makeDurableZone(baggage);
+  const vowTools = prepareVowTools(zone.subZone('VowTools'));
+  const { makeOrchestrationKit } = prepareOrchestrationTools(
+    zone.subZone('orchestration'),
+    vowTools,
+  );
+
+  return Far('OrchestrationVat', {
+    /** @param {Partial<OrchestrationPowers>} [initialPowers] */
+    makeOrchestrationKit(initialPowers = {}) {
+      return makeOrchestrationKit(initialPowers);
+    },
+  });
+};
+
+/** @typedef {ReturnType<typeof buildRootObject>} OrchestrationVat */