@agoric/orchestration 0.1.1-dev-0889e20.0 → 0.1.1-dev-81ac381.0

package/src/exos/portfolio-holder-kit.js

@@ -0,0 +1,174 @@
+import { M, mustMatch } from '@endo/patterns';
+import { E } from '@endo/far';
+import { Fail } from '@endo/errors';
+import { PublicTopicShape } from '@agoric/zoe/src/contractSupport/topics.js';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { VowShape } from '@agoric/vow';
+
+const { fromEntries } = Object;
+
+/**
+ * @import {HostOf} from '@agoric/async-flow';
+ * @import {MapStore} from '@agoric/store';
+ * @import {VowTools} from '@agoric/vow';
+ * @import {ResolvedPublicTopic} from '@agoric/zoe/src/contractSupport/topics.js';
+ * @import {Zone} from '@agoric/zone';
+ * @import {OrchestrationAccount, OrchestrationAccountI} from '@agoric/orchestration';
+ */
+
+/**
+ * @typedef {{
+ *   accounts: MapStore<string, OrchestrationAccount<any>>;
+ *   publicTopics: MapStore<string, ResolvedPublicTopic<unknown>>;
+ * }} PortfolioHolderState
+ */
+
+const ChainNameShape = M.string();
+
+const AccountEntriesShape = M.arrayOf([
+  M.string(),
+  M.remotable('OrchestrationAccount'),
+]);
+const PublicTopicEntriesShape = M.arrayOf([M.string(), PublicTopicShape]);
+
+/**
+ * Kit that holds several OrchestrationAccountKits and returns a invitation
+ * makers.
+ *
+ * @param {Zone} zone
+ * @param {VowTools} vowTools
+ */
+const preparePortfolioHolderKit = (zone, { asVow, when }) => {
+  return zone.exoClassKit(
+    'PortfolioHolderKit',
+    {
+      invitationMakers: M.interface('InvitationMakers', {
+        MakeInvitation: M.call(
+          ChainNameShape,
+          M.string(),
+          M.arrayOf(M.any()),
+        ).returns(M.promise()),
+      }),
+      holder: M.interface('Holder', {
+        asContinuingOffer: M.call().returns(VowShape),
+        getPublicTopics: M.call().returns(VowShape),
+        getAccount: M.call(ChainNameShape).returns(VowShape),
+        addAccount: M.call(
+          ChainNameShape,
+          M.remotable(),
+          PublicTopicShape,
+        ).returns(VowShape),
+      }),
+    },
+    /**
+     * @param {Iterable<[string, OrchestrationAccount<any>]>} accountEntries
+     * @param {Iterable<[string, ResolvedPublicTopic<unknown>]>} publicTopicEntries
+     */
+    (accountEntries, publicTopicEntries) => {
+      mustMatch(accountEntries, AccountEntriesShape, 'must provide accounts');
+      mustMatch(
+        publicTopicEntries,
+        PublicTopicEntriesShape,
+        'must provide public topics',
+      );
+      const accounts = harden(
+        makeScalarBigMapStore('accounts', { durable: true }),
+      );
+      const publicTopics = harden(
+        makeScalarBigMapStore('publicTopics', { durable: true }),
+      );
+      accounts.addAll(accountEntries);
+      publicTopics.addAll(publicTopicEntries);
+      return /** @type {PortfolioHolderState} */ (
+        harden({
+          accounts,
+          publicTopics,
+        })
+      );
+    },
+    {
+      invitationMakers: {
+        /**
+         * @template {unknown[]} IA
+         * @param {string} chainName key where the account is stored
+         * @param {string} action invitation maker name, e.g. 'Delegate'
+         * @param {IA} invitationArgs
+         * @returns {Promise<Invitation<unknown, IA>>}
+         */
+        MakeInvitation(chainName, action, invitationArgs) {
+          const { accounts } = this.state;
+          accounts.has(chainName) || Fail`no account found for ${chainName}`;
+          const account = accounts.get(chainName);
+          return when(E(account).asContinuingOffer(), ({ invitationMakers }) =>
+            E(invitationMakers)[action](...invitationArgs),
+          );
+        },
+      },
+      holder: {
+        // FIXME /** @type {HostOf<OrchestrationAccountI['asContinuingOffer']>} */
+        asContinuingOffer() {
+          return asVow(() => {
+            const { invitationMakers } = this.facets;
+            const { publicTopics } = this.state;
+            return harden({
+              publicSubscribers: fromEntries(publicTopics.entries()),
+              invitationMakers,
+            });
+          });
+        },
+        // FIXME /** @type {HostOf<OrchestrationAccountI['getPublicTopics']>} */
+        getPublicTopics() {
+          return asVow(() => {
+            const { publicTopics } = this.state;
+            return harden(fromEntries(publicTopics.entries()));
+          });
+        },
+        /**
+         * @param {string} chainName key where the account is stored
+         * @param {OrchestrationAccount<any>} account
+         * @param {ResolvedPublicTopic<unknown>} publicTopic
+         */
+        addAccount(chainName, account, publicTopic) {
+          return asVow(() => {
+            if (this.state.accounts.has(chainName)) {
+              throw Fail`account already exists for ${chainName}`;
+            }
+            zone.isStorable(account) ||
+              Fail`account for ${chainName} must be storable`;
+            zone.isStorable(publicTopic) ||
+              Fail`publicTopic for ${chainName} must be storable`;
+
+            this.state.publicTopics.init(chainName, publicTopic);
+            this.state.accounts.init(chainName, account);
+          });
+        },
+        /**
+         * @param {string} chainName key where the account is stored
+         */
+        getAccount(chainName) {
+          return asVow(() => this.state.accounts.get(chainName));
+        },
+      },
+    },
+  );
+};
+
+/**
+ * A portfolio holder stores two or more OrchestrationAccounts and combines
+ * ContinuingOfferResult's from each into a single result.
+ *
+ * XXX consider an interface for extending the exo maker with additional
+ * invitation makers.
+ *
+ * @param {Zone} zone
+ * @param {VowTools} vowTools
+ * @returns {(
+ *   ...args: Parameters<ReturnType<typeof preparePortfolioHolderKit>>
+ * ) => ReturnType<ReturnType<typeof preparePortfolioHolderKit>>['holder']}
+ */
+export const preparePortfolioHolder = (zone, vowTools) => {
+  const makeKit = preparePortfolioHolderKit(zone, vowTools);
+  return (...args) => makeKit(...args).holder;
+};
+/** @typedef {ReturnType<typeof preparePortfolioHolder>} MakePortfolioHolder */
+/** @typedef {ReturnType<MakePortfolioHolder>} PortfolioHolder */

