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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-27cc9b8.0+27cc9b8",
+  "version": "0.1.1-dev-96c19f5.0+96c19f5",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -31,19 +31,19 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-27cc9b8.0+27cc9b8",
-    "@agoric/cosmic-proto": "0.4.1-dev-27cc9b8.0+27cc9b8",
-    "@agoric/ertp": "0.16.3-dev-27cc9b8.0+27cc9b8",
-    "@agoric/internal": "0.3.3-dev-27cc9b8.0+27cc9b8",
-    "@agoric/network": "0.1.1-dev-27cc9b8.0+27cc9b8",
-    "@agoric/notifier": "0.6.3-dev-27cc9b8.0+27cc9b8",
-    "@agoric/store": "0.9.3-dev-27cc9b8.0+27cc9b8",
-    "@agoric/time": "0.3.3-dev-27cc9b8.0+27cc9b8",
-    "@agoric/vat-data": "0.5.3-dev-27cc9b8.0+27cc9b8",
-    "@agoric/vats": "0.15.2-dev-27cc9b8.0+27cc9b8",
-    "@agoric/vow": "0.1.1-dev-27cc9b8.0+27cc9b8",
-    "@agoric/zoe": "0.26.3-dev-27cc9b8.0+27cc9b8",
-    "@agoric/zone": "0.2.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/assert": "0.6.1-dev-96c19f5.0+96c19f5",
+    "@agoric/cosmic-proto": "0.4.1-dev-96c19f5.0+96c19f5",
+    "@agoric/ertp": "0.16.3-dev-96c19f5.0+96c19f5",
+    "@agoric/internal": "0.3.3-dev-96c19f5.0+96c19f5",
+    "@agoric/network": "0.1.1-dev-96c19f5.0+96c19f5",
+    "@agoric/notifier": "0.6.3-dev-96c19f5.0+96c19f5",
+    "@agoric/store": "0.9.3-dev-96c19f5.0+96c19f5",
+    "@agoric/time": "0.3.3-dev-96c19f5.0+96c19f5",
+    "@agoric/vat-data": "0.5.3-dev-96c19f5.0+96c19f5",
+    "@agoric/vats": "0.15.2-dev-96c19f5.0+96c19f5",
+    "@agoric/vow": "0.1.1-dev-96c19f5.0+96c19f5",
+    "@agoric/zoe": "0.26.3-dev-96c19f5.0+96c19f5",
+    "@agoric/zone": "0.2.3-dev-96c19f5.0+96c19f5",
     "@endo/base64": "^1.0.5",
     "@endo/far": "^1.1.2",
     "@endo/marshal": "^1.5.0",
@@ -84,5 +84,5 @@
   "typeCoverage": {
     "atLeast": 97.1
   },
-  "gitHead": "27cc9b8be59abb048f1ea226b96697c3dccc4d0f"
+  "gitHead": "96c19f54bd17fd616883713d372a9dc8ca0140f9"
 }

