@agoric/orchestration 0.1.1-dev-a035bbe.0 → 0.1.1-dev-c244e96.0

package/package.json

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

package/src/chain-info.js

@@ -10,7 +10,7 @@ import fetchedChainInfo from './fetched-chain-info.js';
 const knownChains = /** @satisfies {Record<string, ChainInfo>} */ (
   harden({
     ...fetchedChainInfo,
-    // XXX does not have useful connections
+    // FIXME does not have useful connections
     // UNTIL https://github.com/Agoric/agoric-sdk/issues/9492
     agoriclocal: {
       chainId: 'agoriclocal',

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

@@ -1 +1 @@
-{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AAEH,kEAKE;AASK,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB;;;;;QAsFE;;;WAGG;;;;;;;;;;GAgBR;;;;;8BAtCS,MAAA,KAAC,CAAC;6BAuBF,QAAQ,KAAK,CAAC,mBAChB,OAAE;6BAesJ,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;;;;;;;;;;;;;6BAxIv+I,kBAAkB;uCACS,eAAe;4BAK3C,aAAa;kCAJK,cAAc;6BAG/B,cAAc"}
+{"version":3,"file":"sendAnywhere.contract.d.ts","sourceRoot":"","sources":["sendAnywhere.contract.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AAEH,kEAKE;AASK,2BANI,GAAG,eACH,mBAAmB,GAAG;IAChC,UAAc,EAAE,UAAU,CAAC;CACxB;;;;;QAuFE;;;WAGG;;;;;;;;;;GAgBR;;;;;8BA1CG,MACA,KACH,CAAC;6BAsBuC,QAClC,KAAG,CAAC,mBAA6B,OAAO;6BAkBuC,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;;;;;;;;;;;;;6BAzI75I,kBAAkB;uCACS,eAAe;4BAK3C,aAAa;kCAJK,cAAc;6BAG/B,cAAc"}

package/src/examples/sendAnywhere.contract.js

@@ -52,6 +52,7 @@ export const start = async (zcf, privateArgs, baggage) => {
     privateArgs.marshaller,
   );
 
+  /** @type {import('../orchestration-api.js').OrchestrationAccount<any>} */
   let contractAccount;
 
   const findBrandInVBank = async brand => {
@@ -79,7 +80,7 @@ export const start = async (zcf, privateArgs, baggage) => {
       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?
+      // FIXME ok to use a heap var crossing the membrane scope this way?
       if (!contractAccount) {
         const agoricChain = await orch.getChain('agoric');
         contractAccount = await agoricChain.makeAccount();
@@ -88,7 +89,7 @@ export const start = async (zcf, privateArgs, baggage) => {
       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 E.when(pmtP, pmt => contractAccount.deposit(pmt));
       await contractAccount.transfer(
         { denom, value: amt.value },
         {

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

@@ -35,7 +35,7 @@ export function start(zcf: ZCF, privateArgs: {
             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>;
                 };
             };
@@ -47,10 +47,12 @@ export function start(zcf: ZCF, privateArgs: {
                 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>;
                     };
                 };
@@ -58,20 +60,24 @@ export function start(zcf: ZCF, privateArgs: {
                     '@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>;
                 };
             };
@@ -79,13 +85,15 @@ export function start(zcf: ZCF, privateArgs: {
                 '@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>;
         }>>;
         /**
          * Invitation to make an account, without any funds
@@ -94,7 +102,7 @@ export function start(zcf: ZCF, privateArgs: {
             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>;
                 };
             };
@@ -106,10 +114,12 @@ export function start(zcf: ZCF, privateArgs: {
                 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>;
                     };
                 };
@@ -117,13 +127,15 @@ export function start(zcf: ZCF, privateArgs: {
                     '@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/examples/stakeBld.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stakeBld.contract.d.ts","sourceRoot":"","sources":["stakeBld.contract.js"],"names":[],"mappings":"AAmCO,2BAVI,GAAG;;;;;8BA6ER,MACA,KAAF,CAAC;6BAc2C,QACpC,KAAR,CAAC,mBACO,OAAD;6BASqb,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;gBAnGhxJ,UAAU;iBACT,WAAW;;YAGlB,OAAO,kBAAkB,EAAE,OAAO;;QA2CvC;;WAEG;;;;;;;;;;+DA2CD,OAAI,KAAK,CAAC;;;iEAOyX,OAAO,KAAK,CAAC;;;;;;;;;;;+DAAs4B,OAAO,KAAK,CAAC;;;iEAA+yB,OAAO,KAAK,CAAC;iCAXvjE,QACpC,KAAR,CAAC,mBACO,OAAD;iCASqb,OAAO,KAAK,CAAC;;;+BAA6rB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;QApBtoC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBR;6BA/GyB,cAAc;4BACf,kBAAkB;kCACZ,cAAc"}
+{"version":3,"file":"stakeBld.contract.d.ts","sourceRoot":"","sources":["stakeBld.contract.js"],"names":[],"mappings":"AAmCO,2BAVI,GAAG;;;;;8BA2EJ,MAAA,KAAK,CAAC;6BAmBA,QAAO,KAAK,CAAC,mBAA6B,OAAO;6BAawP,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;gBAvGzoJ,UAAU;iBACT,WAAW;;YAGlB,OAAO,kBAAkB,EAAE,OAAO;;QA+CvC;;WAEG;;;;;;;;;;+DA2BsC,OAAO,KACnD,CAAC;;;iEAaU,OAAO,KAAK,CAAC;;;;kCASulB,QAAS;;;;;;;;;+DAAiyB,OAAO,KAAK,CAAC;;;iEAA+yB,OAAO,KAAK,CAAC;;iCAA56D,OAAO,KAAK,CAAC;;;+BAA6rB,EAAE;;;;sCAA46B,SAAU,OAAM,WAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;QApBv8D;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBR;6BAnHyB,cAAc;4BACf,kBAAkB;kCACZ,cAAc"}

package/src/examples/stakeBld.contract.js

@@ -10,7 +10,7 @@ import { V } from '@agoric/vow/vat.js';
 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 { prepareLocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
 import { makeChainHub } from '../utils/chainHub.js';
 
 /**
@@ -41,7 +41,7 @@ export const start = async (zcf, privateArgs, baggage) => {
     privateArgs.marshaller,
   );
 
-  const makeLocalChainAccountKit = prepareLocalChainAccountKit(
+  const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
     zone,
     makeRecorderKit,
     zcf,
@@ -58,10 +58,14 @@ export const start = async (zcf, privateArgs, baggage) => {
   async function makeLocalAccountKit() {
     const account = await V(privateArgs.localchain).makeAccount();
     const address = await V(account).getAddress();
-    // XXX 'address' is implied by 'account'; use an async maker that get the value itself
-    return makeLocalChainAccountKit({
+    // FIXME 'address' is implied by 'account'; use an async maker that get the value itself
+    return makeLocalOrchestrationAccountKit({
       account,
-      address,
+      address: harden({
+        address,
+        addressEncoding: 'bech32',
+        chainId: 'local',
+      }),
       storageNode: privateArgs.storageNode,
     });
   }

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

@@ -31,7 +31,7 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
                 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>;
                     };
                 };
@@ -48,7 +48,7 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
             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>;
                 };
             };
@@ -69,7 +69,7 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
             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/examples/stakeIca.contract.js

@@ -10,7 +10,7 @@ import {
 import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 import { M } from '@endo/patterns';
-import { prepareCosmosOrchestrationAccount } from '../exos/cosmosOrchestrationAccount.js';
+import { prepareCosmosOrchestrationAccount } from '../exos/cosmos-orchestration-account.js';
 
 const trace = makeTracer('StakeAtom');
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAc/C,2BAXI,GAAG;;;;;8BAiEuC,MAC/C,KAAG,CAAC;6BAgBmC,QAAQ,KAClD,CAAC,mBAGgB,OAAO;6BAkB4H,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;;;;;;;;;;;gBAjGv+I,UAAU;;;;oBAiCV,MAAM,CAAC,KAAK,CAAC;;;;;oBAAb,MAAM,CAAC,KAAK,CAAC;;;;GA+D7B;6BAlIyB,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":"AASA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAc/C,2BAXI,GAAG;;;;;8BAgE+D,MAAM,KAAK,CAAC;6BAkBvD,QAAQ,KAAK,CAAC,mBACxC,OACL;6BAuBoB,OAAO,KAC7B,CAAC;;;2BAC0rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;;;;;;;;;;;gBAtGl0I,UAAU;;;;oBAiCV,MAAM,CAAC,KAAK,CAAC;;;;;oBAAb,MAAM,CAAC,KAAK,CAAC;;;;GAoE7B;6BAvIyB,cAAc;4BAHf,kBAAkB;gCAHwB,aAAa;kCACjD,cAAc;6BAInB,kBAAkB;4CALuB,aAAa"}

package/src/examples/swapExample.contract.js

@@ -103,7 +103,12 @@ export const start = async (zcf, privateArgs, baggage) => {
 
       // deposit funds from user seat to LocalChainAccount
       const payments = await withdrawFromSeat(zcf, seat, give);
-      await deeplyFulfilled(objectMap(payments, localAccount.deposit));
+      await deeplyFulfilled(
+        objectMap(payments, payment =>
+          // @ts-expect-error payment is ERef<Payment> which happens to work but isn't officially supported
+          localAccount.deposit(payment),
+        ),
+      );
       seat.exit();
 
       // build swap instructions with orcUtils library

package/src/exos/{chainAccountKit.d.ts → chain-account-kit.d.ts}

@@ -68,4 +68,4 @@ import type { ChainAddress } from '../types.js';
 import type { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
 import type { Connection } from '@agoric/network';
 import type { Remote } from '@agoric/vow';
-//# sourceMappingURL=chainAccountKit.d.ts.map
+//# sourceMappingURL=chain-account-kit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chain-account-kit.d.ts","sourceRoot":"","sources":["chain-account-kit.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;GAaG;AAeI;;QAqBC,8BAA8B;;;;;;;;QAiC9B;;;;;;;;;WASG;mLAHU,OAAO,CAAC,MAAM,CAAC;QAa5B,+BAA+B;;QAS/B;;;;WAIG;wBADQ,KAAK;;;QAQhB;;;;WAIG;;;;;GAyBR;qCAzJW,0BAA0B;;aAoB1B,MAAM;;;;4BAIS,MAAM;;;;8BAmIrB,UAAU,CAAC,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;0BAvK5C,mBAAmB;0BACP,iBAAiB;kCAKrB,aAAa;4BAFnB,8CAA8C;gCAHpC,iBAAiB;4BAC3B,aAAa"}

package/src/exos/{chainAccountKit.js → chain-account-kit.js}

@@ -131,7 +131,7 @@ export const prepareChainAccountKit = zone =>
         },
         /** Close the remote account */
         async close() {
-          /// XXX what should the behavior be here? and `onClose`?
+          // FIXME what should the behavior be here? and `onClose`?
           // - retrieve assets?
           // - revoke the port?
           const { connection } = this.state;
@@ -169,7 +169,7 @@ export const prepareChainAccountKit = zone =>
         },
         async onClose(_connection, reason) {
           trace(`ICA Channel closed. Reason: ${reason}`);
-          // XXX handle connection closing
+          // FIXME handle connection closing
           // XXX is there a scenario where a connection will unexpectedly close? _I think yes_
         },
         async onReceive(connection, bytes) {

package/src/exos/{cosmosOrchestrationAccount.d.ts → cosmos-orchestration-account.d.ts}

@@ -183,4 +183,4 @@ import type { CosmosValidatorAddress } from '../types.js';
 import type { DenomAmount } from '../types.js';
 import type { Delegation } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
 import type { DenomArg } from '../types.js';
-//# sourceMappingURL=cosmosOrchestrationAccount.d.ts.map
+//# sourceMappingURL=cosmos-orchestration-account.d.ts.map

package/src/exos/cosmos-orchestration-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmos-orchestration-account.d.ts","sourceRoot":"","sources":["cosmos-orchestration-account.js"],"names":[],"mappings":"AAmDA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH,mCAAmC;AACnC;;;;;;;;;;;;;;;GAqBG;AAOH,6CAGE;AAgBK,mGAgCsB,WAAW,GACnC,QAAI,OAAO,WAAW,EAAE,MAAM,CAAC,WACnC,CAAC,CAAC,0HApCQ,GAAG;;;;;;;;;;;QAuDN,wDAAwD;;;QAWxD;;;WAGG;;;;QAgBH;;;WAGG;;QASH;;;;WAIG;;QAaH,gDAAgD;;QAShD,kEAAkE;;;QAYlE;;;;WAIG;;;;;;;;;;;;;gBAtDH;;;mBAGG;;gBASH;;;;mBAIG;;gBAaH,gDAAgD;;gBAShD,kEAAkE;;;gBAYlE;;;;mBAIG;;;;;;;;;;;;QA2BH,8BAA8B;;QAI9B;;;;;WAKG;;;;QA2BH;;;;;;WAMG;;QAmBH;;;WAGG;;QAmBH;;;WAGG;;;;;;QA4CH,kEAAkE;;;GAgCzE;AAkBM,0IAvTsB,MAAM,wIAgTxB,GAAG,GACD,CACZ,GAAO,IAAI,EAAE,UAAU,CACvB,UAAgB,CAAC,OAAO,oCAAoC,CAAC,CACxD,KACE,6BAA6B,CAAC,QAAQ,CAAC,CAa9C;;;;;;;;;;;;;eAxZe,MAAM;;;4CA8XT,UAAU,CACtB,UAAc,CAAC,OAAO,oCAAoC,CAAC,CACxD;yCAyBU,6BAA6B,CAAC,QAAQ,CAAC;0BA1a9B,cAAc;iCALU,6CAA6C;kCADsE,aAAa;gCAAb,aAAa;4BAItJ,kBAAkB;kCACZ,cAAc;+BALqH,aAAa;0BAExJ,kDAAkD;4CAFyF,aAAa;iCAAb,aAAa;gCAGlJ,wDAAwD;8BAH6E,aAAa"}

package/src/exos/{icqConnectionKit.d.ts → icq-connection-kit.d.ts}

@@ -41,4 +41,4 @@ import type { JsonSafe } from '@agoric/cosmic-proto';
 import type { ResponseQuery } from '@agoric/cosmic-proto/tendermint/abci/types.js';
 import type { Connection } from '@agoric/network';
 import type { Remote } from '@agoric/vow';
-//# sourceMappingURL=icqConnectionKit.d.ts.map
+//# sourceMappingURL=icq-connection-kit.d.ts.map

package/src/exos/icq-connection-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icq-connection-kit.d.ts","sourceRoot":"","sources":["icq-connection-kit.js"],"names":[],"mappings":"AAoBA,2DAGE;AAEF;;;;GAIG;AA0BI;;;;QA4BC;;;;WAIG;;;;QAYH;;;;WAIG;;;;;GAgBR;;;;;;;+BAEW,UAAU,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;4BACtD,gBAAgB,CAAC,YAAY,CAAC;0BAjHrB,mBAAmB;0BACP,iBAAiB;kCAGN,+CAA+C;8BADlE,sBAAsB;mCACH,+CAA+C;gCAH1D,iBAAiB;4BAC3B,aAAa"}

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

@@ -0,0 +1,105 @@
+export function prepareLocalChainFacade(zone: Zone, { makeLocalOrchestrationAccountKit, localchain, storageNode }: {
+    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("./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>;
+        };
+    }>;
+    orchestration: Remote<import("@endo/exo").Guarded<{
+        makeAccount(chainId: string, hostConnectionId: `connection-${number}`, controllerConnectionId: `connection-${number}`): Promise<import("../cosmos-api.js").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>;
+    timer: Remote<TimerService>;
+    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]>;
+        }>; }>;
+    }>>;
+}): (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;
+    }>>;
+    /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
+    makeAccount(): Promise<import("../orchestration-api.js").OrchestrationAccountI>;
+}>;
+export type MakeLocalChainFacade = ReturnType<typeof prepareLocalChainFacade>;
+import type { Zone } from '@agoric/base-zone';
+import type { Remote } from '@agoric/internal';
+import type { TimerService } from '@agoric/time';
+import type { IBCConnectionInfo } from '../types.js';
+//# sourceMappingURL=local-chain-facade.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"local-chain-facade.d.ts","sourceRoot":"","sources":["local-chain-facade.js"],"names":[],"mappings":"AAyBO;;;;8BA0C6pC,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;;;;;;;;;;;;;;;;8BAAvxF,MAAM,KAAK,CAAC;6BAA6gB,QAAQ,KAAK,CAAC,mBAA6B,OAAO;6BAAwjB,OAAO,KAAK,CAAC;;;2BAA6rB,EAAE;;;;;;;oBAAqjG,CAAC;;;uBAA6lB,EAAE;;;;;;;;;;;;;;;;;;;;;IAtBloN,0DAA0D;;GAmB7D;mCAEW,UAAU,CAAC,OAAO,uBAAuB,CAAC;0BA5DjC,mBAAmB;4BAEjB,kBAAkB;kCADZ,cAAc;uCAKyC,aAAa"}

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

@@ -0,0 +1,67 @@
+/** @file ChainAccount exo */
+import { V } from '@agoric/vow/vat.js';
+
+import { ChainFacadeI } from '../typeGuards.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {TimerService} from '@agoric/time';
+ * @import {Remote} from '@agoric/internal';
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {MakeLocalOrchestrationAccountKit} from './local-orchestration-account.js';
+ * @import {ChainInfo, CosmosChainInfo, IBCConnectionInfo, OrchestrationAccount} from '../types.js';
+ */
+
+/**
+ * @param {Zone} zone
+ * @param {{
+ *   makeLocalOrchestrationAccountKit: MakeLocalOrchestrationAccountKit;
+ *   orchestration: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timer: Remote<TimerService>;
+ *   localchain: Remote<LocalChain>;
+ * }} powers
+ */
+export const prepareLocalChainFacade = (
+  zone,
+  { makeLocalOrchestrationAccountKit, localchain, storageNode },
+) =>
+  zone.exoClass(
+    'LocalChainFacade',
+    ChainFacadeI,
+    /**
+     * @param {CosmosChainInfo} localChainInfo
+     */
+    localChainInfo => {
+      return { localChainInfo };
+    },
+    {
+      async getChainInfo() {
+        return this.state.localChainInfo;
+      },
+
+      // FIXME parameterize on the remoteChainInfo to make()
+      // That used to work but got lost in the migration to Exo
+      /** @returns {Promise<OrchestrationAccount<ChainInfo>>} */
+      async makeAccount() {
+        const { localChainInfo } = this.state;
+        const lcaP = V(localchain).makeAccount();
+        const [lca, address] = await Promise.all([lcaP, V(lcaP).getAddress()]);
+        const { holder: account } = makeLocalOrchestrationAccountKit({
+          account: lca,
+          address: harden({
+            address,
+            chainId: localChainInfo.chainId,
+            addressEncoding: 'bech32',
+          }),
+          // FIXME storage path
+          storageNode,
+        });
+
+        return account;
+      },
+    },
+  );
+harden(prepareLocalChainFacade);
+/** @typedef {ReturnType<typeof prepareLocalChainFacade>} MakeLocalChainFacade */