@agoric/orchestration 0.1.1-dev-37ec151.0 → 0.1.1-dev-c244e96.0

package/src/exos/orchestrator.js

@@ -3,39 +3,33 @@ import { AmountShape } from '@agoric/ertp';
 import { makeTracer } from '@agoric/internal';
 import { V } from '@agoric/vow/vat.js';
 import { M } from '@endo/patterns';
-// eslint-disable-next-line import/no-cycle -- FIXME
-import { makeLocalChainFacade } from '../facade.js';
+import {
+  ChainInfoShape,
+  LocalChainAccountShape,
+  DenomShape,
+  BrandInfoShape,
+  DenomAmountShape,
+} from '../typeGuards.js';
 
 /**
  * @import {Zone} from '@agoric/base-zone';
  * @import {ChainHub} from '../utils/chainHub.js';
- * @import {Connection, Port} from '@agoric/network';
- * @import {AnyJson} from '@agoric/cosmic-proto';
- * @import {TxBody} from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
- * @import {LocalIbcAddress, RemoteIbcAddress} from '@agoric/vats/tools/ibc-utils.js';
  * @import {AsyncFlowTools} from '@agoric/async-flow';
  * @import {Vow} from '@agoric/vow';
  * @import {TimerService} from '@agoric/time';
- * @import {IBCConnectionID} from '@agoric/vats';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
  * @import {RecorderKit, MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js'.
  * @import {Remote} from '@agoric/internal';
  * @import {OrchestrationService} from '../service.js';
- * @import {MakeLocalChainAccountKit} from './local-chain-account-kit.js';
+ * @import {MakeLocalOrchestrationAccountKit} from './local-orchestration-account.js';
+ * @import {MakeLocalChainFacade} from './local-chain-facade.js';
+ * @import {MakeRemoteChainFacade} from './remote-chain-facade.js';
  * @import {Chain, ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount, Orchestrator} from '../types.js';
  */
 
 const { Fail } = assert;
 const trace = makeTracer('Orchestrator');
 