package/src/chain-info.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-info.d.ts","sourceRoot":"","sources":["chain-info.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHO,yDAHI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,OACpD,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,iBAazC;;qCA1H+C,YAAY;kCAAZ,YAAY"}
+{"version":3,"file":"chain-info.d.ts","sourceRoot":"","sources":["chain-info.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoHO,yDAHI,IAAI,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,OACpD,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,iBAOzC;;qCAnHgD,YAAY;kCAAZ,YAAY"}

package/src/chain-info.js

@@ -2,11 +2,9 @@
 
 /** @file temporary static lookup of chain info */
 
-import { E } from '@endo/far';
+import { registerChain } from './utils/chainHub.js';
 
-/**
- * @import {CosmosChainInfo, EthChainInfo} from './types.js';
- */
+/** @import {CosmosChainInfo, EthChainInfo} from './types.js'; */
 
 /** @typedef {CosmosChainInfo | EthChainInfo} ChainInfo */
 
@@ -83,7 +81,7 @@ export const wellKnownChainInfo =
         stakingTokens: [{ denom: 'ustride' }],
       },
       cosmos: {
-        chainId: 'cosmoshub-4',
+        chainId: 'cosmoslocal',
         connections: {},
         icaEnabled: true,
         icqEnabled: true,
@@ -101,7 +99,7 @@ export const wellKnownChainInfo =
         stakingTokens: [{ denom: 'utia' }],
       },
       osmosis: {
-        chainId: 'osmosis-1',
+        chainId: 'osmosislocal',
         connections: {},
         icaEnabled: true,
         icqEnabled: true,
@@ -117,14 +115,8 @@ export const wellKnownChainInfo =
  * @param {(...messages: string[]) => void} log
  */
 export const registerChainNamespace = async (agoricNamesAdmin, log) => {
-  const { nameAdmin } = await E(agoricNamesAdmin).provideChild('chain');
-
-  const registrationPromises = Object.entries(wellKnownChainInfo).map(
-    async ([name, info]) => {
-      log(`registering chain ${name}`);
-      return E(nameAdmin).update(name, info);
-    },
-  );
-
-  await Promise.all(registrationPromises);
+  for await (const [name, info] of Object.entries(wellKnownChainInfo)) {
+    log(`registering agoricNames chain.${name}`);
+    await registerChain(agoricNamesAdmin, name, info);
+  }
 };

package/src/examples/sendAnywhere.contract.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api';
+ * @import {TimerService, TimerBrand} from '@agoric/time';
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Remote} from '@agoric/vow';
+ */
+/**
+ * @typedef {{
+ *   localchain: Remote<LocalChain>;
+ *   orchestrationService: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timerService: Remote<TimerService>;
+ *   agoricNames: Remote<NameHub>;
+ * }} OrchestrationPowers
+ */
+export const SingleAmountRecord: import("@endo/patterns").Matcher;
+export function start(zcf: ZCF, privateArgs: OrchestrationPowers & {
+    marshaller: Marshaller;
+}, baggage: Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        makeSendInvitation(): Promise<Invitation<unknown, never>>;
+    }>;
+    creatorFacet: import("@endo/exo").Guarded<{
+        /**
+         * @param {CosmosChainInfo} chainInfo
+         * @param {IBCConnectionInfo} connectionInfo
+         */
+        addChain(chainInfo: CosmosChainInfo, connectionInfo: IBCConnectionInfo): Promise<string>;
+    }>;
+}>;
+export type OrchestrationPowers = {
+    localchain: Remote<import("@endo/exo").Guarded<{
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            getAddress(): string;
+            getBalance(brand: Brand<"nat">): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
+            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<globalThis.Amount>;
+            withdraw(amount: Amount<"nat">): Promise<globalThis.Payment<"nat">>;
+            executeTx<MT extends {
+                '@type': string;
+            }[]>(messages: MT): Promise<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
+            monitorTransfers(tap: any): Promise<any>;
+        }>>;
+        query(request: import("@agoric/cosmic-proto").TypedJson): Promise<{
+            '@type': string;
+        }>;
+        queryMany(requests: import("@agoric/cosmic-proto").TypedJson[]): Promise<{
+            error?: string | undefined;
+            reply: {
+                '@type': string;
+            };
+        }[]>;
+    }>>;
+    orchestrationService: Remote<import("@endo/exo").Guarded<{
+        makeAccount(hostConnectionId: `connection-${number}`, controllerConnectionId: `connection-${number}`): Promise<import("../cosmos-api").IcaAccount>;
+        provideICQConnection(controllerConnectionId: `connection-${number}`): Promise<import("@endo/exo").Guarded<{
+            getLocalAddress(): `/ibc-port/${string}`;
+            getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
+            query(msgs: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").RequestQuery>[]): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
+        }>>;
+    }>>;
+    storageNode: Remote<globalThis.StorageNode>;
+    timerService: Remote<TimerService>;
+    agoricNames: Remote<NameHub>;
+};
+import type { Baggage } from '@agoric/vat-data';
+import type { CosmosChainInfo } from '../cosmos-api';
+import type { IBCConnectionInfo } from '../cosmos-api';
+import type { Remote } from '@agoric/vow';
+import type { TimerService } from '@agoric/time';
+import type { NameHub } from '@agoric/vats';
+//# sourceMappingURL=sendAnywhere.contract.d.ts.map

package/src/examples/sendAnywhere.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AAEH,kEAKE;AASK,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB;;;;;QAqGE;;;WAGG;;;GAgBR;;;;;8BArHgD,MAAM,KACvD,CAAC;6BAYG,QAAK,KACT,CAAC,mBACuB,OAAM;6BAuBM,OAAO,KAAK,CAAC;;;2BAczC,EAAA;;;uBAkE+lB,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;;;;;;;;;;;6BAvJx0C,kBAAkB;qCACS,eAAe;uCAAf,eAAe;4BAK3C,aAAa;kCAJK,cAAc;6BAG/B,cAAc"}

package/src/examples/sendAnywhere.contract.js

