@agoric/orchestration 0.1.1-calypso-dev-84eb287.0

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

@@ -0,0 +1,34 @@
+/** @type {ContractMeta<typeof start>} */
+export const meta: ContractMeta<typeof start>;
+export function makeNatAmountShape(brand: Brand, min?: bigint | undefined): {
+    brand: globalThis.Brand;
+    value: import("@endo/patterns").Matcher;
+};
+export function start(zcf: ZCF, privateArgs: {
+    agoricNames: Remote<NameHub>;
+    localchain: Remote<LocalChain>;
+    orchestrationService: Remote<OrchestrationService>;
+    storageNode: Remote<StorageNode>;
+    timerService: Remote<TimerService>;
+    marshaller: Marshaller;
+}, baggage: Baggage): Promise<{
+    publicFacet: {
+        makeSwapAndStakeInvitation: () => Promise<Invitation<unknown, {
+            staked: Amount<"nat">;
+            validator: CosmosValidatorAddress;
+        }>>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeSwapAndStakeInvitation: () => Promise<Invitation<unknown, {
+            staked: Amount<"nat">;
+            validator: CosmosValidatorAddress;
+        }>>;
+    }>;
+}>;
+import type { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { OrchestrationService } from '../service.js';
+import type { TimerService } from '@agoric/time';
+import type { Baggage } from '@agoric/vat-data';
+import type { CosmosValidatorAddress } from '../types.js';
+//# sourceMappingURL=swapExample.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swapExample.contract.d.ts","sourceRoot":"","sources":["swapExample.contract.js"],"names":[],"mappings":"AAoEA,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAWnC;AASK,0CAHI,KAAK;;;EAIsC;AAc/C,2BAXI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;IACvC,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;oBA+BD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;;oBAAhD,MAAM,CAAC,KAAK,CAAC;uBAAa,sBAAsB;;;GAsBhE;6BA1IyB,cAAc;4BAHf,kBAAkB;gCADd,gCAAgC;0CAEtB,eAAe;kCAHvB,cAAc;6BAInB,kBAAkB;4CALuB,aAAa"}

package/src/examples/swapExample.contract.js

@@ -0,0 +1,155 @@
+import { StorageNodeShape } from '@agoric/internal';
+import { TimerServiceShape } from '@agoric/time';
+import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
+import { Far } from '@endo/far';
+import { deeplyFulfilled } from '@endo/marshal';
+import { M, objectMap } from '@endo/patterns';
+import { orcUtils } from '../utils/orc.js';
+import { provideOrchestration } from '../utils/start-helper.js';
+
+/**
+ * @import {Orchestrator, IcaAccount, CosmosValidatorAddress} from '../types.js'
+ * @import {TimerService} from '@agoric/time';
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {Remote} from '@agoric/internal';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {Baggage} from '@agoric/vat-data'
+ * @import {NameHub} from '@agoric/vats';
+ */
+
+/**
+ * @param {Orchestrator} orch
+ * @param {object} ctx
+ * @param {ZCF} ctx.zcf
+ * @param {ZCFSeat} seat
+ * @param {object} offerArgs
+ * @param {Amount<'nat'>} offerArgs.staked
+ * @param {CosmosValidatorAddress} offerArgs.validator
+ */
+const stackAndSwapFn = async (orch, { zcf }, seat, offerArgs) => {
+  const { give } = seat.getProposal();
+
+  const omni = await orch.getChain('omniflixhub');
+  const agoric = await orch.getChain('agoric');
+
+  const [omniAccount, localAccount] = await Promise.all([
+    omni.makeAccount(),
+    agoric.makeAccount(),
+  ]);
+
+  const omniAddress = omniAccount.getAddress();
+
+  // deposit funds from user seat to LocalChainAccount
+  const payments = await withdrawFromSeat(zcf, seat, give);
+  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
+  const transferMsg = orcUtils.makeOsmosisSwap({
+    destChain: 'omniflixhub',
+    destAddress: omniAddress,
+    amountIn: give.Stable,
+    brandOut: /** @type {any} */ ('FIXME'),
+    slippage: 0.03,
+  });
+
+  await localAccount
+    .transferSteps(give.Stable, transferMsg)
+    .then(_txResult =>
+      omniAccount.delegate(offerArgs.validator, offerArgs.staked),
+    )
+    .catch(e => console.error(e));
+};
+
+/** @type {ContractMeta<typeof start>} */
+export const meta = {
+  privateArgsShape: {
+    agoricNames: M.remotable('agoricNames'),
+    localchain: M.remotable('localchain'),
+    orchestrationService: M.or(M.remotable('orchestration'), null),
+    storageNode: StorageNodeShape,
+    marshaller: M.remotable('marshaller'),
+    timerService: M.or(TimerServiceShape, null),
+  },
+  upgradability: 'canUpgrade',
+};
+harden(meta);
+
+// XXX copied from inter-protocol
+// TODO move to new `@agoric/contracts` package when we have it
+/**
+ * @param {Brand} brand must be a 'nat' brand, not checked
+ * @param {NatValue} [min]
+ */
+export const makeNatAmountShape = (brand, min) =>
+  harden({ brand, value: min ? M.gte(min) : M.nat() });
+
+/**
+ * @param {ZCF} zcf
+ * @param {{
+ *   agoricNames: Remote<NameHub>;
+ *   localchain: Remote<LocalChain>;
+ *   orchestrationService: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timerService: Remote<TimerService>;
+ *   marshaller: Marshaller;
+ * }} privateArgs
+ * @param {Baggage} baggage
+ */
+export const start = async (zcf, privateArgs, baggage) => {
+  const {
+    agoricNames,
+    localchain,
+    orchestrationService,
+    storageNode,
+    timerService,
+    marshaller,
+  } = privateArgs;
+
+  const { orchestrate } = provideOrchestration(
+    zcf,
+    baggage,
+    {
+      agoricNames,
+      localchain,
+      orchestrationService,
+      storageNode,
+      timerService,
+    },
+    marshaller,
+  );
+
+  const { brands } = zcf.getTerms();
+
+  /** deprecated historical example */
+  /**
+   * @type {OfferHandler<
+   *   unknown,
+   *   { staked: Amount<'nat'>; validator: CosmosValidatorAddress }
+   * >}
+   */
+  const swapAndStakeHandler = orchestrate('LSTTia', { zcf }, stackAndSwapFn);
+
+  const makeSwapAndStakeInvitation = () =>
+    zcf.makeInvitation(
+      swapAndStakeHandler,
+      'Swap for TIA and stake',
+      undefined,
+      harden({
+        give: { Stable: makeNatAmountShape(brands.Stable, 1n) },
+        want: {}, // XXX ChainAccount Ownable?
+        exit: M.any(),
+      }),
+    );
+
+  const publicFacet = Far('SwapAndStake Public Facet', {
+    makeSwapAndStakeInvitation,
+  });
+
+  return harden({ publicFacet });
+};

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

@@ -0,0 +1,21 @@
+export function start(zcf: ZCF, privateArgs: {
+    agoricNames: Remote<NameHub>;
+    localchain: Remote<LocalChain>;
+    orchestrationService: Remote<OrchestrationService>;
+    storageNode: Remote<StorageNode>;
+    marshaller: Marshaller;
+    timerService: Remote<TimerService>;
+}, baggage: Baggage): Promise<{
+    publicFacet: {
+        makeUnbondAndLiquidStakeInvitation: () => Promise<Invitation<unknown, never>>;
+    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeUnbondAndLiquidStakeInvitation: () => Promise<Invitation<unknown, never>>;
+    }>;
+}>;
+import type { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { OrchestrationService } from '../service.js';
+import type { TimerService } from '@agoric/time';
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=unbondExample.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unbondExample.contract.d.ts","sourceRoot":"","sources":["unbondExample.contract.js"],"names":[],"mappings":"AAwDO,2BAXI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,oBAAwB,EAAE,OAAO,oBAAoB,CAAC,CAAC;IACvD,WAAe,EAAE,OAAO,WAAW,CAAC,CAAC;IACrC,UAAc,EAAE,UAAU,CAAC;IAC3B,YAAgB,EAAE,OAAO,YAAY,CAAC,CAAC;CACpC,WACO,OAAO;;;;;;GAkDjB;6BA/FyB,cAAc;4BACf,kBAAkB;gCAFd,gCAAgC;0CAGtB,eAAe;kCALvB,cAAc;6BACnB,kBAAkB"}

package/src/examples/unbondExample.contract.js

@@ -0,0 +1,105 @@
+import { Far } from '@endo/far';
+import { M } from '@endo/patterns';
+import { provideOrchestration } from '../utils/start-helper.js';
+
+/**
+ * @import {Orchestrator, IcaAccount, CosmosValidatorAddress} from '../types.js'
+ * @import {TimerService} from '@agoric/time';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Remote} from '@agoric/internal';
+ * @import {OrchestrationService} from '../service.js';
+ */
+
+/**
+ * @param {Orchestrator} orch
+ * @param {object} ctx
+ * @param {ZCF} ctx.zcf
+ * @param {ZCFSeat} _seat
+ * @param {undefined} _offerArgs
+ */
+const unbondAndLiquidStakeFn = async (orch, { zcf }, _seat, _offerArgs) => {
+  console.log('zcf within the membrane', zcf);
+  // We would actually alreaady have the account from the orchestrator
+  // ??? could these be passed in? It would reduce the size of this handler,
+  // keeping it focused on long-running operations.
+  const omni = await orch.getChain('omniflixhub');
+  const omniAccount = await omni.makeAccount();
+
+  // TODO implement these
+  // const delegations = await celestiaAccount.getDelegations();
+  // // wait for the undelegations to be complete (may take weeks)
+  // await celestiaAccount.undelegate(delegations);
+  // ??? should this be synchronous? depends on how names are resolved.
+  const stride = await orch.getChain('stride');
+  const strideAccount = await stride.makeAccount();
+
+  // TODO the `TIA` string actually needs to be the Brand from AgoricNames
+  // const tiaAmt = await celestiaAccount.getBalance('TIA');
+  // await celestiaAccount.transfer(tiaAmt, strideAccount.getAddress());
+  // await strideAccount.liquidStake(tiaAmt);
+  console.log(omniAccount, strideAccount);
+};
+
+/**
+ * @param {ZCF} zcf
+ * @param {{
+ *   agoricNames: Remote<NameHub>;
+ *   localchain: Remote<LocalChain>;
+ *   orchestrationService: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   marshaller: Marshaller;
+ *   timerService: Remote<TimerService>;
+ * }} privateArgs
+ * @param {Baggage} baggage
+ */
+export const start = async (zcf, privateArgs, baggage) => {
+  const {
+    agoricNames,
+    localchain,
+    orchestrationService,
+    storageNode,
+    marshaller,
+    timerService,
+  } = privateArgs;
+
+  const { orchestrate } = provideOrchestration(
+    zcf,
+    baggage,
+    {
+      agoricNames,
+      localchain,
+      orchestrationService,
+      storageNode,
+      timerService,
+    },
+    marshaller,
+  );
+
+  /** @type {OfferHandler} */
+  const unbondAndLiquidStake = orchestrate(
+    'LSTTia',
+    { zcf },
+    unbondAndLiquidStakeFn,
+  );
+
+  const makeUnbondAndLiquidStakeInvitation = () =>
+    zcf.makeInvitation(
+      unbondAndLiquidStake,
+      'Unbond and liquid stake',
+      undefined,
+      harden({
+        // Nothing to give; the funds come from undelegating
+        give: {},
+        want: {}, // XXX ChainAccount Ownable?
+        exit: M.any(),
+      }),
+    );
+
+  const publicFacet = Far('SwapAndStake Public Facet', {
+    makeUnbondAndLiquidStakeInvitation,
+  });
+
+  return harden({ publicFacet });
+};

package/src/exos/README.md

@@ -0,0 +1,56 @@
+# Exo structure
+
+As of 2024-05-29…
+
+```mermaid
+classDiagram
+
+%% Orchestration vat business logic (Zoe)
+    LCAKit --* LocalchainAccount
+    ICQConnectionKit --* Port
+    ICQConnectionKit --* Connection
+    ChainAccountKit --* Port
+    ChainAccountKit --* Connection
+    StakingAccountKit --* IcaAccount
+
+    class ChainAccountKit {
+      port: Port
+      connection: Connection
+      localAddress: LocalIbcAddress
+      requestedRemoteAddress: string
+      remoteAddress: RemoteIbcAddress
+      chainAddress: ChainAddress
+    }
+    class ICQConnectionKit {
+      port: Port
+      connection: Connection
+      localAddress: LocalIbcAddress
+      remoteAddress: RemoteIbcAddress
+    }
+    class StakingAccountKit {
+      chainAddress: ChainAddress 
+      bondDenom: string 
+      account: ICAAccount 
+      timer: Timer
+      topicKit: TopicKit
+      makeTransferInvitation()
+    }
+
+%% In other vats
+    class LCAKit {
+        account: LocalChainAccount
+        address: ChainAddress
+        topicKit: RecorderKit<LocalChainAccountNotification>
+    }
+    class LocalchainAccount {
+        executeTx()
+        deposit()
+        withdraw()
+    }
+    class IcaAccount {
+        executeTx()
+        deposit()
+        getPurse()
+        close()
+    }
+```

package/src/exos/agoric-names-tools.d.ts

@@ -0,0 +1,27 @@
+export function makeResumableAgoricNamesHack(zone: Zone, { agoricNames, vowTools: { watch, asVow } }: {
+    agoricNames: Remote<NameHub>;
+    vowTools: VowTools;
+}): import("@endo/exo").Guarded<{
+    /** @param {...string} args */
+    lookup(...args: string[]): Vow<any>;
+    /**
+     * Look up asset info, like denom, in agoricNames.vbankAsset using a
+     * Brand.
+     *
+     * Caches the query to agoricNames in the first call. Subsequent lookups
+     * are via cache unless a refetch is specified or a brand is not found.
+     *
+     * @param {Brand<'nat'>} brand
+     * @param {boolean} [refetch] if true, will invalidate the cache
+     * @returns {Vow<AssetInfo>}
+     */
+    findBrandInVBank(brand: Brand<"nat">, refetch?: boolean | undefined): Vow<AssetInfo>;
+}>;
+export type AgNamesTools = ReturnType<typeof makeResumableAgoricNamesHack>;
+import type { Zone } from '@agoric/zone';
+import type { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { VowTools } from '@agoric/vow';
+import type { Vow } from '@agoric/vow';
+import type { AssetInfo } from '@agoric/vats/src/vat-bank.js';
+//# sourceMappingURL=agoric-names-tools.d.ts.map

package/src/exos/agoric-names-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agoric-names-tools.d.ts","sourceRoot":"","sources":["agoric-names-tools.js"],"names":[],"mappings":"AA4BO,mDAHI,IAAI,+CACJ;IAAE,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE;IA8CvD,8BAA8B;oBAAf,MAAM,EAAA;IAIrB;;;;;;;;;;OAUG;4BAHQ,KAAK,CAAC,KAAK,CAAC,kCAEV,IAAI,SAAS,CAAC;GAsBlC;2BACa,UAAU,CAAC,OAAO,4BAA4B,CAAC;0BAhGtC,cAAc;6BAJX,cAAc;4BAEf,kBAAkB;8BACX,aAAa;yBAAb,aAAa;+BAFjB,8BAA8B"}

package/src/exos/agoric-names-tools.js

@@ -0,0 +1,109 @@
+import { VowShape } from '@agoric/vow';
+import { E } from '@endo/far';
+import { M, makeCopyMap } from '@endo/patterns';
+import { BrandShape } from '@agoric/ertp';
+
+const { Fail } = assert;
+
+/**
+ * @import {NameHub} from '@agoric/vats';
+ * @import {AssetInfo} from '@agoric/vats/src/vat-bank.js';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Vow, VowTools} from '@agoric/vow';
+ * @import {Zone} from '@agoric/zone';
+ */
+
+/**
+ * Perform remote calls to agoricNames in membrane-friendly way. This is an
+ * interim approach until https://github.com/Agoric/agoric-sdk/issues/9541,
+ * https://github.com/Agoric/agoric-sdk/pull/9322, or
+ * https://github.com/Agoric/agoric-sdk/pull/9519.
+ *
+ * XXX only works once per zone.
+ *
+ * XXX consider exposing `has`, `entries`, `keys`, `values` from `NameHub`
+ *
+ * @param {Zone} zone
+ * @param {{ agoricNames: Remote<NameHub>; vowTools: VowTools }} powers
+ */
+export const makeResumableAgoricNamesHack = (
+  zone,
+  { agoricNames, vowTools: { watch, asVow } },
+) => {
+  const makeResumableAgoricNamesHackKit = zone.exoClassKit(
+    'ResumableAgoricNamesHack',
+    {
+      public: M.interface('ResumableAgoricNamesHackI', {
+        lookup: M.call().rest(M.arrayOf(M.string())).returns(VowShape),
+        findBrandInVBank: M.call(BrandShape)
+          .optional(M.boolean())
+          .returns(VowShape),
+      }),
+      vbankAssetEntriesWatcher: M.interface('vbankAssetEntriesWatcher', {
+        onFulfilled: M.call(M.arrayOf(M.record()))
+          .optional(BrandShape)
+          .returns(VowShape),
+      }),
+    },
+    () => ({
+      vbankAssetsByBrand: zone.mapStore('vbankAssetsByBrand', {
+        keyShape: BrandShape,
+        valueShape: M.any(),
+      }),
+    }),
+    {
+      vbankAssetEntriesWatcher: {
+        /**
+         * @param {AssetInfo[]} assets
+         * @param {Brand<'nat'>} brand
+         */
+        onFulfilled(assets, brand) {
+          return asVow(() => {
+            const { vbankAssetsByBrand } = this.state;
+            vbankAssetsByBrand.addAll(
+              makeCopyMap(assets.map(a => [a.brand, a])),
+            );
+            vbankAssetsByBrand.has(brand) ||
+              Fail`brand ${brand} not in agoricNames.vbankAsset`;
+            return vbankAssetsByBrand.get(brand);
+          });
+        },
+      },
+      public: {
+        /** @param {...string} args */
+        lookup(...args) {
+          return watch(E(agoricNames).lookup(...args));
+        },
+        /**
+         * Look up asset info, like denom, in agoricNames.vbankAsset using a
+         * Brand.
+         *
+         * Caches the query to agoricNames in the first call. Subsequent lookups
+         * are via cache unless a refetch is specified or a brand is not found.
+         *
+         * @param {Brand<'nat'>} brand
+         * @param {boolean} [refetch] if true, will invalidate the cache
+         * @returns {Vow<AssetInfo>}
+         */
+        findBrandInVBank(brand, refetch) {
+          return asVow(() => {
+            const { vbankAssetsByBrand } = this.state;
+            if (vbankAssetsByBrand.has(brand) && !refetch) {
+              return vbankAssetsByBrand.get(brand);
+            }
+            const vbankAssetNameHubP = E(agoricNames).lookup('vbankAsset');
+            const vbankAssetEntriesP = E(vbankAssetNameHubP).values();
+            return watch(
+              vbankAssetEntriesP,
+              this.facets.vbankAssetEntriesWatcher,
+              brand,
+            );
+          });
+        },
+      },
+    },
+  );
+  // XXX only works once per zone.
+  return makeResumableAgoricNamesHackKit().public;
+};
+/** @typedef {ReturnType<typeof makeResumableAgoricNamesHack>} AgNamesTools */

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

@@ -0,0 +1,88 @@
+export const ChainAccountI: import("@endo/patterns").InterfaceGuard<{
+    getAddress: import("@endo/patterns").MethodGuard;
+    getBalance: import("@endo/patterns").MethodGuard;
+    getBalances: import("@endo/patterns").MethodGuard;
+    getLocalAddress: import("@endo/patterns").MethodGuard;
+    getRemoteAddress: import("@endo/patterns").MethodGuard;
+    getPort: import("@endo/patterns").MethodGuard;
+    executeTx: import("@endo/patterns").MethodGuard;
+    executeEncodedTx: import("@endo/patterns").MethodGuard;
+    close: import("@endo/patterns").MethodGuard;
+    getPurse: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareChainAccountKit(zone: Zone, { watch, asVow }: VowTools): (chainId: string, port: Port, requestedRemoteAddress: string) => import("@endo/exo").GuardedKit<{
+    parseTxPacketWatcher: {
+        /** @param {string} ack */
+        onFulfilled(ack: string): string;
+    };
+    account: {
+        /** @returns {ChainAddress} */
+        getAddress(): ChainAddress;
+        getBalance(_denom: any): Vow<never>;
+        getBalances(): Vow<never>;
+        getLocalAddress(): `/ibc-port/${string}`;
+        getRemoteAddress(): `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`;
+        getPort(): Port;
+        executeTx(): Vow<never>;
+        /**
+         * Submit a transaction on behalf of the remote account for execution on
+         * the remote chain.
+         *
+         * @param {AnyJson[]} msgs
+         * @param {Omit<TxBody, 'messages'>} [opts]
+         * @returns {Vow<string>} - base64 encoded bytes string. Can be decoded
+         *   using the corresponding `Msg*Response` object.
+         * @throws {Error} if packet fails to send or an error is returned
+         */
+        executeEncodedTx(msgs: AnyJson[], opts?: Omit<TxBody, "messages"> | undefined): Vow<string>;
+        /**
+         * Close the remote account
+         *
+         * @returns {Vow<void>}
+         * @throws {Error} if connection is not available or already closed
+         */
+        close(): Vow<void>;
+        /**
+         * get Purse for a brand to .withdraw() a Payment from the account
+         *
+         * @param {Brand} brand
+         */
+        getPurse(brand: Brand): Vow<never>;
+    };
+    connectionHandler: {
+        /**
+         * @param {Remote<Connection>} connection
+         * @param {LocalIbcAddress} localAddr
+         * @param {RemoteIbcAddress} remoteAddr
+         */
+        onOpen(connection: Remote<Connection>, localAddr: LocalIbcAddress, remoteAddr: RemoteIbcAddress): Promise<void>;
+        /**
+         * @param {Remote<Connection>} _connection
+         * @param {unknown} reason
+         */
+        onClose(_connection: Remote<Connection>, reason: unknown): Promise<void>;
+    };
+}>;
+export type UnparsableChainAddress = "UNPARSABLE_CHAIN_ADDRESS";
+export type State = {
+    chainId: string;
+    port: Port;
+    connection: Remote<Connection> | undefined;
+    localAddress: LocalIbcAddress | undefined;
+    requestedRemoteAddress: string;
+    remoteAddress: RemoteIbcAddress | undefined;
+    chainAddress: ChainAddress | undefined;
+};
+export type ChainAccountKit = ReturnType<ReturnType<typeof prepareChainAccountKit>>;
+import type { Zone } from '@agoric/base-zone';
+import type { VowTools } from '@agoric/vow';
+import type { Port } from '@agoric/network';
+import type { ChainAddress } from '../types.js';
+import type { Vow } from '@agoric/vow';
+import type { AnyJson } from '@agoric/cosmic-proto';
+import type { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+import type { Connection } from '@agoric/network';
+import type { Remote } from '@agoric/vow';
+import type { LocalIbcAddress } from '@agoric/vats/tools/ibc-utils.js';
+import type { RemoteIbcAddress } from '@agoric/vats/tools/ibc-utils.js';
+//# 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;AAkBI,6CAHI,IAAI,oBACJ,QAAQ;;QA+BX,0BAA0B;yBAAd,MAAM;;;QAMlB,8BAA8B;sBAAhB,YAAY;;;;;;;QAmC1B;;;;;;;;;WASG;+BALQ,OAAO,EAAE,gDAEP,IAAI,MAAM,CAAC;QAcxB;;;;;WAKG;iBAFU,IAAI,IAAI,CAAC;QAatB;;;;WAIG;wBADQ,KAAK;;;QAQhB;;;;WAIG;2BAHQ,OAAO,UAAU,CAAC,aAClB,eAAe,cACf,gBAAgB;QAe3B;;;WAGG;6BAFQ,OAAO,UAAU,CAAC,UAClB,OAAO;;GASvB;qCApLW,0BAA0B;oBAmB3B;IACZ,OAAW,EAAE,MAAM,CAAC;IACpB,IAAQ,EAAE,IAAI,CAAC;IACf,UAAc,EAAE,OAAO,UAAU,CAAC,GAAG,SAAS,CAAC;IAC/C,YAAgB,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9C,sBAA0B,EAAE,MAAM,CAAC;IACnC,aAAiB,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAChD,YAAgB,EAAE,YAAY,GAAG,SAAS,CAAC;CACxC;8BA2JU,UAAU,CAAC,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;0BAlM5C,mBAAmB;8BAEF,aAAa;0BADlB,iBAAiB;kCAKrB,aAAa;yBAJJ,aAAa;6BAC3B,sBAAsB;4BACvB,8CAA8C;gCAHpC,iBAAiB;4BACZ,aAAa;qCAGD,iCAAiC;sCAAjC,iCAAiC"}