-// TODO more validation
-export const ChainInfoShape = M.any();
-export const LocalChainAccountShape = M.remotable('LocalChainAccount');
-export const DenomShape = M.string();
-export const BrandInfoShape = M.any();
-
-export const DenomAmountShape = { denom: DenomShape, value: M.bigint() };
-
 /** @see {Orchestrator} */
 export const OrchestratorI = M.interface('Orchestrator', {
   getChain: M.callWhen(M.string()).returns(ChainInfoShape),
@@ -50,9 +44,9 @@ export const OrchestratorI = M.interface('Orchestrator', {
  *   asyncFlowTools: AsyncFlowTools;
  *   chainHub: ChainHub;
  *   localchain: Remote<LocalChain>;
- *   makeLocalChainAccountKit: MakeLocalChainAccountKit;
  *   makeRecorderKit: MakeRecorderKit;
- *   makeRemoteChainFacade: any;
+ *   makeLocalChainFacade: MakeLocalChainFacade;
+ *   makeRemoteChainFacade: MakeRemoteChainFacade;
  *   orchestrationService: Remote<OrchestrationService>;
  *   storageNode: Remote<StorageNode>;
  *   timerService: Remote<TimerService>;
@@ -61,7 +55,7 @@ export const OrchestratorI = M.interface('Orchestrator', {
  */
 export const prepareOrchestrator = (
   zone,
-  { chainHub, localchain, makeLocalChainAccountKit, makeRemoteChainFacade },
+  { chainHub, localchain, makeLocalChainFacade, makeRemoteChainFacade },
 ) =>
   zone.exoClass(
     'Orchestrator',
@@ -76,11 +70,8 @@ export const prepareOrchestrator = (
         const agoricChainInfo = await chainHub.getChainInfo('agoric');
 
         if (name === 'agoric') {
-          return makeLocalChainFacade(
-            localchain,
-            makeLocalChainAccountKit,
-            agoricChainInfo,
-          );
+          // @ts-expect-error XXX chainInfo generic
+          return makeLocalChainFacade(agoricChainInfo);
         }
 
         const remoteChainInfo = await chainHub.getChainInfo(name);
@@ -89,6 +80,7 @@ export const prepareOrchestrator = (
           remoteChainInfo.chainId,
         );
 
+        // @ts-expect-error XXX chainInfo generic
         return makeRemoteChainFacade(remoteChainInfo, connectionInfo);
       },
       makeLocalAccount() {

package/src/exos/remote-chain-facade.d.ts

@@ -1,8 +1,3 @@
-/** @see {Chain} */
-export const RemoteChainFacadeI: import("@endo/patterns").InterfaceGuard<{
-    getChainInfo: import("@endo/patterns").MethodGuard;
-    makeAccount: import("@endo/patterns").MethodGuard;
-}>;
 export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAccount, orchestration, storageNode, timer }: {
     makeCosmosOrchestrationAccount: (chainAddress: import("../orchestration-api.js").ChainAddress, bondDenom: string, io: {
         account: import("../cosmos-api.js").IcaAccount;
@@ -18,7 +13,7 @@ export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAc
             publicSubscribers: {
                 account: {
                     description: string;
-                    subscriber: globalThis.Subscriber<import("./cosmosOrchestrationAccount.js").ComosOrchestrationAccountNotification>;
+                    subscriber: globalThis.Subscriber<import("./cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
                     storagePath: Promise<string>;
                 };
             };
@@ -35,7 +30,7 @@ export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAc
         getPublicTopics(): {
             account: {
                 description: string;
-                subscriber: globalThis.Subscriber<import("./cosmosOrchestrationAccount.js").ComosOrchestrationAccountNotification>;
+                subscriber: globalThis.Subscriber<import("./cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
                 storagePath: Promise<string>;
             };
         };
@@ -81,6 +76,7 @@ export function prepareRemoteChainFacade(zone: Zone, { makeCosmosOrchestrationAc
     /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
     makeAccount(): Promise<import("../orchestration-api.js").OrchestrationAccountI>;
 }>;
+export type MakeRemoteChainFacade = ReturnType<typeof prepareRemoteChainFacade>;
 import type { Zone } from '@agoric/base-zone';
 import type { Remote } from '@agoric/internal';
 import type { TimerService } from '@agoric/time';

package/src/exos/remote-chain-facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AAsBA,mBAAmB;AACnB;;;GAGG;AAaI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsBD,0DAA0D;;GA4B7D;0BAjFoB,mBAAmB;4BAEjB,kBAAkB;kCADZ,cAAc;uCAIyC,aAAa"}
+{"version":3,"file":"remote-chain-facade.d.ts","sourceRoot":"","sources":["remote-chain-facade.js"],"names":[],"mappings":"AAgCO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsBD,0DAA0D;;GAwB7D;oCAEW,UAAU,CAAC,OAAO,wBAAwB,CAAC;0BAzElC,mBAAmB;4BAEjB,kBAAkB;kCADZ,cAAc;uCAIyC,aAAa"}

package/src/exos/remote-chain-facade.js

@@ -1,16 +1,15 @@
 /** @file ChainAccount exo */
 import { makeTracer } from '@agoric/internal';
 import { V } from '@agoric/vow/vat.js';
-import { M } from '@endo/patterns';
 
-import { ChainInfoShape } from './orchestrator.js';
+import { ChainFacadeI } from '../typeGuards.js';
 
 /**
  * @import {Zone} from '@agoric/base-zone';
  * @import {TimerService} from '@agoric/time';
  * @import {Remote} from '@agoric/internal';
  * @import {OrchestrationService} from '../service.js';
- * @import {prepareCosmosOrchestrationAccount} from './cosmosOrchestrationAccount.js';
+ * @import {prepareCosmosOrchestrationAccount} from './cosmos-orchestration-account.js';
  * @import {ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount} from '../types.js';
  */
 
@@ -20,12 +19,6 @@ const trace = makeTracer('RemoteChainFacade');
 /** @type {any} */
 const anyVal = null;
 
-/** @see {Chain} */
-export const RemoteChainFacadeI = M.interface('RemoteChainFacade', {
-  getChainInfo: M.callWhen().returns(ChainInfoShape),
-  makeAccount: M.callWhen().returns(M.remotable('OrchestrationAccount')),
-});
-
 /**
  * @param {Zone} zone
  * @param {{
@@ -43,7 +36,7 @@ export const prepareRemoteChainFacade = (
 ) =>
   zone.exoClass(
     'RemoteChainFacade',
-    RemoteChainFacadeI,
+    ChainFacadeI,
     /**
      * @param {CosmosChainInfo} remoteChainInfo
      * @param {IBCConnectionInfo} connectionInfo
@@ -71,15 +64,11 @@ export const prepareRemoteChainFacade = (
 
         const address = await V(icaAccount).getAddress();
 
-        const [{ denom: bondDenom }] = remoteChainInfo.stakingTokens || [
-          {
-            denom: null,
-          },
-        ];
-        if (!bondDenom) {
-          throw Fail`missing bondDenom`;
+        const stakingDenom = remoteChainInfo.stakingTokens?.[0]?.denom;
+        if (!stakingDenom) {
+          throw Fail`chain info lacks staking denom`;
         }
-        return makeCosmosOrchestrationAccount(address, bondDenom, {
+        return makeCosmosOrchestrationAccount(address, stakingDenom, {
           account: icaAccount,
           storageNode,
           icqConnection: anyVal,
@@ -89,3 +78,4 @@ export const prepareRemoteChainFacade = (
     },
   );
 harden(prepareRemoteChainFacade);
+/** @typedef {ReturnType<typeof prepareRemoteChainFacade>} MakeRemoteChainFacade */

package/src/facade.d.ts

@@ -1,27 +1,4 @@
-export function makeLocalChainFacade(localchain: Remote<import("@endo/exo").Guarded<{
-    makeAccount(): import("@agoric/vow").PromiseVow<import("@endo/exo").Guarded<{
-        getAddress(): string;
-        getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
-        deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
-        withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
-        executeTx<MT extends {
-            '@type': string;
-        }[]>(messages: MT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-        monitorTransfers(tap: import("@agoric/vats/src/bridge-target.js").TargetApp): import("@agoric/vow").PromiseVow<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
-    }>>;
-    query<T extends {
-        '@type': string;
-    } = {
-        '@type': string;
-    }>(request: T): import("@agoric/vow").PromiseVow<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<T>>>;
-    queryMany<RT extends {
-        '@type': string;
-    }[]>(requests: RT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K_1 in keyof RT]: import("@agoric/cosmic-proto").JsonSafe<{
-        error?: string | undefined;
-        reply: import("@agoric/cosmic-proto").ResponseTo<RT[K_1]>;
-    }>; }>;
-}>>, makeLocalChainAccountKit: ReturnType<typeof import("./exos/local-chain-account-kit.js").prepareLocalChainAccountKit>, localInfo: ChainInfo): Chain<any>;
-export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, chainHub, makeLocalChainAccountKit, makeRecorderKit, makeRemoteChainFacade, asyncFlowTools, }: {
+export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode, orchestrationService, localchain, chainHub, makeLocalOrchestrationAccountKit, makeRecorderKit, makeLocalChainFacade, makeRemoteChainFacade, asyncFlowTools, }: {
     zone: Zone;
     timerService: Remote<TimerService>;
     zcf: ZCF;
@@ -58,10 +35,90 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
         }>; }>;
     }>>;
     chainHub: import("./utils/chainHub.js").ChainHub;
-    makeLocalChainAccountKit: ReturnType<typeof import("./exos/local-chain-account-kit.js").prepareLocalChainAccountKit>;
+    makeLocalOrchestrationAccountKit: (args_0: {
+        account: import("@endo/exo").Guarded<{
+            getAddress(): string;
+            getBalance(brand: Brand<"nat">): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
+            executeTx<MT extends {
+                '@type': string;
+            }[]>(messages: MT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
+            monitorTransfers(tap: import("@agoric/vats/src/bridge-target.js").TargetApp): import("@agoric/vow").PromiseVow<import("@agoric/vats/src/bridge-target.js").TargetRegistration>;
+        }>;
+        address: import("./orchestration-api.js").ChainAddress;
+        storageNode: Remote<globalThis.StorageNode>;
+    }) => import("@endo/exo").GuardedKit<{
+        invitationMakers: {
+            Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgDelegateResponse & {
+                '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
+            }>, undefined>>;
+            Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<void, undefined>>;
+            CloseAccount(): never;
+        };
+        holder: {
+            getBalance(denom: DenomArg): Promise<import("./orchestration-api.js").DenomAmount>;
+            getBalances(): never;
+            getPublicTopics(): {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("./exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgDelegateResponse & {
+                '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
+            }>>;
+            undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<void>;
+            deposit(payment: globalThis.Payment<"nat">): Promise<void>;
+            withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
+            executeTx<MT extends {
+                '@type': string;
+            }[]>(messages: MT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
+            getAddress(): import("./orchestration-api.js").ChainAddress;
+            send(toAccount: any, amount: any): Promise<void>;
+            transfer(amount: import("./orchestration-api.js").AmountArg, destination: import("./orchestration-api.js").ChainAddress, opts?: import("./cosmos-api.js").IBCMsgTransferOptions | undefined): Promise<void>;
+            transferSteps(amount: AmountArg, msg: TransferMsg): Promise<void>;
+        };
+    }>;
     makeRecorderKit: <T_1>(storageNode: StorageNode | Awaited<import("@endo/far").FarRef<StorageNode>>, valueShape?: import("@agoric/zoe/src/contractSupport/recorder.js").TypedMatcher<T_1> | undefined) => RecorderKit<T_1>;
     makeCosmosOrchestrationAccount: any;
-    makeRemoteChainFacade: any;
+    makeLocalChainFacade: (localChainInfo: Readonly<{
+        chainId: string;
+        connections?: Record<string, IBCConnectionInfo> | undefined;
+        icqEnabled?: boolean | undefined;
+        stakingTokens?: readonly {
+            denom: string;
+        }[] | undefined;
+    }>) => import("@endo/exo").Guarded<{
+        getChainInfo(): Promise<Readonly<{
+            chainId: string;
+            connections?: Record<string, IBCConnectionInfo> | undefined;
+            icqEnabled?: boolean | undefined;
+            stakingTokens?: readonly {
+                denom: string;
+            }[] | undefined;
+        }>>;
+        makeAccount(): Promise<import("./orchestration-api.js").OrchestrationAccountI>;
+    }>;
+    makeRemoteChainFacade: (remoteChainInfo: Readonly<{
+        chainId: string;
+        connections?: Record<string, IBCConnectionInfo> | undefined;
+        icqEnabled?: boolean | undefined;
+        stakingTokens?: readonly {
+            denom: string;
+        }[] | undefined;
+    }>, connectionInfo: IBCConnectionInfo) => import("@endo/exo").Guarded<{
+        getChainInfo(): Promise<Readonly<{
+            chainId: string;
+            connections?: Record<string, IBCConnectionInfo> | undefined;
+            icqEnabled?: boolean | undefined;
+            stakingTokens?: readonly {
+                denom: string;
+            }[] | undefined;
+        }>>;
+        makeAccount(): Promise<import("./orchestration-api.js").OrchestrationAccountI>;
+    }>;
     asyncFlowTools: {
         prepareAsyncFlowKit: (zone: Zone, tag: string, guestAsyncFunc: import("../../../node_modules/@agoric/async-flow/src/types.js").GuestAsyncFunc, options?: {
             startEager?: boolean | undefined;
@@ -107,12 +164,11 @@ export function makeOrchestrationFacade({ zone, timerService, zcf, storageNode,
     orchestrate<Context, Args extends any[]>(durableName: string, ctx: Context, fn: (orc: Orchestrator, ctx2: Context, ...args: Args) => object): (...args: Args) => Promise<unknown>;
 };
 export type OrchestrationFacade = ReturnType<typeof makeOrchestrationFacade>;
-import type { Remote } from '@agoric/internal';
-import type { ChainInfo } from './types.js';
-import type { Chain } from './types.js';
 import type { Zone } from '@agoric/zone';
 import type { TimerService } from '@agoric/time';
+import type { Remote } from '@agoric/internal';
 import type { RecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+import type { IBCConnectionInfo } from './types.js';
 import type { Vow } from '@agoric/vow';
 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":"AA8BO;;;0BAqE8B,MAChC,KAAE,CAAC;yBAciB,QAAQ,KAAK,CAAC,mBAGrC,OACA;yBAuBS,OAAO,KACf,CAAC;;;uBAwB4B,EAAC;;;;;;;gBAM63F,CAAC;;;mBAA6lB,EAAE;;;;+BApJn/G,UAAU,CACpB,cAAkB,mCAAmC,EAAE,2BAA2B,CAC/E,oCAoEH;AAoBM;;;SAdG,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;oBAwEi5F,CAAC;;;uBAA6lB,EAAE;;;;;cApE/+G,OAAO,qBAAqB,EAAE,QAAQ;8BACtB,UAAU,CACxC,cAAoB,mCAAmC,EAAE,2BAA2B,CAC/E;wCAmDkB,WAAW,GAC9B,QAAI,OAAO,WAAW,EAAG,MAAK,CAAE,WAAU,CAAC,CAAC;oCAlDZ,GAAG;2BACZ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4C3B;;;;;;;;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;EAQnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;4BA3J/B,kBAAkB;+BAEgE,YAAY;2BAAZ,YAAY;0BARhG,cAAc;kCAEN,cAAc;iCAGE,6CAA6C;yBAJtE,aAAa;kCAOwE,YAAY"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["facade.js"],"names":[],"mappings":"AAuCO;;;SAbG,GAAG;;;;;;;;;;;;;8BAyEiH,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;cArEnlL,OAAO,qBAAqB,EAAE,QAAQ;;;;8BAqEyE,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;2DAAxlD,OAAO,KAAK,CAAC;;;6DAAid,OAAO,KAAK,CAAC;;;;8BAA0tB,QAAS;;;;;;;;;2DAAiyB,OAAO,KAAK,CAAC;;;6DAA+yB,OAAO,KAAK,CAAC;;6BAA56D,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;kCAA46B,SAAU,OAAM,WAAY;;;wCAA/xC,WAAW,GAAE,QAAS,OAAO,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;oCAlE/oD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgDpC;;;;;;;;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;EAQnD;kCAEa,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA1FjC,cAAc;kCAEN,cAAc;4BAIpB,kBAAkB;iCADI,6CAA6C;uCAGe,YAAY;yBAPjG,aAAa;kCAOwE,YAAY"}

package/src/facade.js

@@ -1,9 +1,7 @@
 /** @file Orchestration service */
 
 import { Fail } from '@agoric/assert';
-import { V as E } from '@agoric/vow/vat.js';
-import { Far } from '@endo/far';
-// eslint-disable-next-line import/no-cycle -- FIXME
+
 import { prepareOrchestrator } from './exos/orchestrator.js';
 
 /**
@@ -17,83 +15,11 @@ import { prepareOrchestrator } from './exos/orchestrator.js';
  * @import {Remote} from '@agoric/internal';
  * @import {OrchestrationService} from './service.js';
  * @import {Chain, ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount, Orchestrator} from './types.js';
+ * @import {MakeLocalChainFacade} from './exos/local-chain-facade.js';
+ * @import {MakeRemoteChainFacade} from './exos/remote-chain-facade.js';
+ * @import {MakeLocalOrchestrationAccountKit} from './exos/local-orchestration-account.js';
  */
 
-// FIXME turn this into an Exo
-/**
- * @param {Remote<LocalChain>} localchain
- * @param {ReturnType<
- *   typeof import('./exos/local-chain-account-kit.js').prepareLocalChainAccountKit
- * >} makeLocalChainAccountKit
- * @param {ChainInfo} localInfo
- * @returns {Chain}
- */
-export const makeLocalChainFacade = (
-  localchain,
-  makeLocalChainAccountKit,
-  localInfo,
-) => {
-  return Far('LocalChainFacade', {
-    /** @returns {Promise<ChainInfo>} */
-    async getChainInfo() {
-      return localInfo;
-    },
-
-    async 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,
-      });
-
-      // FIXME turn this into an Exo LocalChainOrchestrationAccount or make that a facet of makeLocalChainAccountKit
-      return {
-        async deposit(payment) {
-          console.log('deposit got', payment);
-          await E(account).deposit(payment);
-        },
-        getAddress() {
-          const addressStr = account.getAddress();
-          return {
-            address: addressStr,
-            chainId: localInfo.chainId,
-            addressEncoding: 'bech32',
-          };
-        },
-        async getBalance(denomArg) {
-          // FIXME look up real values
-          // UNTIL https://github.com/Agoric/agoric-sdk/issues/9211
-          const [brand, denom] =
-            typeof denomArg === 'string'
-              ? [/** @type {any} */ (null), denomArg]
-              : [denomArg, 'FIXME'];
-
-          const natAmount = await E(lca).getBalance(brand);
-          return harden({ denom, value: natAmount.value });
-        },
-        getBalances() {
-          throw new Error('not yet implemented');
-        },
-        async send(toAccount, amount) {
-          // FIXME implement
-          console.log('send got', toAccount, amount);
-        },
-        async transfer(amount, destination, opts) {
-          console.log('transfer got', amount, destination, opts);
-          return account.transfer(amount, destination, opts);
-        },
-        transferSteps(amount, msg) {
-          console.log('transferSteps got', amount, msg);
-          return Promise.resolve();
-        },
-      };
-    },
-  });
-};
-
 /**
  * @param {{
  *   zone: Zone;
@@ -103,12 +29,11 @@ export const makeLocalChainFacade = (
  *   orchestrationService: Remote<OrchestrationService>;
  *   localchain: Remote<LocalChain>;
  *   chainHub: import('./utils/chainHub.js').ChainHub;
- *   makeLocalChainAccountKit: ReturnType<
- *     typeof import('./exos/local-chain-account-kit.js').prepareLocalChainAccountKit
- *   >;
+ *   makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
  *   makeRecorderKit: MakeRecorderKit;
  *   makeCosmosOrchestrationAccount: any;
- *   makeRemoteChainFacade: any;
+ *   makeLocalChainFacade: MakeLocalChainFacade;
+ *   makeRemoteChainFacade: MakeRemoteChainFacade;
  *   asyncFlowTools: AsyncFlowTools;
  * }} powers
  */
@@ -120,8 +45,9 @@ export const makeOrchestrationFacade = ({
   orchestrationService,
   localchain,
   chainHub,
-  makeLocalChainAccountKit,
+  makeLocalOrchestrationAccountKit,
   makeRecorderKit,
+  makeLocalChainFacade,
   makeRemoteChainFacade,
   asyncFlowTools,
 }) => {
@@ -131,9 +57,10 @@ export const makeOrchestrationFacade = ({
     storageNode &&
     orchestrationService &&
     // @ts-expect-error type says defined but double check
-    makeLocalChainAccountKit &&
+    makeLocalOrchestrationAccountKit &&
     // @ts-expect-error type says defined but double check
     makeRecorderKit &&
+    // @ts-expect-error type says defined but double check
     makeRemoteChainFacade &&
     asyncFlowTools) ||
     Fail`params missing`;
@@ -142,8 +69,8 @@ export const makeOrchestrationFacade = ({
     asyncFlowTools,
     chainHub,
     localchain,
-    makeLocalChainAccountKit,
     makeRecorderKit,
+    makeLocalChainFacade,
     makeRemoteChainFacade,
     orchestrationService,
     storageNode,

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

@@ -25,7 +25,7 @@ export function startStakeAtom({ consume: { agoricNames, board, chainStorage, ch
                             publicSubscribers: {
                                 account: {
                                     description: string;
-                                    subscriber: globalThis.Subscriber<import("../exos/cosmosOrchestrationAccount.js").ComosOrchestrationAccountNotification>;
+                                    subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
                                     storagePath: Promise<string>;
                                 };
                             };
@@ -42,7 +42,7 @@ export function startStakeAtom({ consume: { agoricNames, board, chainStorage, ch
                         getPublicTopics(): {
                             account: {
                                 description: string;
-                                subscriber: globalThis.Subscriber<import("../exos/cosmosOrchestrationAccount.js").ComosOrchestrationAccountNotification>;
+                                subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
                                 storagePath: Promise<string>;
                             };
                         };
@@ -63,7 +63,7 @@ export function startStakeAtom({ consume: { agoricNames, board, chainStorage, ch
                         publicSubscribers: {
                             account: {
                                 description: string;
-                                subscriber: globalThis.Subscriber<import("../exos/cosmosOrchestrationAccount.js").ComosOrchestrationAccountNotification>;
+                                subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
                                 storagePath: Promise<string>;
                             };
                         };

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

@@ -1 +1 @@
-{"version":3,"file":"start-stakeAtom.d.ts","sourceRoot":"","sources":["start-stakeAtom.js"],"names":[],"mappings":"AAuBO,yOAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,OA2CxB,IAAI,aACA,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA1CF,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAuDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCApG4C,+BAA+B"}
+{"version":3,"file":"start-stakeAtom.d.ts","sourceRoot":"","sources":["start-stakeAtom.js"],"names":[],"mappings":"AAuBO,yOAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,OA2CtB,IACH,aAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA1CJ,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAuDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCApG4C,+BAA+B"}

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

@@ -40,7 +40,7 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                         publicSubscribers: {
                             account: {
                                 description: string;
-                                subscriber: globalThis.Subscriber<import("../exos/local-chain-account-kit.js").LocalChainAccountNotification>;
+                                subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
                                 storagePath: Promise<string>;
                             };
                         };
@@ -52,10 +52,12 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                             CloseAccount(): never;
                         }>;
                         account: import("@endo/exo").Guarded<{
+                            getBalance(denom: DenomArg): Promise<import("../orchestration-api.js").DenomAmount>;
+                            getBalances(): never;
                             getPublicTopics(): {
                                 account: {
                                     description: string;
-                                    subscriber: globalThis.Subscriber<import("../exos/local-chain-account-kit.js").LocalChainAccountNotification>;
+                                    subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
                                     storagePath: Promise<string>;
                                 };
                             };
@@ -63,20 +65,24 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                                 '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
                             }>>;
                             undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<void>;
-                            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+                            deposit(payment: globalThis.Payment<"nat">): Promise<void>;
                             withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
                             executeTx<MT extends {
                                 '@type': string;
                             }[]>(messages: MT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-                            getAddress(): string;
+                            getAddress(): import("../orchestration-api.js").ChainAddress;
+                            send(toAccount: any, amount: any): Promise<void>;
                             transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): Promise<void>;
+                            transferSteps(amount: AmountArg, msg: TransferMsg): Promise<void>;
                         }>;
                     }, undefined>>;
                     makeAccount(): Promise<import("@endo/exo").Guarded<{
+                        getBalance(denom: DenomArg): Promise<import("../orchestration-api.js").DenomAmount>;
+                        getBalances(): never;
                         getPublicTopics(): {
                             account: {
                                 description: string;
-                                subscriber: globalThis.Subscriber<import("../exos/local-chain-account-kit.js").LocalChainAccountNotification>;
+                                subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
                                 storagePath: Promise<string>;
                             };
                         };
@@ -84,19 +90,21 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                             '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
                         }>>;
                         undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<void>;
-                        deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+                        deposit(payment: globalThis.Payment<"nat">): Promise<void>;
                         withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
                         executeTx<MT extends {
                             '@type': string;
                         }[]>(messages: MT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-                        getAddress(): string;
+                        getAddress(): import("../orchestration-api.js").ChainAddress;
+                        send(toAccount: any, amount: any): Promise<void>;
                         transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): Promise<void>;
+                        transferSteps(amount: AmountArg, msg: TransferMsg): Promise<void>;
                     }>>;
                     makeAccountInvitationMaker(): Promise<Invitation<{
                         publicSubscribers: {
                             account: {
                                 description: string;
-                                subscriber: globalThis.Subscriber<import("../exos/local-chain-account-kit.js").LocalChainAccountNotification>;
+                                subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
                                 storagePath: Promise<string>;
                             };
                         };
@@ -108,10 +116,12 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                             CloseAccount(): never;
                         }>;
                         account: import("@endo/exo").Guarded<{
+                            getBalance(denom: DenomArg): Promise<import("../orchestration-api.js").DenomAmount>;
+                            getBalances(): never;
                             getPublicTopics(): {
                                 account: {
                                     description: string;
-                                    subscriber: globalThis.Subscriber<import("../exos/local-chain-account-kit.js").LocalChainAccountNotification>;
+                                    subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
                                     storagePath: Promise<string>;
                                 };
                             };
@@ -119,13 +129,15 @@ export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, cha
                                 '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
                             }>>;
                             undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<void>;
-                            deposit(payment: Payment<"nat">, optAmountShape?: Pattern): import("@agoric/vow").PromiseVow<import("@agoric/ertp/src/types.js").NatAmount>;
+                            deposit(payment: globalThis.Payment<"nat">): Promise<void>;
                             withdraw(amount: Amount<"nat">): import("@agoric/vow").PromiseVow<globalThis.Payment<"nat">>;
                             executeTx<MT extends {
                                 '@type': string;
                             }[]>(messages: MT): import("@agoric/vats/src/localchain.js").PromiseVowOfTupleMappedToGenerics<{ [K in keyof MT]: import("@agoric/cosmic-proto").JsonSafe<import("@agoric/cosmic-proto").ResponseTo<MT[K]>>; }>;
-                            getAddress(): string;
+                            getAddress(): import("../orchestration-api.js").ChainAddress;
+                            send(toAccount: any, amount: any): Promise<void>;
                             transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): Promise<void>;
+                            transferSteps(amount: AmountArg, msg: TransferMsg): Promise<void>;
                         }>;
                     }, 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,OA6B7B,GAAA;;;;;0CA+D80B,MAAM,KAAK,CAAC;yCAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;yCAAwjB,OAAO,KAAK,CAAC;;;uCAA6rB,EAAE;;;;;;;gCAAqjG,CAAC;;;mCAA6lB,EAAE;;;;;;;;;;;;;wBA1DhzM,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;2EA0D05C,OAAO,KAAK,CAAC;;;6EAAid,OAAO,KAAK,CAAC;;;;;;;;;;;2EAAs4B,OAAO,KAAK,CAAC;;;6EAA+yB,OAAO,KAAK,CAAC;6CAAjxE,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6CAAwjB,OAAO,KAAK,CAAC;;;2CAA6rB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA1FrpF,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,OA6BpB,GAAG;;;;;0CA+Dk0B,MAAM,KAAK,CAAC;yCAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;yCAAwjB,OAAO,KAAK,CAAC;;;uCAA6rB,EAAE;;;;;;;gCAAqjG,CAAC;;;mCAA6lB,EAAE;;;;;;;;;;;;;wBA1DpyM,OAAO,kBAAkB,EAAG,OAAM;;;;;;;;;;;2EA0DqhC,OAAO,KAAK,CAAC;;;6EAAid,OAAO,KAAK,CAAC;;;;8CAA0tB,QAAS;;;;;;;;;2EAAiyB,OAAO,KAAK,CAAC;;;6EAA+yB,OAAO,KAAK,CAAC;;6CAA56D,OAAO,KAAK,CAAC;;;2CAA6rB,EAAE;;;;kDAA46B,SAAU,OAAM,WAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA1F7lH,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAwDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BN;sBApGqB,gCAAgC"}