@agoric/orchestration 0.1.1-dev-27cc9b8.0 → 0.1.1-dev-96c19f5.0

package/src/exos/local-chain-account-kit.js

@@ -20,7 +20,9 @@ import { dateInSeconds, makeTimestampHelper } from '../utils/time.js';
  * @import {AmountArg, ChainAddress, DenomAmount, IBCMsgTransferOptions, CosmosChainInfo} from '@agoric/orchestration';
  * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js'.
  * @import {Zone} from '@agoric/zone';
+ * @import {Remote} from '@agoric/internal';
  * @import {TimerService, TimerBrand} from '@agoric/time';
+ * @import {ChainHub} from '../utils/chainHub.js';
  */
 
 const trace = makeTracer('LCAH');
@@ -43,7 +45,7 @@ const HolderI = M.interface('holder', {
   getPublicTopics: M.call().returns(TopicsRecordShape),
   delegate: M.call(M.string(), AmountShape).returns(M.promise()),
   undelegate: M.call(M.string(), AmountShape).returns(M.promise()),
-  deposit: M.callWhen(PaymentShape).returns(AmountShape),
+  deposit: M.callWhen(PaymentShape).optional(AmountShape).returns(AmountShape),
   withdraw: M.callWhen(AmountShape).returns(PaymentShape),
   transfer: M.call(AmountArgShape, ChainAddressShape)
     .optional(IBCTransferOptionsShape)
@@ -61,22 +63,19 @@ const PUBLIC_TOPICS = {
  * @param {Zone} zone
  * @param {MakeRecorderKit} makeRecorderKit
  * @param {ZCF} zcf
- * @param {TimerService} timerService
- * @param {TimerBrand} timerBrand
- * @param {CosmosChainInfo} agoricChainInfo
+ * @param {Remote<TimerService>} timerService
+ * @param {ChainHub} chainHub
  */
 export const prepareLocalChainAccountKit = (
   zone,
   makeRecorderKit,
   zcf,
   timerService,
-  timerBrand,
-  agoricChainInfo,
+  chainHub,
 ) => {
-  const timestampHelper = makeTimestampHelper(timerService, timerBrand);
-  /**
-   * Make an object wrapping an LCA with Zoe interfaces.
-   */
+  const timestampHelper = makeTimestampHelper(timerService);
+  // TODO: rename to makeLocalOrchestrationAccount or the like to distinguish from lca
+  /** Make an object wrapping an LCA with Zoe interfaces. */
   const makeLocalChainAccountKit = zone.exoClassKit(
     'LCA Kit',
     {
@@ -220,9 +219,7 @@ export const prepareLocalChainAccountKit = (
           // @ts-expect-error subtype
           return E(this.state.account).executeTx(messages);
         },
-        /**
-         * @returns {ChainAddress['address']}
-         */
+        /** @returns {ChainAddress['address']} */
         getAddress() {
           return NonNullish(this.state.address, 'Chain address not available.');
         },
@@ -240,12 +237,12 @@ export const prepareLocalChainAccountKit = (
           // TODO #9211 lookup denom from brand
           if ('brand' in amount) throw Fail`ERTP Amounts not yet supported`;
 
-          destination.chainId in agoricChainInfo.connections ||
-            Fail`Unknown chain ${destination.chainId}`;
-
           // TODO #8879 chainInfo and #9063 well-known chains
-          const { transferChannel } =
-            agoricChainInfo.connections[destination.chainId];
+          const agoricChainInfo = await chainHub.getChainInfo('agoric');
+          const { transferChannel } = await chainHub.getConnectionInfo(
+            agoricChainInfo.chainId,
+            destination.chainId,
+          );
 
           await null;
           // set a `timeoutTimestamp` if caller does not supply either `timeoutHeight` or `timeoutTimestamp`

package/src/facade.d.ts

@@ -1,6 +1,4 @@
-/** agoricNames key for ChainInfo hub */
-export const CHAIN_KEY: "chain";
-export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, agoricNames, }: {
+export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, chainHub, makeLocalChainAccountKit, }: {
     zone: Zone;
     timerService: Remote<TimerService>;
     zcf: ZCF;
@@ -34,21 +32,9 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
             };
         }[]>;
     }>>;
-    agoricNames: Remote<NameHub>;
+    chainHub: import("./utils/chainHub.js").ChainHub;
+    makeLocalChainAccountKit: ReturnType<typeof import("./exos/local-chain-account-kit.js").prepareLocalChainAccountKit>;
 }): {
-    /**
-     * Register a new chain in a heap store. The name will override a name in
-     * well known chain names.
-     *
-     * This registration will not surve a reincarnation of the vat so if the
-     * chain is not yet in the well known names at that point, it will have to
-     * be registered again. In an unchanged contract `start` the call will
-     * happen again naturally.
-     *
-     * @param {string} name
-     * @param {ChainInfo} chainInfo
-     */
-    registerChain(name: string, chainInfo: ChainInfo): void;
     /**
      * @template Context
      * @template {any[]} Args
@@ -64,7 +50,5 @@ export type OrchestrationFacade = ReturnType<typeof makeOrchestrationFacade>;
 import type { Zone } from '@agoric/zone';
 import type { TimerService } from '@agoric/time';
 import type { Remote } from '@agoric/internal';
-import type { NameHub } from '@agoric/vats';
-import type { ChainInfo } from './types.js';
 import type { Orchestrator } from './types.js';
 //# sourceMappingURL=facade.d.ts.map

package/src/facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAsBA,wCAAwC;AACxC,gCAAiC;AA2I1B;;;SAPG,GAAG;;;;;;;;;;;;;8BAlG6B,MAAM,KAC9C,CAAC;6BAYW,QAAO,KAAK,CAAC,mBAEX,OAAO;6BAeV,OAAO,KAAK,CAAC;;;2BAyBf,EAAE;;;uBA6F6B,OAAO,sBAAsB,EAAE,SACpE;;;4BAiBA,OAAG,sBAAsB,EAAG,SAAQ,EAAE;;;;;;;;;IAtBvC;;;;;;;;;;;OAWG;wBAFQ,MAAM;IAMjB;;;;;;;;OAQG;gBAFkC,OAAO,EACrB,IAAI,6BAJhB,MAAM,OAGoB,OAAO,AAD1B,gCACmB,OAAO,WACrB,IAAI,AADgC,KAAK,MAAM,GACzD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC;EA4BnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAnPjC,cAAc;kCACN,cAAc;4BAEpB,kBAAkB;6BAJjB,cAAc;+BAMgD,YAAY;kCAAZ,YAAY"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAuKO;;;SAVG,GAAG;;;;;;;;;;;;;8BArGY,MAAM,KAAK,CAAC;6BAczB,QAAQ,KAAK,CAAC,mBACZ,OAAK;6BAc0C,OACnD,KAAH,CAAC;;;2BAuBJ,EAAE;;;uBAsFgB,OAAO,sBAClB,EAAE,SAAS;;;4BA0BV,OAAO,sBACX,EAAE,SAAS,EAAE;;;;;;;cA9DN,OAAO,qBAAqB,EAAE,QAAQ;8BACtB,UAAU,CACxC,cAAoB,mCAAmC,EAAE,2BAA2B,CAC/E;;IAsBF;;;;;;;;OAQG;gBAFkC,OAAO,EACrB,IAAI,6BAJhB,MAAM,OAGoB,OAAO,AAD1B,gCACmB,OAAO,WACrB,IAAI,AADgC,KAAK,MAAM,GACzD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,OAAO,CAAC;EA4BnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BAzNjC,cAAc;kCACN,cAAc;4BAEpB,kBAAkB;kCAE6C,YAAY"}

package/src/facade.js

@@ -1,13 +1,9 @@
 /** @file Orchestration service */
 
-import { makeScalarBigMapStore } from '@agoric/vat-data';
 import { E } from '@endo/far';
-import { M } from '@endo/patterns';
 import { prepareCosmosOrchestrationAccount } from './exos/cosmosOrchestrationAccount.js';
-import { CosmosChainInfoShape } from './typeGuards.js';
 
 /**
- * @import {NameHub} from '@agoric/vats';
  * @import {Zone} from '@agoric/zone';
  * @import {TimerService} from '@agoric/time';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
@@ -19,10 +15,6 @@ import { CosmosChainInfoShape } from './typeGuards.js';
 /** @type {any} */
 const anyVal = null;
 
-// TODO define key hierarchy in shared constants
-/** agoricNames key for ChainInfo hub */
-export const CHAIN_KEY = 'chain';
-
 // FIXME look up real values
 // UNTIL https://github.com/Agoric/agoric-sdk/issues/9063
 const mockLocalChainInfo = {
@@ -37,9 +29,12 @@ const mockLocalChainInfo = {
 
 /**
  * @param {Remote<LocalChain>} localchain
+ * @param {ReturnType<
+ *   typeof import('./exos/local-chain-account-kit.js').prepareLocalChainAccountKit
+ * >} makeLocalChainAccountKit
  * @returns {Chain}
  */
-const makeLocalChainFacade = localchain => {
+const makeLocalChainFacade = (localchain, makeLocalChainAccountKit) => {
   return {
     /** @returns {Promise<ChainInfo>} */
     async getChainInfo() {
@@ -47,7 +42,14 @@ const makeLocalChainFacade = localchain => {
     },
 
     async makeAccount() {
-      const account = await E(localchain).makeAccount();
+      const lcaP = E(localchain).makeAccount();
+      const [lca, address] = await Promise.all([lcaP, E(lcaP).getAddress()]);
+      const { holder: account } = makeLocalChainAccountKit({
+        account: lca,
+        address,
+        // @ts-expect-error TODO: Remote
+        storageNode: null,
+      });
 
       return {
         async deposit(payment) {
@@ -70,7 +72,7 @@ const makeLocalChainFacade = localchain => {
               ? [/** @type {any} */ (null), denomArg]
               : [denomArg, 'FIXME'];
 
-          const natAmount = await account.getBalance(brand);
+          const natAmount = await E(lca).getBalance(brand);
           return harden({ denom, value: natAmount.value });
         },
         getBalances() {
@@ -81,8 +83,8 @@ const makeLocalChainFacade = localchain => {
           console.log('send got', toAccount, amount);
         },
         async transfer(amount, destination, opts) {
-          // FIXME implement
           console.log('transfer got', amount, destination, opts);
+          return account.transfer(amount, destination, opts);
         },
         transferSteps(amount, msg) {
           console.log('transferSteps got', amount, msg);
@@ -157,7 +159,10 @@ const makeRemoteChainFacade = (
  *   storageNode: Remote<StorageNode>;
  *   orchestrationService: Remote<OrchestrationService>;
  *   localchain: Remote<LocalChain>;
- *   agoricNames: Remote<NameHub>;
+ *   chainHub: import('./utils/chainHub.js').ChainHub;
+ *   makeLocalChainAccountKit: ReturnType<
+ *     typeof import('./exos/local-chain-account-kit.js').prepareLocalChainAccountKit
+ *   >;
  * }} powers
  */
 export const makeOrchestrationFacade = ({
@@ -167,7 +172,8 @@ export const makeOrchestrationFacade = ({
   storageNode,
   orchestrationService,
   localchain,
-  agoricNames,
+  chainHub,
+  makeLocalChainAccountKit,
 }) => {
   console.log('makeOrchestrationFacade got', {
     zone,
@@ -177,43 +183,7 @@ export const makeOrchestrationFacade = ({
     orchestrationService,
   });
 
-  const chainInfos = makeScalarBigMapStore('chainInfos', {
-    keyShape: M.string(),
-    valueShape: CosmosChainInfoShape,
-  });
-
-  /**
-   * @param {string} name
-   * @returns {Promise<CosmosChainInfo>}
-   */
-  const getChainInfo = async name => {
-    // Either from registerChain or memoized remote lookup()
-    if (chainInfos.has(name)) {
-      return chainInfos.get(name);
-    }
-
-    const chainInfo = await E(agoricNames).lookup(CHAIN_KEY, name);
-    assert(chainInfo, `unknown chain ${name}`);
-    chainInfos.init(name, chainInfo);
-    return chainInfo;
-  };
-
   return {
-    /**
-     * Register a new chain in a heap store. The name will override a name in
-     * well known chain names.
-     *
-     * This registration will not surve a reincarnation of the vat so if the
-     * chain is not yet in the well known names at that point, it will have to
-     * be registered again. In an unchanged contract `start` the call will
-     * happen again naturally.
-     *
-     * @param {string} name
-     * @param {ChainInfo} chainInfo
-     */
-    registerChain(name, chainInfo) {
-      chainInfos.init(name, chainInfo);
-    },
     /**
      * @template Context
      * @template {any[]} Args
@@ -228,10 +198,10 @@ export const makeOrchestrationFacade = ({
       const orc = {
         async getChain(name) {
           if (name === 'agoric') {
-            return makeLocalChainFacade(localchain);
+            return makeLocalChainFacade(localchain, makeLocalChainAccountKit);
           }
 
-          const chainInfo = await getChainInfo(name);
+          const chainInfo = await chainHub.getChainInfo(name);
 
           return makeRemoteChainFacade(chainInfo, {
             orchestration: orchestrationService,

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

@@ -32,7 +32,6 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, agoricName
                 };
                 storageNode: globalThis.StorageNode;
                 timerService: import("@agoric/time").TimerService;
-                timerBrand: import("@agoric/time").TimerBrand;
             }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
                 publicFacet: import("@endo/exo").Guarded<{
                     makeStakeBldInvitation(): Promise<Invitation<{

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

@@ -1 +1 @@
-{"version":3,"file":"start-stakeBld.d.ts","sourceRoot":"","sources":["start-stakeBld.js"],"names":[],"mappings":"AAmBO,+UAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,OAqBX,GAAG;;;;;0CA6BF,MACjB,KAAK,CAAC;yCAiBK,QAEf,KAAI,CAAC,mBAA2B,OAAO;yCAoBF,OAC7B,KAAJ,CAAC;;;uCAQ+a,EAAE;;;mCAAg0E,OAAO,sBAAsB,EAAE,SAAS;;;wCAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;;;;;;;;wBApEz+G,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;2EAoEw2B,OAAO,KAAK,CAAC;;;6EAAid,OAAO,KAAK,CAAC;;;;;;;;;;;2EAAs4B,OAAO,KAAK,CAAC;;;6EAA+yB,OAAO,KAAK,CAAC;6CA/B7jG,QAEf,KAAI,CAAC,mBAA2B,OAAO;6CAoBF,OAC7B,KAAJ,CAAC;;;2CAQ+a,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAjG5a,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBA8DH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;sBA5GqB,gCAAgC"}
+{"version":3,"file":"start-stakeBld.d.ts","sourceRoot":"","sources":["start-stakeBld.js"],"names":[],"mappings":"AAmBO,+UAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,OAwB3B,GAAD;;;;;0CA2BqC,MAAM,KAAK,CAAC;yCAkBlD,QACE,KAAA,CAAC,mBACW,OAAO;yCAsBS,OAAO,KAAK,CAAC;;;uCAI+d,EAAE;;;mCAAg0E,OAAO,sBAAsB,EAAE,SAAS;;;wCAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;;;;;;;wBAlErjH,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;2EAkEgjC,OAAO,KAAK,CAAC;;;6EAAid,OAAO,KAAK,CAAC;;;;;;;;;;;2EAAs4B,OAAO,KAAK,CAAC;;;6EAA+yB,OAAO,KAAK,CAAC;6CA5B9xG,QACE,KAAA,CAAC,mBACW,OAAO;6CAsBS,OAAO,KAAK,CAAC;;;2CAI+d,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA/FpgB,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBA4DH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;sBA1GqB,gCAAgC"}

package/src/proposals/start-stakeBld.js

@@ -48,10 +48,9 @@ export const startStakeBld = async ({
   // NB: committee must only publish what it intended to be public
   const marshaller = await E(board).getPublishingMarshaller();
 
-  const [agoricNames, timerService, timerBrand] = await Promise.all([
+  const [agoricNames, timerService] = await Promise.all([
     agoricNamesP,
     chainTimerServiceP,
-    chainTimerServiceP.then(ts => E(ts).getTimerBrand()),
   ]);
 
   /**
@@ -69,7 +68,6 @@ export const startStakeBld = async ({
       agoricNames,
       localchain: await localchain,
       timerService,
-      timerBrand,
       storageNode,
       marshaller,
     },

package/src/typeGuards.d.ts

@@ -30,5 +30,9 @@ export namespace DelegationShape {
     let shares: import("@endo/patterns").Matcher;
 }
 export const IBCTransferOptionsShape: import("@endo/patterns").Matcher;
+export const IBCChannelIDShape: import("@endo/patterns").Matcher;
+export const IBCChannelInfoShape: import("@endo/patterns").Matcher;
+export const IBCConnectionIDShape: import("@endo/patterns").Matcher;
+export const IBCConnectionInfoShape: import("@endo/patterns").Matcher;
 export const CosmosChainInfoShape: import("@endo/patterns").Matcher;
 //# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAGA;;;;GAIG;;;;;;;;;;;;;;;;;;;;;AAiBH,8DAAkE;;;;;;AAQlE,uEAUE;AAEF,oEAYE"}
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAGA;;;;GAIG;;;;;;;;;;;;;;;;;;;;;AAiBH,8DAAkE;;;;;;AAQlE,uEAUE;AAEF,iEAA4C;AAC5C,mEAQG;AACH,oEAA+C;AAC/C,sEAiBG;AAEH,oEAYE"}

package/src/typeGuards.js

@@ -42,13 +42,43 @@ export const IBCTransferOptionsShape = M.splitRecord(
   },
 );
 
+export const IBCChannelIDShape = M.string();
+export const IBCChannelInfoShape = M.splitRecord({
+  portId: M.string(),
+  channelId: IBCChannelIDShape,
+  counterPartyPortId: M.string(),
+  counterPartyChannelId: IBCChannelIDShape,
+  ordering: M.scalar(), // XXX
+  state: M.scalar(), // XXX
+  version: M.string(),
+});
+export const IBCConnectionIDShape = M.string();
+export const IBCConnectionInfoShape = M.splitRecord({
+  id: IBCConnectionIDShape,
+  client_id: M.string(),
+  state: M.scalar(), // XXX STATE_OPEN or...
+  counterparty: {
+    client_id: M.string(),
+    connection_id: IBCConnectionIDShape,
+    prefix: {
+      key_prefix: M.string(),
+    },
+  },
+  versions: M.arrayOf({
+    identifier: M.string(),
+    features: M.arrayOf(M.string()),
+  }),
+  delay_period: M.nat(),
+  transferChannel: IBCChannelInfoShape,
+});
+
 export const CosmosChainInfoShape = M.splitRecord(
   {
     chainId: M.string(),
     connections: M.record(),
-    stakingTokens: M.arrayOf({ denom: M.string() }),
   },
   {
+    stakingTokens: M.arrayOf({ denom: M.string() }),
     icaEnabled: M.boolean(),
     icqEnabled: M.boolean(),
     pfmEnabled: M.boolean(),

package/src/utils/chainHub.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @import {NameHub} from '@agoric/vats';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Zone} from '@agoric/zone';
+ */
+/** agoricNames key for ChainInfo hub */
+export const CHAIN_KEY: "chain";
+/** namehub for connection info */
+export const CONNECTIONS_KEY: "chainConnection";
+export function connectionKey(chainId1: string, chainId2: string): string;
+export function makeChainHub(agoricNames: Remote<NameHub>, zone?: Zone | undefined): {
+    /**
+     * Register a new chain. The name will override a name in well known chain
+     * names.
+     *
+     * If a durable zone was not provided, registration will not survive a
+     * reincarnation of the vat. Then if the chain is not yet in the well known
+     * names at that point, it will have to be registered again. In an unchanged
+     * contract `start` the call will happen again naturally.
+     *
+     * @param {string} name
+     * @param {CosmosChainInfo} chainInfo
+     */
+    registerChain(name: string, chainInfo: CosmosChainInfo): void;
+    /**
+     * @param {string} chainName
+     * @returns {Promise<CosmosChainInfo>}
+     */
+    getChainInfo(chainName: string): Promise<CosmosChainInfo>;
+    /**
+     * @param {string} srcChainId
+     * @param {string} destChainId
+     * @param {IBCConnectionInfo} connectionInfo
+     */
+    registerConnection(srcChainId: string, destChainId: string, connectionInfo: IBCConnectionInfo): void;
+    /**
+     * @param {string} srcChainId
+     * @param {string} destChainId
+     * @returns {Promise<IBCConnectionInfo>}
+     */
+    getConnectionInfo(srcChainId: string, destChainId: string): Promise<IBCConnectionInfo>;
+};
+export function registerChain(agoricNamesAdmin: ERef<import("@agoric/vats").NameHubKit["nameAdmin"]>, name: string, chainInfo: CosmosChainInfo): Promise<void>;
+export type ChainHub = ReturnType<typeof makeChainHub>;
+import type { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { Zone } from '@agoric/zone';
+import type { CosmosChainInfo } from '../cosmos-api.js';
+import type { IBCConnectionInfo } from '../cosmos-api.js';
+//# sourceMappingURL=chainHub.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chainHub.d.ts","sourceRoot":"","sources":["chainHub.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AAEH,wCAAwC;AACxC,gCAAiC;AACjC,kCAAkC;AAClC,gDAAiD;AAU1C,wCAHI,MAAM,YACN,MAAM,UAG4B;AAMtC;IAaH;;;;;;;;;;;OAWG;wBAFQ,MAAM;IAMjB;;;OAGG;4BAFQ,MAAM;IAiBjB;;;;OAIG;mCAHQ,MAAM,eACN,MAAM;IAQjB;;;;OAIG;kCAHQ,MAAM,eACN,MAAM;EAsBpB;AAQM,gDAJI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,QACpD,MAAM,6CAkBhB;uBAtBa,UAAU,CAAC,OAAO,YAAY,CAAC;6BA3GnB,cAAc;4BAEf,kBAAkB;0BACpB,cAAc;qCAFgB,kBAAkB;uCAAlB,kBAAkB"}

package/src/utils/chainHub.js

@@ -0,0 +1,136 @@
+import { E } from '@endo/far';
+import { M, mustMatch } from '@endo/patterns';
+import { makeHeapZone } from '@agoric/zone';
+import { CosmosChainInfoShape, IBCConnectionInfoShape } from '../typeGuards.js';
+
+/**
+ * @import {NameHub} from '@agoric/vats';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api.js';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Zone} from '@agoric/zone';
+ */
+
+/** agoricNames key for ChainInfo hub */
+export const CHAIN_KEY = 'chain';
+/** namehub for connection info */
+export const CONNECTIONS_KEY = 'chainConnection';
+
+/**
+ * The entries of the top-level namehubs in agoricNames are reflected to
+ * vstorage. But only the top level. So we combine the 2 chain ids into 1 key.
+ * Connections are directionless, so we sort the ids.
+ *
+ * @param {string} chainId1
+ * @param {string} chainId2
+ */
+export const connectionKey = (chainId1, chainId2) =>
+  JSON.stringify([chainId1, chainId2].sort());
+
+/**
+ * @param {Remote<NameHub>} agoricNames
+ * @param {Zone} [zone]
+ */
+export const makeChainHub = (agoricNames, zone = makeHeapZone()) => {
+  /** @type {MapStore<string, CosmosChainInfo>} */
+  const chainInfos = zone.mapStore('chainInfos', {
+    keyShape: M.string(),
+    valueShape: CosmosChainInfoShape,
+  });
+  /** @type {MapStore<string, IBCConnectionInfo>} */
+  const connectionInfos = zone.mapStore('connectionInfos', {
+    keyShape: M.string(),
+    valueShape: IBCConnectionInfoShape,
+  });
+
+  const chainHub = harden({
+    /**
+     * Register a new chain. The name will override a name in well known chain
+     * names.
+     *
+     * If a durable zone was not provided, registration will not survive a
+     * reincarnation of the vat. Then if the chain is not yet in the well known
+     * names at that point, it will have to be registered again. In an unchanged
+     * contract `start` the call will happen again naturally.
+     *
+     * @param {string} name
+     * @param {CosmosChainInfo} chainInfo
+     */
+    registerChain(name, chainInfo) {
+      chainInfos.init(name, chainInfo);
+    },
+    /**
+     * @param {string} chainName
+     * @returns {Promise<CosmosChainInfo>}
+     */
+    async getChainInfo(chainName) {
+      // Either from registerChain or memoized remote lookup()
+      if (chainInfos.has(chainName)) {
+        return chainInfos.get(chainName);
+      }
+
+      const chainInfo = await E(agoricNames)
+        .lookup(CHAIN_KEY, chainName)
+        .catch(_cause => {
+          throw assert.error(`chain not found:${chainName}`);
+        });
+      chainInfos.init(chainName, chainInfo);
+      return chainInfo;
+    },
+    /**
+     * @param {string} srcChainId
+     * @param {string} destChainId
+     * @param {IBCConnectionInfo} connectionInfo
+     */
+    registerConnection(srcChainId, destChainId, connectionInfo) {
+      const key = connectionKey(srcChainId, destChainId);
+      connectionInfos.init(key, connectionInfo);
+    },
+
+    /**
+     * @param {string} srcChainId
+     * @param {string} destChainId
+     * @returns {Promise<IBCConnectionInfo>}
+     */
+    async getConnectionInfo(srcChainId, destChainId) {
+      const key = connectionKey(srcChainId, destChainId);
+      if (connectionInfos.has(key)) {
+        return connectionInfos.get(key);
+      }
+
+      const connectionInfo = await E(agoricNames)
+        .lookup(CONNECTIONS_KEY, key)
+        .catch(_cause => {
+          throw assert.error(
+            `connection not found: ${srcChainId}<->${destChainId}`,
+          );
+        });
+      connectionInfos.init(key, connectionInfo);
+      return connectionInfo;
+    },
+  });
+
+  return chainHub;
+};
+/** @typedef {ReturnType<typeof makeChainHub>} ChainHub */
+
+/**
+ * @param {ERef<import('@agoric/vats').NameHubKit['nameAdmin']>} agoricNamesAdmin
+ * @param {string} name
+ * @param {CosmosChainInfo} chainInfo
+ */
+export const registerChain = async (agoricNamesAdmin, name, chainInfo) => {
+  const { nameAdmin } = await E(agoricNamesAdmin).provideChild('chain');
+  const { nameAdmin: connAdmin } =
+    await E(agoricNamesAdmin).provideChild('chainConnection');
+
+  mustMatch(chainInfo, CosmosChainInfoShape);
+  // XXX chainInfo.connections is redundant here.
+  await E(nameAdmin).update(name, chainInfo);
+
+  for await (const [destChainId, connInfo] of Object.entries(
+    chainInfo.connections,
+  )) {
+    const key = connectionKey(chainInfo.chainId, destChainId);
+    await E(connAdmin).update(key, connInfo);
+  }
+};

package/src/utils/time.d.ts

@@ -1,8 +1,5 @@
-/**
- * @param {TimerService} timer
- * @param {TimerBrand} timerBrand
- */
-export function makeTimestampHelper(timer: TimerService, timerBrand: TimerBrand): {
+/** @param {Remote<TimerService>} timer */
+export function makeTimestampHelper(timer: Remote<TimerService>): {
     /**
      * Takes the current time from ChainTimerService and adds a relative time to
      * determine a timeout timestamp in nanoseconds. Useful for
@@ -16,13 +13,13 @@ export function makeTimestampHelper(timer: TimerService, timerBrand: TimerBrand)
 };
 /**
  * @import {RelativeTimeRecord, TimerBrand, TimerService} from '@agoric/time';
- * @import {MsgTransfer} from '@agoric/cosmic-proto/ibc/applications/transfer/v1/tx.js';
+ * @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 { TimerBrand } 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

@@ -1 +1 @@
-{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["time.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAEI;;;;;;;;OAQG;0EAFU,OAAO,CAAC,MAAM,CAAC;EAc/B;AAlCD;;;GAGG;AAEH,qCAAsC;AACtC,iDAAqD;AAuC9C,oCAHI,IAAI,GACF,MAAM,CAE2D;8BAThE,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;kCAnCE,cAAc;gCAAd,cAAc;wCAAd,cAAc"}
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["time.js"],"names":[],"mappings":"AAWA,0CAA0C;AAC1C;IAUI;;;;;;;;OAQG;0EAFU,OAAO,CAAC,MAAM,CAAC;EAiB/B;AA1CD;;;GAGG;AAEH,qCAAsC;AACtC,iDAAqD;AA+C9C,oCAHI,IAAI,GACF,MAAM,CAE2D;8BAThE,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;kCA3CE,cAAc;4BACpD,kBAAkB;wCADoB,cAAc"}

package/src/utils/time.js

@@ -3,17 +3,22 @@ import { TimeMath } from '@agoric/time';
 
 /**
  * @import {RelativeTimeRecord, TimerBrand, TimerService} from '@agoric/time';
- * @import {MsgTransfer} from '@agoric/cosmic-proto/ibc/applications/transfer/v1/tx.js';
+ * @import {Remote} from '@agoric/internal';
  */
 
 export const SECONDS_PER_MINUTE = 60n;
 export const NANOSECONDS_PER_SECOND = 1_000_000_000n;
 
-/**
- * @param {TimerService} timer
- * @param {TimerBrand} timerBrand
- */
-export function makeTimestampHelper(timer, timerBrand) {
+/** @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({
     /**
      * Takes the current time from ChainTimerService and adds a relative time to
@@ -28,7 +33,10 @@ export function makeTimestampHelper(timer, timerBrand) {
       const currentTime = await E(timer).getCurrentTimestamp();
       const timeout =
         relativeTime ||
-        TimeMath.coerceRelativeTimeRecord(SECONDS_PER_MINUTE * 5n, timerBrand);
+        TimeMath.coerceRelativeTimeRecord(
+          SECONDS_PER_MINUTE * 5n,
+          await getBrand(),
+        );
       return (
         TimeMath.addAbsRel(currentTime, timeout).absValue *
         NANOSECONDS_PER_SECOND