@@ -0,0 +1,168 @@
+import { makeDurableZone } from '@agoric/zone/durable.js';
+import { M, mustMatch } from '@endo/patterns';
+import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { E } from '@endo/far';
+import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
+
+import { AmountShape } from '@agoric/ertp';
+import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
+import { CosmosChainInfoShape } from '../typeGuards.js';
+import { makeOrchestrationFacade } from '../facade.js';
+import { prepareLocalChainAccountKit } from '../exos/local-chain-account-kit.js';
+import { makeChainHub } from '../utils/chainHub.js';
+
+const { entries } = Object;
+const { Fail } = assert;
+
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api';
+ * @import {TimerService, TimerBrand} from '@agoric/time';
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Remote} from '@agoric/vow';
+ */
+
+/**
+ * @typedef {{
+ *   localchain: Remote<LocalChain>;
+ *   orchestrationService: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timerService: Remote<TimerService>;
+ *   agoricNames: Remote<NameHub>;
+ * }} OrchestrationPowers
+ */
+
+export const SingleAmountRecord = M.and(
+  M.recordOf(M.string(), AmountShape, {
+    numPropertiesLimit: 1,
+  }),
+  M.not(harden({})),
+);
+
+/**
+ * @param {ZCF} zcf
+ * @param {OrchestrationPowers & {
+ *   marshaller: Marshaller;
+ * }} privateArgs
+ * @param {Baggage} baggage
+ */
+export const start = async (zcf, privateArgs, baggage) => {
+  const zone = makeDurableZone(baggage);
+
+  const chainHub = makeChainHub(privateArgs.agoricNames);
+
+  // TODO once durability is settled, provide some helpers to reduce boilerplate
+  const { marshaller, ...orchPowers } = privateArgs;
+  const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
+  const makeLocalChainAccountKit = prepareLocalChainAccountKit(
+    zone,
+    makeRecorderKit,
+    zcf,
+    privateArgs.timerService,
+    chainHub,
+  );
+  const { orchestrate } = makeOrchestrationFacade({
+    zcf,
+    zone,
+    chainHub,
+    makeLocalChainAccountKit,
+    ...orchPowers,
+  });
+
+  let contractAccount;
+
+  const findBrandInVBank = async brand => {
+    const assets = await E(
+      E(privateArgs.agoricNames).lookup('vbankAsset'),
+    ).values();
+    const it = assets.find(a => a.brand === brand);
+    it || Fail`brand ${brand} not in agoricNames.vbankAsset`;
+    return it;
+  };
+
+  /** @type {OfferHandler} */
+  const sendIt = orchestrate(
+    'sendIt',
+    { zcf },
+    // eslint-disable-next-line no-shadow -- this `zcf` is enclosed in a membrane
+    async (orch, { zcf }, seat, offerArgs) => {
+      mustMatch(
+        offerArgs,
+        harden({ chainName: M.scalar(), destAddr: M.string() }),
+      );
+      const { chainName, destAddr } = offerArgs;
+      const { give } = seat.getProposal();
+      const [[kw, amt]] = entries(give);
+      const { denom } = await findBrandInVBank(amt.brand);
+      const chain = await orch.getChain(chainName);
+
+      // XXX ok to use a heap var crossing the membrane scope this way?
+      if (!contractAccount) {
+        const agoricChain = await orch.getChain('agoric');
+        contractAccount = await agoricChain.makeAccount();
+      }
+
+      const info = await chain.getChainInfo();
+      const { chainId } = info;
+      const { [kw]: pmtP } = await withdrawFromSeat(zcf, seat, give);
+      await E.when(pmtP, pmt => contractAccount.deposit(pmt, amt));
+      await contractAccount.transfer(
+        { denom, value: amt.value },
+        {
+          address: destAddr,
+          addressEncoding: 'bech32',
+          chainId,
+        },
+      );
+    },
+  );
+
+  const publicFacet = zone.exo(
+    'Send PF',
+    M.interface('Send PF', {
+      makeSendInvitation: M.callWhen().returns(InvitationShape),
+    }),
+    {
+      makeSendInvitation() {
+        return zcf.makeInvitation(
+          sendIt,
+          'send',
+          undefined,
+          M.splitRecord({ give: SingleAmountRecord }),
+        );
+      },
+    },
+  );
+
+  let nonce = 0n;
+  const ConnectionInfoShape = M.record(); // TODO
+  const creatorFacet = zone.exo(
+    'Send CF',
+    M.interface('Send CF', {
+      addChain: M.callWhen(CosmosChainInfoShape, ConnectionInfoShape).returns(
+        M.scalar(),
+      ),
+    }),
+    {
+      /**
+       * @param {CosmosChainInfo} chainInfo
+       * @param {IBCConnectionInfo} connectionInfo
+       */
+      async addChain(chainInfo, connectionInfo) {
+        const chainKey = `${chainInfo.chainId}-${(nonce += 1n)}`;
+        const agoricChainInfo = await chainHub.getChainInfo('agoric');
+        chainHub.registerChain(chainKey, chainInfo);
+        chainHub.registerConnection(
+          agoricChainInfo.chainId,
+          chainInfo.chainId,
+          connectionInfo,
+        );
+        return chainKey;
+      },
+    },
+  );
+
+  return { publicFacet, creatorFacet };
+};