package/src/proposals/start-stakeBld.d.ts

@@ -32,6 +32,27 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                         send(toAccount: any, amount: any): import("@agoric/vow").Vow<never>;
                         transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
                         transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void extends import("@endo/pass-style").Passable ? import("@endo/pass-style").Passable & void : import("@agoric/async-flow").HostInterface<void>>;
+                        monitorTransfers(tap: import("@agoric/vats/src/bridge-target.js").TargetApp): import("@agoric/vow").Vow<import("@agoric/vats/src/bridge-target.js").TargetRegistration | import("@agoric/vow").Vow<import("@agoric/vats/src/bridge-target.js").TargetRegistration> extends import("@endo/pass-style").Passable ? (string & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (string & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (number & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (number & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (bigint & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (false & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (false & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (true & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (true & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (symbol & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (symbol & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (import("@endo/pass-style").RemotableObject<string> & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (Promise<any> & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (Promise<any> & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (Error & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (Error & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (import("@endo/pass-style").CopyArrayI<import("@endo/pass-style").PassableCap, Error> & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (import("@endo/pass-style").CopyArrayI<import("@endo/pass-style").PassableCap, Error> & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (import("@endo/pass-style").CopyRecordI<import("@endo/pass-style").PassableCap, Error> & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (import("@endo/pass-style").CopyRecordI<import("@endo/pass-style").PassableCap, Error> & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) | (import("@endo/pass-style").CopyTaggedI<import("@endo/pass-style").PassableCap, Error> & import("@agoric/vats/src/bridge-target.js").TargetRegistration) | (import("@endo/pass-style").CopyTaggedI<import("@endo/pass-style").PassableCap, Error> & import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+                            payload: import("@agoric/vow").VowPayload<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+                        }) : import("@agoric/async-flow").HostInterface<import("@agoric/vats/src/bridge-target.js").TargetRegistration | import("@agoric/vow").Vow<import("@agoric/vats/src/bridge-target.js").TargetRegistration>>>;
                     }>>;
                     makeAccountInvitationMaker(): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
                 }>;

package/src/proposals/start-stakeBld.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-stakeBld.d.ts","sourceRoot":"","sources":["start-stakeBld.js"],"names":[],"mappings":"AAkBO,6TAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;+BAiCqB,kBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAjC2B,CACxD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAwDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BN;sBApGqB,gCAAgC"}
+{"version":3,"file":"start-stakeBld.d.ts","sourceRoot":"","sources":["start-stakeBld.js"],"names":[],"mappings":"AAkBO,6TAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;+BAiCqB,kBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAjC2B,CACxD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAwDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BN;sBApGqB,gCAAgC"}

package/src/utils/time.d.ts

@@ -23,6 +23,7 @@ export function makeTimestampHelper(timer: Remote<TimerService>): {
  */
 export const SECONDS_PER_MINUTE: 60n;
 export const MILLISECONDS_PER_SECOND: 1000n;
+export const NANOSECONDS_PER_MILLISECOND: 1000000n;
 export const NANOSECONDS_PER_SECOND: 1000000000n;
 export type TimestampHelper = Awaited<ReturnType<typeof makeTimestampHelper>>;
 import type { TimerService } from '@agoric/time';

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

@@ -1 +1 @@
-{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["time.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,2CAFW,OAAO,YAAY,CAAC;IAY3B;;;;;;;;;;OAUG;0EAFU,OAAO,CAAC,MAAM,CAAC;EAiB/B;AAjDD;;;GAGG;AAEH,qCAAsC;AACtC,4CAA6C;AAC7C,iDAAqD;8BA4CvC,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;kCAlDE,cAAc;4BACpD,kBAAkB;wCADoB,cAAc"}
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["time.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,2CAFW,OAAO,YAAY,CAAC;IAY3B;;;;;;;;;;OAUG;0EAFU,OAAO,CAAC,MAAM,CAAC;EAiB/B;AAlDD;;;GAGG;AAEH,qCAAsC;AACtC,4CAA6C;AAC7C,mDAAsD;AACtD,iDAAqD;8BA4CvC,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;kCAnDE,cAAc;4BACpD,kBAAkB;wCADoB,cAAc"}

package/src/utils/time.js

@@ -8,6 +8,7 @@ import { TimeMath } from '@agoric/time';
 
 export const SECONDS_PER_MINUTE = 60n;
 export const MILLISECONDS_PER_SECOND = 1000n;
+export const NANOSECONDS_PER_MILLISECOND = 1_000_000n;
 export const NANOSECONDS_PER_SECOND = 1_000_000_000n;
 
 /**