package/src/examples/stakeBld.contract.d.ts

@@ -24,7 +24,6 @@ export function start(zcf: ZCF, privateArgs: {
     marshaller: Marshaller;
     storageNode: StorageNode;
     timerService: TimerService;
-    timerBrand: TimerBrand;
 }, baggage: import("@agoric/vat-data").Baggage): Promise<{
     publicFacet: import("@endo/exo").Guarded<{
         /**
@@ -130,5 +129,4 @@ export function start(zcf: ZCF, privateArgs: {
 import type { NameHub } from '@agoric/vats';
 import type { Remote } from '@agoric/internal';
 import type { TimerService } from '@agoric/time';
-import type { TimerBrand } from '@agoric/time';
 //# sourceMappingURL=stakeBld.contract.d.ts.map

package/src/examples/stakeBld.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stakeBld.contract.d.ts","sourceRoot":"","sources":["stakeBld.contract.js"],"names":[],"mappings":"AAkCO,2BAXI,GAAG;;;;;8BA0BY,MAAM,KAAK,CAAC;6BAiBF,QAAQ,KAAK,CAAC,mBAA4B,OAAM;6BAkB7E,OACD,KAAE,CAAC;;;2BAaK,EAAE;;;uBAoCs5C,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;gBA3GhpE,UAAU;iBACT,WAAW;;;YAIlB,OAAO,kBAAkB,EAAE,OAAO;;QAkDvC;;WAEG;;;;;;;;;;+DAiCqB,OACtB,KAAH,CAAC;;;iEAgB0B,OAAO,KAAK,CAAC;;;;;;;;;;;+DAAs4B,OAAO,KAAK,CAAC;;;iEAA+yB,OAAO,KAAK,CAAC;iCApExtD,QAAQ,KAAK,CAAC,mBAA4B,OAAM;iCAkB7E,OACD,KAAE,CAAC;;;+BAaK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;QAgBV;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBR;6BAvHyB,cAAc;4BACf,kBAAkB;kCACA,cAAc;gCAAd,cAAc"}
+{"version":3,"file":"stakeBld.contract.d.ts","sourceRoot":"","sources":["stakeBld.contract.js"],"names":[],"mappings":"AAkCO,2BAVI,GAAG;;;;;8BA4Be,MAAM,KAAK,CAAC;6BAgB1B,QAAQ,KAAK,CAAC,mBACJ,OAAO;6BAaa,OAAO,KAAK,CAAC;;;2BAmBvC,EAAE;;;uBAyBooD,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;gBAlGn4E,UAAU;iBACT,WAAW;;YAGlB,OAAO,kBAAkB,EAAE,OAAO;;QA0CvC;;WAEG;;;;;;;;;;+DA2CA,OAAO,KAAK,CAAC;;;iEAOyX,OAAO,KAAK,CAAC;;;;;;;;;;;+DAAs4B,OAAO,KAAK,CAAC;;;iEAA+yB,OAAO,KAAK,CAAC;iCA1D5lE,QAAQ,KAAK,CAAC,mBACJ,OAAO;iCAaa,OAAO,KAAK,CAAC;;;+BAmBvC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;QAKf;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBR;6BA9GyB,cAAc;4BACf,kBAAkB;kCACZ,cAAc"}

package/src/examples/stakeBld.contract.js

@@ -10,11 +10,12 @@ import { E } from '@endo/far';
 import { deeplyFulfilled } from '@endo/marshal';
 import { M } from '@endo/patterns';
 import { prepareLocalChainAccountKit } from '../exos/local-chain-account-kit.js';
+import { makeChainHub } from '../utils/chainHub.js';
 
 /**
  * @import {NameHub} from '@agoric/vats';
  * @import {Remote} from '@agoric/internal';
- * @import {TimerBrand, TimerService} from '@agoric/time';
+ * @import {TimerService} from '@agoric/time';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
  */
 
@@ -28,7 +29,6 @@ const trace = makeTracer('StakeBld');
  *   marshaller: Marshaller;
  *   storageNode: StorageNode;
  *   timerService: TimerService;
- *   timerBrand: TimerBrand;
  * }} privateArgs
  * @param {import('@agoric/vat-data').Baggage} baggage
  */
@@ -45,20 +45,12 @@ export const start = async (zcf, privateArgs, baggage) => {
     privateArgs.marshaller,
   );
 
-  // FIXME in a second incarnation we can't make a remote call before defining all kinds
-  // UNTIL https://github.com/Agoric/agoric-sdk/issues/8879
-  const agoricChainInfo = await E(privateArgs.agoricNames).lookup(
-    'chain',
-    'agoric',
-  );
-
   const makeLocalChainAccountKit = prepareLocalChainAccountKit(
     zone,
     makeRecorderKit,
     zcf,
     privateArgs.timerService,
-    privateArgs.timerBrand,
-    agoricChainInfo,
+    makeChainHub(privateArgs.agoricNames),
   );
 
   async function makeLocalAccountKit() {

package/src/examples/swapExample.contract.d.ts

@@ -46,6 +46,7 @@ export function start(zcf: ZCF, privateArgs: {
     }>>;
     storageNode: Remote<globalThis.StorageNode>;
     timerService: Remote<TimerService>;
+    marshaller: Marshaller;
 }, baggage: Baggage): Promise<{
     publicFacet: {
         makeSwapAndStakeInvitation: () => Promise<Invitation<unknown, {

package/src/examples/swapExample.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AAEH,2BAA2B;AAC3B,mBADW,YAAY,CAUrB;AASK,0CAHI,KAAK;;;EAIsC;AAa/C,2BAVI,GAAG;;;;;8BAIwC,MACjD,KAAG,CAAC;6BAmBA,QACL,KAAC,CAAC,mBACW,OAAO;6BAqBQ,OAAO,KAAK,CAAC;;;2BAgB9B,EAAE;;;uBAsCs1C,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;oBAhEjlE,MAAM,CAAC,KAAK,CAAC;;;;;oBAAb,MAAM,CAAC,KAAK,CAAC;;;;GA+D7B;6BA9HyB,cAAc;4BAHf,kBAAkB;gCAHwB,aAAa;kCACjD,cAAc;6BAInB,kBAAkB;4CALuB,aAAa"}
+{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AAEH,2BAA2B;AAC3B,mBADW,YAAY,CAWrB;AASK,0CAHI,KAAK;;;EAIsC;AAc/C,2BAXI,GAAG;;;;;8BAJV,MAAM,KAAK,CAAC;6BAec,QAAQ,KAAK,CAAC,mBACjC,OAAO;6BAyBd,OAAI,KAAK,CAAC;;;2BAqBgB,EAAE;;;uBAwD4uB,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;;;;;;;;;gBA3Gt/C,UAAU;;;;oBA2CV,MAAM,CAAC,KAAK,CAAC;;;;;oBAAb,MAAM,CAAC,KAAK,CAAC;;;;GA+D7B;6BA5IyB,cAAc;4BAHf,kBAAkB;gCAHwB,aAAa;kCACjD,cAAc;6BAInB,kBAAkB;4CALuB,aAAa"}

package/src/examples/swapExample.contract.js

@@ -5,8 +5,11 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 import { Far } from '@endo/far';
 import { deeplyFulfilled } from '@endo/marshal';
 import { M, objectMap } from '@endo/patterns';
+import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { makeOrchestrationFacade } from '../facade.js';
 import { orcUtils } from '../utils/orc.js';
+import { makeChainHub } from '../utils/chainHub.js';
+import { prepareLocalChainAccountKit } from '../exos/local-chain-account-kit.js';
 
 /**
  * @import {Orchestrator, IcaAccount, CosmosValidatorAddress} from '../types.js'
@@ -25,6 +28,7 @@ export const meta = {
     localchain: M.remotable('localchain'),
     orchestrationService: M.or(M.remotable('orchestration'), null),
     storageNode: StorageNodeShape,
+    marshaller: M.remotable('marshaller'),
     timerService: M.or(TimerServiceShape, null),
   },
   upgradability: 'canUpgrade',
@@ -48,6 +52,7 @@ export const makeNatAmountShape = (brand, min) =>
  *   orchestrationService: Remote<OrchestrationService>;
  *   storageNode: Remote<StorageNode>;
  *   timerService: Remote<TimerService>;
+ *   marshaller: Marshaller;
  * }} privateArgs
  * @param {Baggage} baggage
  */
@@ -62,16 +67,28 @@ export const start = async (zcf, privateArgs, baggage) => {
     orchestrationService,
     storageNode,
     timerService,
+    marshaller,
   } = privateArgs;
 
+  const chainHub = makeChainHub(agoricNames);
+  const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
+  const makeLocalChainAccountKit = prepareLocalChainAccountKit(
+    zone,
+    makeRecorderKit,
+    zcf,
+    timerService,
+    chainHub,
+  );
+
   const { orchestrate } = makeOrchestrationFacade({
-    agoricNames,
     localchain,
     orchestrationService,
     storageNode,
     timerService,
     zcf,
     zone,
+    chainHub,
+    makeLocalChainAccountKit,
   });
 
   /** deprecated historical example */

package/src/examples/unbondExample.contract.d.ts

@@ -5,7 +5,8 @@ export function start(zcf: ZCF, privateArgs: {
             getAddress(): string;
             getBalance(brand: Brand<"nat">): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
             deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<globalThis.Amount>;
-            withdraw(amount: Amount<"nat">): Promise<globalThis.Payment<"nat">>;
+            withdraw(amount: Amount<// ??? should this be synchronous? depends on how names are resolved.
+            "nat">): Promise<globalThis.Payment<"nat">>;
             executeTx<MT extends {
                 '@type': string;
             }[]>(messages: MT): Promise<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
@@ -30,6 +31,7 @@ export function start(zcf: ZCF, privateArgs: {
         }>>;
     }>>;
     storageNode: Remote<globalThis.StorageNode>;
+    marshaller: Marshaller;
     timerService: Remote<TimerService>;
 }, baggage: Baggage): Promise<{
     publicFacet: {

package/src/examples/unbondExample.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unbondExample.contract.d.ts","sourceRoot":"","sources":["unbondExample.contract.js"],"names":[],"mappings":"AA0BO,2BAVI,GAAG;;;;;8BAsCsB,MAAM,KAAK,CAAC;6BAUnC,QAAQ,KAAK,CAAC,mBAA2B,OAAO;6BAevD,OAAE,KAAK,CAAC;;;2BAiB+I,EAAE;;;uBAAg0E,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;;;;GADztG;6BArFyB,cAAc;4BACf,kBAAkB;gCALwB,aAAa;kCACjD,cAAc;6BACnB,kBAAkB"}
+{"version":3,"file":"unbondExample.contract.d.ts","sourceRoot":"","sources":["unbondExample.contract.js"],"names":[],"mappings":"AA8BO,2BAXI,GAAG;;;;;8BAgCV,MAAC,KAAK,CAAC;6BAgBY,QAAO,KAAK,CAAC,mBACxB,OAAO;6BAYb,OADA,qEAAqE;YACrE,KADK,CAAC;;;2BAauB,EAAE;;;uBAmBo2D,OAAO,sBAAsB,EAAE,SAAS;;;4BAAyqB,OAAO,sBAAsB,EAAE,SAAS,EAAE;;;;;;;;;;;;;;;;gBAtFnnF,UAAU;;;;;;;;GAqF1B;6BAjGyB,cAAc;4BACf,kBAAkB;gCALwB,aAAa;kCACjD,cAAc;6BACnB,kBAAkB"}

package/src/examples/unbondExample.contract.js

@@ -1,7 +1,10 @@
 import { makeDurableZone } from '@agoric/zone/durable.js';
 import { Far } from '@endo/far';
 import { M } from '@endo/patterns';
+import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { makeOrchestrationFacade } from '../facade.js';
+import { makeChainHub } from '../utils/chainHub.js';
+import { prepareLocalChainAccountKit } from '../exos/local-chain-account-kit.js';
 
 /**
  * @import {Orchestrator, IcaAccount, CosmosValidatorAddress} from '../types.js'
@@ -20,6 +23,7 @@ import { makeOrchestrationFacade } from '../facade.js';
  *   localchain: Remote<LocalChain>;
  *   orchestrationService: Remote<OrchestrationService>;
  *   storageNode: Remote<StorageNode>;
+ *   marshaller: Marshaller;
  *   timerService: Remote<TimerService>;
  * }} privateArgs
  * @param {Baggage} baggage
@@ -30,18 +34,29 @@ export const start = async (zcf, privateArgs, baggage) => {
     localchain,
     orchestrationService,
     storageNode,
+    marshaller,
     timerService,
   } = privateArgs;
   const zone = makeDurableZone(baggage);
 
+  const chainHub = makeChainHub(agoricNames);
+  const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
+  const makeLocalChainAccountKit = prepareLocalChainAccountKit(
+    zone,
+    makeRecorderKit,
+    zcf,
+    privateArgs.timerService,
+    chainHub,
+  );
   const { orchestrate } = makeOrchestrationFacade({
-    agoricNames,
     localchain,
     orchestrationService,
     storageNode,
     timerService,
     zcf,
     zone,
+    chainHub: makeChainHub(agoricNames),
+    makeLocalChainAccountKit,
   });
 
   /** @type {OfferHandler} */

package/src/exos/local-chain-account-kit.d.ts

@@ -1,17 +1,13 @@
-export function prepareLocalChainAccountKit(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, zcf: ZCF, timerService: TimerService, timerBrand: TimerBrand, agoricChainInfo: CosmosChainInfo): (args_0: {
+export function prepareLocalChainAccountKit(zone: Zone, makeRecorderKit: <T>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T> | undefined) => RecorderKit<T>, zcf: ZCF, timerService: Remote<TimerService>, chainHub: {
+    registerChain(name: string, chainInfo: CosmosChainInfo): void;
+    getChainInfo(chainName: string): Promise<CosmosChainInfo>;
+    registerConnection(srcChainId: string, destChainId: string, connectionInfo: import("@agoric/orchestration").IBCConnectionInfo): void;
+    getConnectionInfo(srcChainId: string, destChainId: string): Promise<import("@agoric/orchestration").IBCConnectionInfo>;
+}): (args_0: {
     account: import("@endo/exo").Guarded<{
         getAddress(): string;
         getBalance(brand: Brand<"nat">): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
-        deposit(payment: Payment<"nat"
-        /**
-         * @param {Zone} zone
-         * @param {MakeRecorderKit} makeRecorderKit
-         * @param {ZCF} zcf
-         * @param {TimerService} timerService
-         * @param {TimerBrand} timerBrand
-         * @param {CosmosChainInfo} agoricChainInfo
-         */
-        >, optAmountShape?: Pattern): Promise<globalThis.Amount>;
+        deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<globalThis.Amount>;
         withdraw(amount: Amount<"nat">): Promise<globalThis.Payment<"nat">>;
         executeTx<MT extends {
             '@type': string;
@@ -63,25 +59,14 @@ export function prepareLocalChainAccountKit(zone: Zone, makeRecorderKit: <T>(sto
          * transferred.
          */
         /** @type {LocalChainAccount['deposit']} */
-        deposit(payment: Payment<"nat"
-        /**
-         * @param {Zone} zone
-         * @param {MakeRecorderKit} makeRecorderKit
-         * @param {ZCF} zcf
-         * @param {TimerService} timerService
-         * @param {TimerBrand} timerBrand
-         * @param {CosmosChainInfo} agoricChainInfo
-         */
-        >, optAmountShape?: Pattern): Promise<globalThis.Amount>;
+        deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<globalThis.Amount>;
         /** @type {LocalChainAccount['withdraw']} */
         withdraw(amount: Amount<"nat">): Promise<globalThis.Payment<"nat">>;
         /** @type {LocalChainAccount['executeTx']} */
         executeTx<MT extends {
             '@type': string;
         }[]>(messages: MT): Promise<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/vatsafe").ResponseTo<MT[K]>>; }>;
-        /**
-         * @returns {ChainAddress['address']}
-         */
+        /** @returns {ChainAddress['address']} */
         getAddress(): string;
         /**
          * @param {AmountArg} amount an ERTP {@link Amount} or a
@@ -103,16 +88,7 @@ export type State = {
     account: import("@endo/exo").Guarded<{
         getAddress(): string;
         getBalance(brand: Brand<"nat">): Promise<import("@agoric/ertp/src/types.js").NatAmount>;
-        deposit(payment: Payment<"nat"
-        /**
-         * @param {Zone} zone
-         * @param {MakeRecorderKit} makeRecorderKit
-         * @param {ZCF} zcf
-         * @param {TimerService} timerService
-         * @param {TimerBrand} timerBrand
-         * @param {CosmosChainInfo} agoricChainInfo
-         */
-        >, optAmountShape?: Pattern): Promise<globalThis.Amount>;
+        deposit(payment: Payment<"nat">, optAmountShape?: Pattern): Promise<globalThis.Amount>;
         withdraw(amount: Amount<"nat">): Promise<globalThis.Payment<"nat">>;
         executeTx<MT extends {
             '@type': string;
@@ -125,7 +101,7 @@ export type LocalChainAccountKit = ReturnType<ReturnType<typeof prepareLocalChai
 import type { Zone } from '@agoric/zone';
 import type { RecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
 import type { TimerService } from '@agoric/time';
-import type { TimerBrand } from '@agoric/time';
+import type { Remote } from '@agoric/internal';
 import type { CosmosChainInfo } from '@agoric/orchestration';
 import type { AmountArg } from '@agoric/orchestration';
 import type { ChainAddress } from '@agoric/orchestration';

package/src/exos/local-chain-account-kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-chain-account-kit.d.ts","sourceRoot":"","sources":["local-chain-account-kit.js"],"names":[],"mappings":"AAmEO,0FA2EG,WAAG,GAAE,QAAS,OACZ,WAAI,EAAE,MACjB,CAAa,WAAD,CAAC,CAAC,0HAlFJ,GAAG;;;0BAjB+B,MAAM,KAAK,CAAC;yBAWpB,QAAO,KAC1C;QAEF;;;;;;;WAOG;SARH,mBAGC,OAAM;yBAqBC,OAAO,KAAK,CAAC;;;uBAef,EACN;;;;iBAHe,WAAW;;;QAalB;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;;;;;;;;QA0BxB;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;QAsBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,IAAI,CAAC;QA2B1B;;;;WAIG;QACH,2CAA2C;yBAzJd,QAAO,KAC1C;QAEF;;;;;;;WAOG;SARH,mBAGC,OAAM;QAwJC,4CAA4C;yBAnI5C,OAAO,KAAK,CAAC;QAuIb,6CAA6C;;;uBAxH/C,EACN;QA4HQ;;WAEG;;QAIH;;;;;;;;WAQG;0GADU,OAAO,CAAC,IAAI,CAAC;;GA+CjC;;aA5Pa,MAAM;;;;;;0BAeyB,MAAM,KAAK,CAAC;yBAWpB,QAAO,KAC1C;QAEF;;;;;;;WAOG;SARH,mBAGC,OAAM;yBAqBC,OAAO,KAAK,CAAC;;;uBAef,EACN;;;;;mCAyLc,UAAU,CAAC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC;0BAtQjD,cAAc;iCADU,6CAA6C;kCAEjD,cAAc;gCAAd,cAAc;qCAHsC,uBAAuB;+BAAvB,uBAAuB;kCAAvB,uBAAuB;2CAAvB,uBAAuB"}
+{"version":3,"file":"local-chain-account-kit.d.ts","sourceRoot":"","sources":["local-chain-account-kit.js"],"names":[],"mappings":"AAoEO,0FAmEwB,WAAW,GAAE,QACpC,OACF,WACD,EAAE,MAAM,CAAC,WACL,CAAC,CAAC,0HA3EA,GAAG;;;;;;;;0BAlBG,MAAM,KAAK,CAAC;yBAUT,QAAS,KAAI,CAAC,mBAA2B,OAAO;yBAqBjD,OAAO,KAAK,CAAC;;;uBAgBlB,EAAE;;;;iBACD,WAAW;;;QAalB;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;QAYxB;;;WAGG;qCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;;;;;;;;;QA0BxB;;;WAGG;mCAFQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC;;;QAsBxB;;;;WAIG;qCAHQ,MAAM,cACN,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,IAAI,CAAC;QA2B1B;;;;WAIG;QACH,2CAA2C;yBAxJ/B,QAAS,KAAI,CAAC,mBAA2B,OAAO;QA4J5D,4CAA4C;yBAvIjC,OAAO,KAAK,CAAC;QA2IxB,6CAA6C;;;uBA3HvC,EAAE;QAgIR,yCAAyC;;QAIzC;;;;;;;;WAQG;0GADU,OAAO,CAAC,IAAI,CAAC;;GA+CjC;;aAvPa,MAAM;;;;;;0BAcH,MAAM,KAAK,CAAC;yBAUT,QAAS,KAAI,CAAC,mBAA2B,OAAO;yBAqBjD,OAAO,KAAK,CAAC;;;uBAgBlB,EAAE;;;;;mCA2LF,UAAU,CAAC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC;0BAnQjD,cAAc;iCADU,6CAA6C;kCAGjD,cAAc;4BADhC,kBAAkB;qCAHoD,uBAAuB;+BAAvB,uBAAuB;kCAAvB,uBAAuB;2CAAvB,uBAAuB"}